CUVI Wiki - User contributions [en]

Function:FftShift

2014-06-18T06:50:24Z

Ghazanfar: Created page with "__NOTOC__ Repositions the quadrants of the fft image, so that the zero frequency components of the fft are at the center of the image. This is useful for visualizing the Fouri..."

__NOTOC__
Repositions the quadrants of the fft image, so that the zero frequency components of the fft are at the center of the image. This is useful for visualizing the Fourier transform.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus fftShift(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input image
|-
| dst
| CuviImage&
| Output image with diagonal quadrants swapped
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 32f
| 32f
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage input = cuvi:io::loadImage(path), fftImage, fftShifted;

//Computing the Fourier Transform
cuvi::imageTransforms::fft2(input,fftImage);

//Shift the fft
cuvi::imageTransforms::fftShift(fftImage, fftShifted);

</syntaxhighlight>
|}

Function:FftGetProperty

2014-06-18T06:41:10Z

Ghazanfar: Created page with "__NOTOC__ Gets different properties of fft of an image. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus fftGetProperty(const CuviImage& src..."

__NOTOC__
Gets different properties of fft of an image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus fftGetProperty(const CuviImage& src,
CuviImage& dst,
const CuviFFTProp prop,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input FFT image
|-
| dst
| CuviImage&
| Output image containing the specified property
|-
| prop
| const CuviFFTProp
| The property of FFT to get.
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 32fC2
| 32fC1
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage input = cuvi:io::loadImage(path), fftImage, magnitude;

//Computing the Fourier Transform
cuvi::imageTransforms::fft2(input,fftImage);

//Compute the magnitude of fft
cuvi::imageTransforms::fftGetProperty(fftImage, magnitude, CUVI_FFT_MAGNITUDE);

</syntaxhighlight>
|}

Function:Fft2

2014-06-18T06:30:33Z

Ghazanfar:

__NOTOC__
Computes the 2D Fast Fourier Transform of the input image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus fft2(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image

|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 32fC2
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

//Computing the Fourier Transform
cuvi::imageTransforms::fft2(gimg,gout);

</syntaxhighlight>
|}

Function:CuviMotionEstimator

2014-06-17T11:21:25Z

Ghazanfar: Created page with "===CuviMotionEstimator=== A class to estimate translation motion between 2 frames. * CuviMotionEstimator() - Default constructor. Creates empty CuviMotionEstimator object. * C..."

===CuviMotionEstimator===
A class to estimate translation motion between 2 frames.
* CuviMotionEstimator() - Default constructor. Creates empty CuviMotionEstimator object.
* CuviMotionEstimator(CuviMotionModel model = CUVI_MOTION_DEFAULT) - Creates a CuviMotionEstimator object to estimate the specified type of motion. Currently, only translation motion is supported.
* ~CuviMotionEstimator() - Destructor.
* CuviStatus estimate(const CuviImage& frame0, const CuviImage& frame1, Theta& motion) const; - Estimate the global motion vector between 2 frames.
{|class="wikitable"
|-
! Name
! Type
! Description
|-
| frame0
| const CuviImage&
| First input frame
|-
| frame1
| const CuviImage&
| Second input frame
|-
| motion
| Theta&
| Output global motion vector
|}

===Image Type Support===

{| class="wikitable"
|-
! Input
|-
| 8uC3
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Create CuviMotionEstimator object
cuvi::videostab::CuviMotionEstimator estimator;

//Load images
CuviImage first = cuvi::io::loadImage(path, CUVI_LOAD_IMAGE_COLOR);
CuviImage second = cuvi::io::loadImage(path, CUVI_LOAD_IMAGE_COLOR);

cuvi::videostab::Theta theta;

estimator.estimate(first, second, theta);

std::cout<<"Dx = "<<theta.dx()<<"\nDy = "<<theta.dy()<<std::endl;

</syntaxhighlight>
|}

Function:CuviVideoStabilizer

2014-06-17T11:02:58Z

Ghazanfar: /* Example */

===CuviVideoStabilizer===
A class to perform stabilization of a video file
* CuviVideoStabilizer() - Default constructor. Creates empty CuviVideoStabilizer object.
* CuviVideoStabilizer(const std::string& path, CuviMotionModel model = CUVI_MOTION_DEFAULT) - Creates a CuviVideoStabilizer object from the specified video file. Calls create.
* ~CuviVideoStabilizer() - Destructor. Calls release.
* CuviStatus create(const std::string& path, CuviMotionModel model = CUVI_MOTION_DEFAULT) - Creates a CuviVideoStabilizer object from the specified video file.
{|class="wikitable"
|-
! Name
! Type
! Description
|-
| path
| const std::string&
| Path of the input video file
|-
| model
| CuviMotionModel
| Type of motion to compensate.
|}
* void release(). Frees the CuviVideoStabilizer object.
* CuviStatus getNextStabilizedFrame(CuviImage& stabilized) const; - Stabilize and return the next video frame.
{|class="wikitable"
|-
! Name
! Type
! Description
|-
| stabilized
| CuviImage&
| Output stabilized frame.
|}
* Cuvi32s width() const; - Returns width of the video frame.
* Cuvi32s height() const; - Returns height of the video frame.
* Cuvi32s numFrames() const; - Returns number of frames in the video.
* Cuvi64f fps() const; - Returns frame rate of the video.

===Image Type Support===

{| class="wikitable"
|-
! Output
|-
| 8uC3
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating Video Stabilizer Object
CuviVideoStabilizer stabilizer(path);

CuviImage stabilized;

//Loop over all frames and visualize the stabilized video
for(int i=0; i<stab.numFrames(); i++)
{
stabilizer.getNextStabilizedFrame(stabilized);

cuvi::showImage("Stabilized Video", stabilized);
cuvi::waitKeyPress(10);
}

</syntaxhighlight>
|}

Function:CuviVideoStabilizer

2014-06-17T10:54:55Z

Ghazanfar:

===CuviVideoStabilizer===
A class to perform stabilization of a video file
* CuviVideoStabilizer() - Default constructor. Creates empty CuviVideoStabilizer object.
* CuviVideoStabilizer(const std::string& path, CuviMotionModel model = CUVI_MOTION_DEFAULT) - Creates a CuviVideoStabilizer object from the specified video file. Calls create.
* ~CuviVideoStabilizer() - Destructor. Calls release.
* CuviStatus create(const std::string& path, CuviMotionModel model = CUVI_MOTION_DEFAULT) - Creates a CuviVideoStabilizer object from the specified video file.
{|class="wikitable"
|-
! Name
! Type
! Description
|-
| path
| const std::string&
| Path of the input video file
|-
| model
| CuviMotionModel
| Type of motion to compensate.
|}
* void release(). Frees the CuviVideoStabilizer object.
* CuviStatus getNextStabilizedFrame(CuviImage& stabilized) const; - Stabilize and return the next video frame.
{|class="wikitable"
|-
! Name
! Type
! Description
|-
| stabilized
| CuviImage&
| Output stabilized frame.
|}
* Cuvi32s width() const; - Returns width of the video frame.
* Cuvi32s height() const; - Returns height of the video frame.
* Cuvi32s numFrames() const; - Returns number of frames in the video.
* Cuvi64f fps() const; - Returns frame rate of the video.

===Image Type Support===

{| class="wikitable"
|-
! Output
|-
| 8uC3
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating Video Stabilizer Object
CuviVideoStabilizer stabilizer(path);

CuviImage stabilized;

//Loop over all frames and visualize the stabilized video
for(int i=0; i<stab.numFrames(); i++)
{
stabilizer.getNextStabilizedFrame(stabilized);

cuvi::showImage(window, stabilized);
cuvi::waitKeyPress(10);
}

</syntaxhighlight>
|}

Function:CuviVideoStabilizer

2014-06-17T10:46:36Z

Ghazanfar:

Function:CuviVideoStabilizer

2014-06-17T10:21:57Z

Ghazanfar: Created page with "===CuviVideoStabilizer=== A class to perform stabilization of a video file * CuviVideoStabilizer(); - Default constructor. Creates empty CuviVideoStabilizer object."

===CuviVideoStabilizer===
A class to perform stabilization of a video file
* CuviVideoStabilizer(); - Default constructor. Creates empty CuviVideoStabilizer object.

Function:Fft2

2014-06-16T07:37:51Z

Ghazanfar: Created page with "__NOTOC__ Computes the 2D Fast Fourier Transform of the input image. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus fft2(const CuviImage& ..."

__NOTOC__
Computes the 2D Fast Fourier Transform of the input image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus fft2(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image

|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 32fC1
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

//Computing the Fourier Transform
cuvi::imageTransforms::fft2(gimg,gout);

</syntaxhighlight>
|}

Function:Resize

2014-06-16T07:10:30Z

Ghazanfar: /* Parameters */

__NOTOC__
Re-sizes input image to fit into the output image size.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus resize(const CuviImage& src,
CuviImage& dst,
CuviInterpolationType inter = CUVI_INTER_LINEAR,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}

===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| inter
| CuviInterpolationType
| Type of interpolation to use for re-sizing. Supports:
{|
|CUVI_INTER_NN
|-
|CUVI_INTER_LINEAR
|-
|CUVI_INTER_CUBIC
|}
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
|-
| 32fC1
| 32fC1
|-
| 32fC3
| 32fC3
|}

===Samples===
{|
|-
|[[File:Resizein1.jpg|frame|Input Image (Width = W, Height = H)]]
|[[File:Resizeout1.jpg|frame| Resized Image (width =0.78625*W, height= 0.78625*H)]]
|-
|[[File:Resizein2.jpg|frame|Input Image (Width = W, Height = H)]]
|[[File:Resizeout2.jpg|frame| Resized Image (width = 1.2*W, height= 1.75*H)]]

|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path);

const Cuvi32f xScale = 0.5f, yScale = 0.7f;

const Cuvi32s newWidth = static_cast<Cuvi32s>(gimg.width() * xScale);
const Cuvi32s newHeight = static_cast<Cuvi32s>(gimg.height() * yScale);

CuviImage gout(newWidth,newHeight,gimg.type());

//Re-sizing input image to fit output container using bicubic interpolation
cuvi::geometryTransforms::resize(gimg,gout, CUVI_INTER_CUBIC);

</syntaxhighlight>
|}

Function:Resize

2014-06-16T07:09:19Z

Ghazanfar: /* Parameters */

__NOTOC__
Re-sizes input image to fit into the output image size.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus resize(const CuviImage& src,
CuviImage& dst,
CuviInterpolationType inter = CUVI_INTER_LINEAR,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}

===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| inter
| CuviInterpolationType
| Type of interpolation to use for re-sizing
| Supports:
{|
|CUVI_INTER_NN
|-
|CUVI_INTER_LINEAR
|-
|CUVI_INTER_CUBIC
|}
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
|-
| 32fC1
| 32fC1
|-
| 32fC3
| 32fC3
|}

===Samples===
{|
|-
|[[File:Resizein1.jpg|frame|Input Image (Width = W, Height = H)]]
|[[File:Resizeout1.jpg|frame| Resized Image (width =0.78625*W, height= 0.78625*H)]]
|-
|[[File:Resizein2.jpg|frame|Input Image (Width = W, Height = H)]]
|[[File:Resizeout2.jpg|frame| Resized Image (width = 1.2*W, height= 1.75*H)]]

|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path);

const Cuvi32f xScale = 0.5f, yScale = 0.7f;

const Cuvi32s newWidth = static_cast<Cuvi32s>(gimg.width() * xScale);
const Cuvi32s newHeight = static_cast<Cuvi32s>(gimg.height() * yScale);

CuviImage gout(newWidth,newHeight,gimg.type());

//Re-sizing input image to fit output container using bicubic interpolation
cuvi::geometryTransforms::resize(gimg,gout, CUVI_INTER_CUBIC);

</syntaxhighlight>
|}

Function:TrackFeatures

2014-06-16T06:50:54Z

Ghazanfar:

__NOTOC__
CUVI Feature tracker tracks input features from frame 1 onto frame 2. The function is ideal for tracking selected number of features through an image sequence or a video stream. This is a custom algorithm and does not use optical flows to estimate motion. Check out Motion Estimate section for more details on Optical Flow based motion tracking.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus trackFeatures(const CuviImage& previous,
const CuviImage& next,
CuviPointValue2D<Cuvi32f,Cuvi32f>* inputFeatures,
CuviPointValue2D<Cuvi32f,Cuvi32f>*& trackedFeatures,
const Cuvi32s featureCount,
CuviTrackingCriteria criteria,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}

===Parameters===
{|class="wikitable"
|-
! Name
! Type
! Description
|-
| previous
| const CuviImage&
| The first image whose features are to be tracked
|-
| next
| const CuviImage&
| Second image, in which to look for features of first image
|-
| inputFeatures
| CuviPointValue2D<Cuvi32f,Cuvi32f>*
| Feature of first image
|-
| trackedFeatures
| CuviPointValue2D<Cuvi32f,Cuvi32f>*&
| Output feature list containing the location of tracked features from first image onto second image
|-
| featureCount
| const Cuvi32s
| Number of features to track
|-
| criteria
| CuviFeaturesCriteria
| A structure containing various parameters that affect feature tracking behavior
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| CuviPointValue2D
|}

===Samples===
{|
|-
|[[File:Frame0.jpg|frame]]
|[[File:Frame1.jpg|frame|]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Image size
CuviSize size = cuviSize(img1->width,img1->height);

//Create two 8-bit Grays-scale CuviImage objects
CuviImage gimg1 = cuvi::io::loadImage(path, CUVI_LOAD_IMAGE_GRAYSCALE);
CuviImage gimg2 = cuvi::io::loadImage(path, CUVI_LOAD_IMAGE_GRAYSCALE);

CuviPointValue2D* features1, *features2;

//selection and tracking criteria
CuviFeaturesCriteria fc(CUVI_FEATURES_HARRIS,0.006f,22);
CuviTrackingCriteria tc(2,CuviSize(12,12),15,10.0f);

//ROI for selection
CuviRect roi(0,0,gimg1.width(),gimg1.height());

int featureCount = 50;

//Select Features
cuvi::computerVision::goodFeaturesToTrack(gimg1,roi,features1,featureCount,fc);

//Track the selected features from first frame onto second frame
cuvi::computerVision::trackFeatures(gimg1,gimg2,features1,features2,featureCount,tc);

</syntaxhighlight>
|}

Function:YUV2RGB

2014-06-16T06:38:26Z

Ghazanfar:

__NOTOC__
Convert YUV color model to an RGB image
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus yuv2rgb(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}

===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input YUV image
|-
| dst
| CuviImage&
| Output RGB image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC3
|-
| 16uC3
| 16uC3
|}

===Sample===
{|
|-
|[[File:YUV_RGB_In.jpg|frame|YUV Image]]
|[[File:YUV_RGB_Out.jpg|frame|RGB Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage input = cuvi::io::loadImage(path), output;

//Convert YUV image to RGB
cuvi::colorOperations::yuv2rgb(input,output);

</syntaxhighlight>
|}

Function:RGB2Gray

2014-06-16T06:34:26Z

Ghazanfar:

__NOTOC__
Converts an RGB image to gray scale using fixed or custom transform coefficients
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus rgb2gray(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());

CuviStatus rgb2gray(const CuviImage& src,
CuviImage& dst,
const CuviScalar& coeffs,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}

===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| CuviImage&
| Input 3 channel image
|-
| dst
| CuviImage&
| Output single channel image
|-
| coeffs
| CuviScalar&
| Custom transformation coefficients
|-
| stream
| CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC1
|-
| 16uC3
| 16uC1
|-
| 32fC3
| 32fC1
|}

===Sample===
{|
|-
|[[File:ColoIn.jpg|frame|Color Image]]
|[[File:RGB2GrayOut.jpg|frame|Output Gray Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path), gout;

//Convert to gray-scale using standard coefficients
cuvi::colorOperations::rgb2gray(gimg,gout);

//Convert to gray-scale using custom coefficients
CuviScalar coeffs(0.33, 0.33, 0.33);
cuvi::colorOperations::rgb2gray(gimg,gout, coeffs);
</syntaxhighlight>
|}

Function:LUT

2014-06-16T06:21:56Z

Ghazanfar: /* Example */

__NOTOC__
Remaps image values according to look up table.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus LUT(const CuviImage& src,
const CuviImage& mapping,
CuviImage& dst,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| CuviImage&
| Input Image
|-
| mapping
| CuviImage&
| The look-up table
|-
| dst
| CuviImage&
| Resultant Image
|-
| stream
| CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input 1
! Input 2
! Output
|-
| 8u
| 8u
| 8u
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage input = cuvi::io::loadImage(path), output;

//Create LUT on host
const int mappingSize = 256;

unsigned char mappingValues[mappingSize];

//Initialize LUT with values which invert the image values
for(int i=0; i<mappingSize; i++)
mappingValues[i] = 255 - i;

//Create and upload LUT matrix on device
CuviImage mapping(mappingSize,1, CUVI_8UC1);
mapping.upload(mappingValues, sizeof(mappingValues));

cuvi::colorOperations::LUT( input, mapping, output );

</syntaxhighlight>
|}

Function:Demosaic

2014-06-16T06:15:26Z

Ghazanfar: /* Image Type Support */

__NOTOC__
Restores an RGB image from a gray-scale CFA image using Bayer algorithm
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus demosaic(const CuviImage& src,
CuviImage& dst,
const CuviBayerSeq sensorAlignment,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}

===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Bayer Image
|-
| dst
| CuviImage&
| Output RGB Image
|-
| sensorAlignment
| CuviBayerSeq
| Sensor alignment of the bayer image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC3
|-
| 16uC1
| 16uC3
|}

===Sample===
{|
|-
|[[File:BayerHolidayIn.png|frame|Input]]
|[[File:BayerHolidayOut.png|frame|Output]]
|-
|[[File:BayerHouseIn.png|frame|Input]]
|[[File:BayerHouseOut.png|frame|Output]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Example using C

CuviImage gimg = cuvi::io::loadImage(path,CUVI_LOAD_IMAGE_GRAYSCALE_KEEP_DEPTH), gout;

//Demosaic
cuvi::colorOperations::demosaic(gimg,gout,CUVI_BAYER_BGGR);

</syntaxhighlight>
|}

Function:ChannelSplit

2014-06-16T06:10:17Z

Ghazanfar:

__NOTOC__
Splits a three channel image into R, G and B channels

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus channelSplit(const CuviImage& src,
CuviImage& red,
CuviImage& green,
CuviImage& blue,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| 3-channel input Image
|-
| red
| CuviImage&
| Output red channel image
|-
| green
| CuviImage&
| Output green channel image
|-
| blue
| CuviImage&
| Output blue channel image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC1 x 3
|-
| 16uC3
| 16uC1 x 3
|-
| 32fC3
| 32fC1 x 3
|}

===Sample===
{|
|-
|[[File:Splitin.jpg|frame|Input Image]]
|[[File:Splitred.jpg|frame|Red Channel]]
|[[File:Splitgreen.jpg|frame|Green Channel]]
|[[File:Splitblue.jpg|frame|Blue Channel]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//A single color image
CuviImage gimg = cuvi::io::loadImage(path,CUVI_LOAD_IMAGE_COLOR);

//Three single channel images for storing output
CuviImage gr, gg, gb;

//Split into R, G and B channels
CuviStatus st = cuvi::colorOperations::channelSplit(gimg,gr,gg,gb);

</syntaxhighlight>
|}

Function:ChannelMerge

2014-06-16T06:09:04Z

Ghazanfar:

__NOTOC__
Merges R, G and B Channel to form a color image

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus channelMerge(const CuviImage& red,
const CuviImage& green,
const CuviImage& blue,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| red
| const CuviImage&
| Red channel input image
|-
| green
| const CuviImage&
| Green channel input image
|-
| blue
| const CuviImage&
| Blue channel input image
|-
| dst
| const CuviImage&
| 3-channel output Image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1 x 3
| 8uC3
|-
| 16uC1 x 3
| 16uC3
|-
| 32fC1 x 3
| 32fC3
|}

===Sample===
{|
|-
|[[File:Splitred.jpg|frame|Red Channel]]
|[[File:Splitgreen.jpg|frame|Green Channel]]
|[[File:Splitblue.jpg|frame|Blue Channel]]
|[[File:Splitin.jpg|frame|Output Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Three single channel images
CuviImage gr = cuvi::io::loadImage(path,CUVI_LOAD_IMAGE_GRAYSCALE);
CuviImage gg = cuvi::io::loadImage(path,CUVI_LOAD_IMAGE_GRAYSCALE);
CuviImage gb = cuvi::io::loadImage(path,CUVI_LOAD_IMAGE_GRAYSCALE);

//A single color image for storing output
CuviImage gout;

//Merge R, G and B images into a single colored image
cuvi::colorOperations::channelMerge(gr,gg,gb,gout);

</syntaxhighlight>
|}

Function:BorderMask

2014-06-16T06:06:54Z

Ghazanfar:

__NOTOC__
Adds borders on the input specified by the 4 arguments: top, bottom, left and right..

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus borderMask(const CuviImage& src,
CuviImage& dst,
const Cuvi32s top,
const Cuvi32s bottom,
const Cuvi32s left,
const Cuvi32s right,
const Cuvi32f* mask,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| top
| const Cuvi32s
| Number of pixels to mask from top
|-
| bottom
| const Cuvi32s
| Number of pixels to mask from bottom
|-
| left
| const Cuvi32s
| Number of pixels to mask from left
|-
| right
| const Cuvi32s
| Number of pixels to mask from right
|-
| mask
| const Cuvi32f*
| Values of masked pixel for each channel
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
|}

===Sample===
{|
|-
|[[File:Maskin.jpg‎|frame|Input Image]]
|[[File:Maskout.jpg|frame|Masked Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path), gout;

Cuvi32f mask[3] = { 0 };

//Mask borders with pixel value of 0 for each channel
cuvi::colorOperations::borderMask(gimg,gout,10,10,5,3,mask);
</syntaxhighlight>
|}

Function:Pow

2014-06-16T05:59:55Z

Ghazanfar: /* Image Type Support */

__NOTOC__

Raises each pixel of the image to the specified power.

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus pow(const CuviImage& src,
const Cuvi32f power,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}

===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| power
| const Cuvi32f
| Power by which each pixel would be raised.
|-
| dst
| CuviImage&
| Output Image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 32fC1
|-
| 8uC3
| 32fC3
|-
| 16uC1
| 32fC1
|-
| 16uC3
| 32fC3
|-
| 32fC1
| 32fC1
|-
| 32fC3
| 32fC3
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Read an image from the disk
CuviImage input = cuvi::io::loadImage(path);
CuviImage output;

const Cuvi32f power = 2.0f;

//Raise the image to the specified power.
cuvi::arithmeticLogical::pow(input,power,output);
</syntaxhighlight>
|}

Function:NOT

2014-06-16T05:57:43Z

Ghazanfar:

__NOTOC__
Inverts the bits of each image pixel.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus NOT(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image

|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
|}

===Sample===
{|
|-
|[[File:NotIn.jpg|frame|Input Image]]
|[[File:NotOut.jpg|frame|Negative Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

//Computing Negative of the image
cuvi::arithmeticLogical::NOT(gimg,gout);

//The same can be achieved using the ~ operator
gout = ~gimg;

</syntaxhighlight>
|}

Function:Threshold

2014-06-16T05:50:27Z

Ghazanfar: /* Example */

__NOTOC__
Clamps image pixel values between specified thresholds.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus threshold(const CuviImage& src,
CuviImage& dst,
const CuviScalar& minThresh,
const CuviScalar& maxThresh,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| minThresh
| const CuviScalar&
| Minimum value of threshold
|-
| maxThresh
| const CuviScalar&
| Maximum value of threshold
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 8u
|-
| 16u
| 16u
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

CuviScalar minThresh(10,20,20);
CuviScalar maxThresh(100,200,150);

//Apply threshold on image pixel values
cuvi::dataExchange::threshold(gimg,gout,minThresh, maxThresh);

</syntaxhighlight>
|}

Function:ColorPick

2014-06-16T05:49:12Z

Ghazanfar: /* Example */

__NOTOC__
Segments input color image by selecting a specified color. Rest of the image is converted to grayscale.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus colorPick(const CuviImage& src,
CuviImage& dst,
const CuviColor color,
const Cuvi32f threshold = 128.0f,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| color
| CuviColor
| The color to select from the image
|-
| threshold
| Cuvi32f
| The threshold for color selection
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC3
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage input = cuvi:io::loadImage(path), output;

//Select blue color from the image.
cuvi::colorOperations::colorPick(input,output,CUVI_COLOR_BLUE);

</syntaxhighlight>
|}

Function:MatMulTrans

2014-06-16T05:45:59Z

Ghazanfar: /* Example */

__NOTOC__
Performs matrix multiplication with its transpose.

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus matMulTrans(const CuviImage& A,
CuviImage& B,
bool trans = false,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| A
| CuviImage&
| Input Image
|-
| B
| CuviImage&
| Resultant Image
|-
| stream
| CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 32f single channel
| 32f single channel
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviSize aSize(3,3);

//Initialize input image
CuviImage A(aSize, CUVI_32FC1);

//Fill image with random values
cuvi::dataExchange::generateRandomImage(A);

CuviImage B;

//Perform matrix multiplication (A * A')
cuvi::arithmeticLogical::matMulTrans(A,B);

//The order of multiplication can be reversed to (A' * A)
cuvi::arithmeticLogical::matMulTrans(A,B,true);

</syntaxhighlight>
|}

Function:Threshold

2014-06-13T13:41:36Z

Ghazanfar: Created page with "__NOTOC__ Clamps image pixel values between specified thresholds. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus threshold(const CuviImage..."

__NOTOC__
Clamps image pixel values between specified thresholds.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus threshold(const CuviImage& src,
CuviImage& dst,
const CuviScalar& minThresh,
const CuviScalar& maxThresh,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| minThresh
| const CuviScalar&
| Minimum value of threshold
|-
| maxThresh
| const CuviScalar&
| Maximum value of threshold
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 8u
|-
| 16u
| 16u
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

CuviScalar minThresh(10,20,20);
CuviScalar maxThresh(100,200,150);

//Computing exponential of image pixels
cuvi::dataExchange::threshold(gimg,gout,minThresh, maxThresh);

</syntaxhighlight>
|}

Function:Exp

2014-06-13T13:30:58Z

Ghazanfar: /* Image Type Support */

__NOTOC__
Calculates exponential value of each pixel of input image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus exp(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image

|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 32f
|-
| 16u
| 32f
|-
| 32f
| 32f
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

//Computing exponential of image pixels
cuvi::arithmeticLogical::exp(gimg,gout);

</syntaxhighlight>
|}

Function:ColorPick

2014-06-13T13:28:25Z

Ghazanfar: Created page with "__NOTOC__ Segments input color image by selecting a specified color. Rest of the image is converted to grayscale. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight ..."

__NOTOC__
Segments input color image by selecting a specified color. Rest of the image is converted to grayscale.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus colorPick(const CuviImage& src,
CuviImage& dst,
const CuviColor color,
const Cuvi32f threshold = 128.0f,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| color
| CuviColor
| The color to select from the image
|-
| threshold
| Cuvi32f
| The threshold for color selection
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC3
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage gimg = cuvi:io::loadImage(path), gout;

//Select blue color from the image.
cuvi::arithmeticLogical::NOT(gimg,gout,CUVI_COLOR_BLUE);

//The same can be achieved using the ~ operator
gout = ~gimg;

</syntaxhighlight>
|}

Image I/O & Framework

2014-06-13T13:20:22Z

Ghazanfar: /* Methods */

==Using CUVI with C++==
CUVI C++ interface uses various features of C++ including classes, namespaces, default arguments and overloading to provide ease of use.

===CuviImage===
CuviImage is a C++ class to hold image data on the device. It has all the essential members to hold image information as well as methods to create and move image to and from device. All the C++ functions in CUVI take CuviImage as input/output image argument. CuviImage creates an image on the GPU so you do not need to cater for manually copying the image to the GPU and then back to the CPU, this is catered by CuviImage.

CuviImage methods helps create, copy and show images.
====Methods====
{|class="wikitable"
|-
! Method
! Description
|-
| CuviImage()
| Default constructor. Initializes all members with 0
|-
| CuviImage(const Cuvi32s width, const Cuvi32s height, const Cuvi32s depth, const Cuvi32s channels);
| Creates a CuviImage of specified width, height, depth and channels.
|-
| CuviImage(const CuviSize& size, const Cuvi32s depth, const Cuvi32s channels);
| Creates a CuviImage of specified size, depth and channels.
|-
| CuviImage(const CuviImage&);
| Creates a copy of existing CuviImage
|-
| CuviStatus upload(const void* pSrcHost, Cuvi32s srcPitch);
| Copy image data from host memory to CuviImage.
|-
| CuviStatus upload(const void* pSrcHost, Cuvi32s srcPitch, const CuviStream& stream);
| Copy image data asynchronously, from host memory to CuviImage using the specified CuviStream.
|-
| CuviStatus download(void* pDstHost, Cuvi32s dstPitch);
| Copy image data from CuviImage to host memory.
|-
| CuviStatus download(void* pDstHost, Cuvi32s dstPitch, const CuviStream& stream);
| Copy image data asynchronously,from CuviImage to host memory using the specified CuviStream.
|-
| CuviStatus show(const std::string& title = "CUVI Image",Cuvi32s milliseconds = 0);
| Render CuviImage on screen for a specified amount of time
|-
| CuviStatus create(const Cuvi32s width, const Cuvi32s height, const Cuvi32s depth, const Cuvi32s channels);
| Creates a CuviImage of specified width, height, depth and channels. Used for lazy initialization of a previously declared CuviImage.
|-
| CuviStatus create(const CuviSize& size, const Cuvi32s depth, const Cuvi32s channels);
| Creates a CuviImage of specified size, depth and channels. Used for lazy initialization of a previously declared CuviImage.
|-
| CuviStatus release();
| Deallocates a CuviImage object.
|-
| ~CuviImage();
| CuviImage destructor. Calls release().
|-
| Cuvi32s width();
| Returns the width of CuviImage in pixels.
|-
| Cuvi32s height();
| Returns the height of CuviImage in pixels.
|-
| Cuvi32s depth();
| Returns the depth of CuviImage.
|-
| Cuvi32s pitch();
| Returns the size of a row in bytes, including the padding of the row.
|-
| Cuvi32s channels();
| Returns the number of channels of the CuviImage.
|-
| CuviSize size();
| Returns the size of CuviImage.
|-
| Cuvi32s dataBits();
| Returns the number of actual data bits of the image.
|-
| CuviType type();
| Returns the type of CuviImage, e.g. CUVI_8UC1, CUVI_8UC3.
|-
| CuviChannelSeq channelSeq();
| Returns the channel sequence of the image, e.g. RGB, BGR etc.
|-
| bool isSigned();
| Returns true in case of unsigned or floating point image type, else returns false.
|-
| bool isInitialized();
| Returns whether the image has been initialized.
|-
| void* ptr();
| Returns the GPU data pointer of the image.
|-
| T* ptr<T>();
| Returns the GPU data pointer as the specified type.
|-
| void setDataBits(const Cuvi32s dataBits);
| Set the dataBits of the image.
|-
| void setChannelSequence(const CuviChannelSeq sequence);
| Set the channel sequence of the image.
|}

====I/O using CuviImage====
{|
|style="font-size:125%;"|
<syntaxhighlight lang="cpp">

#include<iostream>
#include<cuvi.h>

using namespace std;

int main()
{
try
{
const char* imagePath = "image.jpg";
CuviImage input = cuvi::io::loadImage(imagePath);

if(!input.isInitialized())
{
cout<<"Image Not Loaded"<<endl;
return -1;
}

CuviImage output;

cuvi::arithmeticLogical::NOT(input,output);

output.show("Negative Image");

const char* outputPath = "output.jpg";

cuvi::io::saveImage(output,outputPath);

}
catch(const char* e)
{
cout<<"Error: "<<endl<<e<<endl;
}
return 0;
}
</syntaxhighlight>
|}

===Namespaces===
CUVI is divided in image processing modules based on functionality. These modules use separate namespace in CUVI C++ interface to increase readability and ease of use. The current CUVI version has following namespaces:
*cuvi
**arithmeticLogical
**colorOpertions
**computerVision
**dataExchange
**geometryTransforms
**imageFiltering
**imageStatistics
**imageTransforms
**io
**device
**videoStab

Function:PadImage

2014-06-13T13:15:30Z

Ghazanfar: /* Example */

__NOTOC__
Extends image borders by padding extra values on the image boundaries.

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus padImage(const CuviImage& src,
CuviImage& dst,
const Cuvi32s top,
const Cuvi32s bottom,
const Cuvi32s left,
const Cuvi32s right,
const Cuvi32f* values,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| top
| const Cuvi32s
| Number of pixels to pad on top
|-
| bottom
| const Cuvi32s
| Number of pixels to pad on bottom
|-
| left
| const Cuvi32s
| Number of pixels to pad on left
|-
| right
| const Cuvi32s
| Number of pixels to pad on right
|-
| values
| const Cuvi32f*
| Values of padded pixels
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path), gout;

//Pad borders with pixel value of 0
Cuvi32f values[] = {0,0,0};
cuvi::colorOperations::padImage(gimg,gout,10,10,5,3,values);

</syntaxhighlight>
|}

Function:PadImage

2014-06-13T13:14:32Z

Ghazanfar: Created page with "__NOTOC__ Extends image borders by padding extra values on the image boundaries. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus padImage(..."

__NOTOC__
Extends image borders by padding extra values on the image boundaries.

===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus padImage(const CuviImage& src,
CuviImage& dst,
const Cuvi32s top,
const Cuvi32s bottom,
const Cuvi32s left,
const Cuvi32s right,
const Cuvi32f* values,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| top
| const Cuvi32s
| Number of pixels to pad on top
|-
| bottom
| const Cuvi32s
| Number of pixels to pad on bottom
|-
| left
| const Cuvi32s
| Number of pixels to pad on left
|-
| right
| const Cuvi32s
| Number of pixels to pad on right
|-
| values
| const Cuvi32f*
| Values of padded pixels
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path), gout;

//Pad borders with pixel value of 0
Cuvi32f values[] = {0,0,0};
cuvi::colorOperations::borderMask(gimg,gout,10,10,5,3,values);

</syntaxhighlight>
|}

Function:CalcHist

2014-06-13T12:59:49Z

Ghazanfar: Created page with "__NOTOC__ Computes the histogram of input image. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus calcHist(const CuviImage& src, ..."

__NOTOC__
Computes the histogram of input image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus calcHist(const CuviImage& src,
CuviHistogram& hist,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| hist
| CuviHistogram&
| Computed histogram of input image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| CuviHistogram
|-
| 8uC3
| CuviHistogram
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage input = cuvi::io::loadImage(path);

//Create histogram according to image type
CuviHistogram hist(input.type());

//Calculate the histogram
cuvi::imageStatistics::calcHist(input, hist);

</syntaxhighlight>
|}

Function:CountInRange

2014-06-13T12:51:20Z

Ghazanfar:

__NOTOC__
Counts the number of pixels within the given intensity range
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus countInRange(const CuviImage& src,
CuviScalar& count,
const CuviScalar& rangeMin,
const CuviScalar& rangeMax,
const CuviStream& stream = NULL);
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| count
| CuviScalar&
| Computed number of pixels within the given intensity range.
|-
| rangeMin
| const CuviScalar&
| Lower limit of the intensity range
|-
| rangeMax
| const CuviScalar&
| Upper limit of the intensity range
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| CuviScalar
|-
| 8uC3
| CuviScalar
|-
| 32fC1
| CuviScalar
|-
| 32fC3
| CuviScalar
|}

===Sample===
{|
|-
|[[File:Count.PNG]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path);

CuviScalar count;

const CuviScalar lowerBound(25.0, 10.0, 10.0);
const CuviScalar upperBound(100.0, 200.0, 150.0);

//Returns number of pixels within the given intensity range
cuvi::imageStatistics::countInRange(gimg, count, lowerBound, upperBound);

</syntaxhighlight>
|}

Function:CountInRange

2014-06-13T12:50:35Z

Ghazanfar:

__NOTOC__
Counts the number of pixels within the given intensity range
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus countInRange(const CuviImage& src,
CuviScalar& count,
const CuviScalar& rangeMin,
const CuviScalar& rangeMax,
const CuviStream& stream = NULL);
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| count
| CuviScalar&
| Computed number of pixels within the given intensity range.
|-
| rangeMin
| const CuviScalar&
| Lower limit of the intensity range
|-
| rangeMax
| const CuviScalar&
| Upper limit of the intensity range
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| CuviScalar
|-
| 8uC3
| CuviScalar
|-
| 32fC1
| CuviScalar
|-
| 32fC3
| CuviScalar
|}

===Sample===
{|
|-
|[[File:Count.PNG]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage* gimg = cuvi::io::loadImage(path);

CuviScalar count;

const CuviScalar lowerBound(25.0, 10.0, 10.0);
const CuviScalar upperBound(100.0, 200.0, 150.0);

//Returns number of pixels within the given intensity range
cuvi::imageStatistics::countInRange(gimg, count, lowerBound, upperBound);

</syntaxhighlight>
|}

Function:LogTransform

2014-06-13T12:39:26Z

Ghazanfar: Created page with "__NOTOC__ Applies log transformation to pixel values. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus logTransform(const CuviImage& src, ..."

__NOTOC__
Applies log transformation to pixel values.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus logTransform(const CuviImage& src,
CuviImage& dst,
const Cuvi32f c = 1.0f,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| c
| const Cuvi32f
| Scaling value
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 32f
|-
| 16u
| 32f
|-
| 32f
| 32f
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating input images
CuviImage input = cuvi:io::loadImage(path), output;

const Cuvi32f c = 1.5f;

cuvi::colorOperations::logTransform(input,output,c);

</syntaxhighlight>
|}

Function:GammaCorrect

2014-06-13T12:36:28Z

Ghazanfar:

__NOTOC__
Increases or decreases gamma value of input image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus gammaCorrect(const CuviImage& src,
CuviImage& dst,
const Cuvi32f gamma = 1.0f,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| gamma
| const Cuvi32f
| Gamma value
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 8u
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating input images
CuviImage input = cuvi:io::loadImage(path), output;

const Cuvi32f gamma = 1.5f;

cuvi::colorOperations::gammaCorrect(input,output,gamma);

</syntaxhighlight>
|}

Function:GammaCorrect

2014-06-13T12:33:16Z

Ghazanfar: Created page with "__NOTOC__ Converts image data type with optional scaling. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus gammaCorrect(const CuviImage& src..."

__NOTOC__
Converts image data type with optional scaling.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus gammaCorrect(const CuviImage& src,
CuviImage& dst,
const Cuvi32f gamma = 1.0f,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| gamma
| const Cuvi32f
| Gamma value
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 8u
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating input images
CuviImage input = cuvi:io::loadImage(path), output;

const Cuvi32f gamma = 1.5f;

cuvi::colorOperations::gammaCorrect(input,output,gamma);

</syntaxhighlight>
|}

Function:LUT

2014-06-13T12:13:06Z

Ghazanfar: Created page with "__NOTOC__ Remaps image values according to look up table. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus LUT(const CuviImage& src, ..."

__NOTOC__
Remaps image values according to look up table.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus LUT(const CuviImage& src,
const CuviImage& mapping,
CuviImage& dst,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| CuviImage&
| Input Image
|-
| mapping
| CuviImage&
| The look-up table
|-
| dst
| CuviImage&
| Resultant Image
|-
| stream
| CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input 1
! Input 2
! Output
|-
| 8u
| 8u
| 8u
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage input = cuvi::io::loadImage(path), output;

//Create LUT on host
const int mappingSize = 256;

unsigned char mappingValues[mappingSize];

//Initialize LUT with values which invert the image values
for(int i=0; i<mappingSize; i++)
mappingValues[i] = 255 - i;

//Create and upload LUT matrix on device
CuviImage mapping(mappingSize,1, CUVI_8UC1);
mapping.upload(mappingValues, sizeof(mappingValues);

cuvi::colorOperations::LUT( input, mapping, output );

</syntaxhighlight>
|}

Function:MedianFilter

2014-06-13T11:51:18Z

Ghazanfar:

__NOTOC__
Applies 2D median filter to the input image
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus medianFilter(const CuviImage& src,
CuviImage& dst,
const CuviRect& roi,
const CuviSize& filterSize,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| roi
| const CuviRect&
| Region of Interest
|-
| filterSize
| const CuviSize&
| Median filter's kernel size. Only 3x3, 5x5, 7x7, and 9x9 are supported
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Input image
CuviImage gimg = cuvi::io::loadImage(path);

//Output Image
CuviImage gout;

//Choosing ROI
CuviRect roi(0,0,img.width(),img.height());

//Filter Size
CuviSize fSize(5,5);

//Applying Median filter of size 5x5 on the image
cuvi::imageFiltering::medianFilter(gimg, gout, roi, fSize);

</syntaxhighlight>
|}

Function:MedianFilter

2014-06-13T11:51:00Z

Ghazanfar: Created page with "__NOTOC__ Applies 2D median filter to the input image ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus minFilter(const CuviImage& src, ..."

__NOTOC__
Applies 2D median filter to the input image
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus minFilter(const CuviImage& src,
CuviImage& dst,
const CuviRect& roi,
const CuviSize& filterSize,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Output Image
|-
| roi
| const CuviRect&
| Region of Interest
|-
| filterSize
| const CuviSize&
| Median filter's kernel size. Only 3x3, 5x5, 7x7, and 9x9 are supported
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
|}

===Sample===

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Input image
CuviImage gimg = cuvi::io::loadImage(path);

//Output Image
CuviImage gout;

//Choosing ROI
CuviRect roi(0,0,img.width(),img.height());

//Filter Size
CuviSize fSize(5,5);

//Applying Median filter of size 5x5 on the image
cuvi::imageFiltering::medianFilter(gimg, gout, roi, fSize);

</syntaxhighlight>
|}

Function:MinMax

2014-06-13T11:27:38Z

Ghazanfar:

__NOTOC__
Computes the minimum and maximum pixel values in the image
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus minMax(const CuviImage& src,
CuviScalar& minValue,
CuviScalar& maxValue,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| minValue
| CuviScalar&
| Minimum pixel value(s) in the image
|-
| maxValue
| CuviScalar&
| Maximum pixel value(s) in the image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| 2 x CuviScalar
|-
| 8uC3
| 2 x CuviScalar
|-
| 16uC1
| 2 x CuviScalar
|-
| 16uC3
| 2 x CuviScalar
|-
| 32fC1
| 2 x CuviScalar
|-
| 32fC3
| 2 x CuviScalar
|}

===Sample===
{|
|-
|[[File:Minmax.PNG]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path);

CuviScalar min, max;

//Returns minimum and maximum pixel value(s)
cuvi::imageStatistics::minMax(gimg, min, max);

</syntaxhighlight>
|}

Function:Min

2014-06-13T11:24:54Z

Ghazanfar:

__NOTOC__
Computes the minimum of image pixel values
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus min(const CuviImage& src,
CuviScalar& minValue,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| minValue
| CuviScalar&
| Minimum pixel value in the image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC1
| CuviScalar
|-
| 8uC3
| CuviScalar
|-
| 16uC1
| CuviScalar
|-
| 16uC3
| CuviScalar
|-
| 32fC1
| CuviScalar
|-
| 32fC3
| CuviScalar
|}

===Sample===
{|
|-
|[[File:Min.PNG]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage gimg = cuvi::io::loadImage(path);

CuviScalar min;

//Returns minimum pixel value(s)
cuvi::imageStatistics::min(gimg, min);

</syntaxhighlight>
|}

Function:ConvertScale

2014-06-13T11:20:51Z

__NOTOC__
Converts image data type with optional scaling.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus convertScale(const CuviImage& src,
CuviImage& dst,
const Cuvi32f scale = 1.0f,
const Cuvi32f offset = 0.0f,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| scale
| const Cuvi32f
| Scale factor
|-
| offset
| const Cuvi32f
| Value added to scaled values
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8u
| 8u
|-
| 16u
| 16u
|-
| 32f
| 32f
|-
| 8u
| 32f
|-
| 16u
| 32f
|-
| 8u
| 16u
|-
| 32f
| 8u
|-
| 32f
| 16u
|-
| 16u
| 8u
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating input images
CuviImage input = cuvi:io::loadImage(path);

//Create output image of same size but different type
CuviImage output(input.size(), CUVI_DEPTH_32F, input.channels());

//Convert image by normalizing pixel values (divide each pixel by 255)
cuvi::dataExchange::convertScale(input, output, 1.0f/255.0f);

</syntaxhighlight>
|}

Function:GetChannel

2014-06-13T11:11:57Z

Ghazanfar:

__NOTOC__
Extracts the specified channel from a multichannel image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus getChannel(const CuviImage& src,
CuviImage& dst,
const Cuvi32s channel,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| channel
| Cuvi32s
| Channel number from 0 to (src.channels() - 1)
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC1
|-
| 8uC4
| 8uC1
|-
| 16uC3
| 16uC1
|-
| 16uC4
| 16uC1
|-
| 32fC3
| 32fC1
|-
| 32fC4
| 32fC1
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage input = cuvi:io::loadImage(path), output;

//Get first channel of the input image
cuvi::dataExchange::getChannel(input, output, 0);

//The same can be achieved by using the channel fetch operator
output = input[0];

</syntaxhighlight>
|}

Function:OR

2014-06-13T10:52:39Z

Ghazanfar:

__NOTOC__
Bitwise OR operation of an image with another image or a constant value.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus OR(const CuviImage& src1,
const CuviImage& src2,
CuviImage& dst,
const CuviStream& stream = CuviStream());

CuviStatus OR(const CuviImage& src,
const Cuvi32s value,
CuviImage& dst,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src1
| const CuviImage&
| First Input Image
|-
| src2
| const CuviImage&
| Second Input Image
|-
| dst
| CuviImage&
| Resultant Image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input 1
! Input 2
! Output
|-
| 8uC1
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
| 16uC3
|}

===Sample===
{|
|-
|[[File:Addin1.jpg|frame|First Input Image]]
|[[File:Addin2.jpg|frame|Second Input Image]]
|-
|[[File:ORout.jpg|frame| Resultant Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage input1 = cuvi::io::loadImage(path);
CuviImage input2 = cuvi::io::loadImage(path);
CuviImage output;

//OR Operation
cuvi::arithmeticLogical::OR(input1,input2,output);

//The same can be achieved by using OR operator
output = input1 | input2;

//Set last 4 bits of each pixel of the image
output |= 0x0f;

</syntaxhighlight>
|}

Function:XOR

2014-06-13T10:40:56Z

Ghazanfar:

__NOTOC__
Bitwise XOR operation of an image with another image or a constant value.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviStatus XOR(const CuviImage& src1,
const CuviImage& src2,
CuviImage& dst,
const CuviStream& stream = CuviStream());

CuviStatus XOR(const CuviImage& src,
const Cuvi32s value,
CuviImage& dst,
const CuviStream& stream = CuviStream());

</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src1
| const CuviImage&
| First Input Image
|-
| src2
| const CuviImage&
| Second Input Image
|-
| dst
| CuviImage&
| Resultant Image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input 1
! Input 2
! Output
|-
| 8uC1
| 8uC1
| 8uC1
|-
| 8uC3
| 8uC3
| 8uC3
|-
| 16uC1
| 16uC1
| 16uC1
|-
| 16uC3
| 16uC3
| 16uC3
|}

===Sample===
{|
|-
|[[File:Penguin.jpg|frame|First Input Image]]
|[[File:Bluebird.jpg|frame|Second Input Image]]
|[[File:XORout.jpg|frame| Resultant Image]]
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

CuviImage input1 = cuvi::io::loadImage(path);
CuviImage input2 = cuvi::io::loadImage(path);
CuviImage output;

//XOR Operation
cuvi::arithmeticLogical::XOR(input1,input2,output);

//The same can be achieved by using XOR operator
output = input1 ^ input2;

//Inverting last 4 bits of each pixel of the image
output ^= 0x0f;

</syntaxhighlight>
|}

Function:GetChannel

2014-06-13T10:34:40Z

Ghazanfar: Created page with "__NOTOC__ Extracts the specified channel from a multichannel image. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus getChannel(const CuviIm..."

__NOTOC__
Extracts the specified channel from a multichannel image.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus getChannel(const CuviImage& src,
CuviImage& dst,
const Cuvi32s channel,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image
|-
| channel
| Cuvi32s
| Channel number to extract
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 8uC3
| 8uC1
|-
| 8uC4
| 8uC1
|-
| 16uC3
| 16uC1
|-
| 16uC4
| 16uC1
|-
| 32fC3
| 32fC1
|-
| 32fC4
| 32fC1
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Creating GPU images
CuviImage input = cuvi:io::loadImage(path), output;

//Get first channel of the input image
cuvi::dataExchange::getChannel(input, output, 0);

//The same can be achieved by using the channel fetch operator
output = input[0];

</syntaxhighlight>
|}

CUVI Features

2014-06-13T10:27:12Z

Ghazanfar: /* Arithmetic & Logical */

This page provides a list of all the functionality available in the latest release of CUVI Library.
==Modules==
CUVI comes in following image processing modules.
* Arithmetic & Logical
* Color Operations 
* Computer Vision
* Data Exchange
* Geometry Transforms
* Image Filtering
* Image Statistics
* Image Transforms
* Video Stabilization
<br/>

==Function List==
{| style="width:100%; background:#f6f6f6; margin-top:1.2em; border:1px solid #ccc;"
|- valign="top"
|
===Arithmetic & Logical===
* [[Function:Abs|abs]] - Computes absolute value of each image pixel
* [[Function:AbsDiff|absDiff]] - Computes absolute difference between 2 images.
* [[Function:Add|add]] - Adds two images
* [[Function:AND|AND]] - Bitwise AND operation between two images.
* [[Function:Cbrt|cbrt]] - Computes cube root of each image pixel
* [[Function:Ceil|ceil]] - Applies ceil function to each image pixel
* [[Function:Divide|divide]] - Divides pixel values of two images
* [[Function:Exp|exp]] - Computes exponential of each image pixel
* [[Function:Floor|floor]] - Applies floor function to each image pixel
* [[Function:Invert|invert]] - Computes matrix inverse using LU factorization
* [[Function:MatMul|matMul]] - Performs matrix multiplication
* [[Function:MatMulTrans|matMulTrans]] - Performs matrix multiplication with its transpose
* [[Function:Multiply|multiply]] - Multiplies pixel values of two images
* [[Function:NOT|NOT]] - Inverts the bits of each pixel.
* [[Function:OR|OR]] - Bitwise OR operation between two images.
* [[Function:Pow|pow]] - Raise each pixel to a specified power.
* [[Function:Round|round]] - Rounds each pixel to nearest integer value.
* [[Function:SHL|SHL]] - Left shift each pixel of an image
* [[Function:SHR|SHR]] - Right shift each pixel of an image
* [[Function:Sqrt|sqrt]] - Takes square root of each pixel of an image.
* [[Function:Subtract|subtract]] - Subtracts pixel values of two images.
* [[Function:XOR|XOR]] - Logical bitwise XOR operation between two images.

===Color Operations===
* [[Function:Adjust|adjust]] - Equivalent to MATLAB's imadjust
* [[Function:BorderMask|borderMask]] - Masks image borders with custom intensity
* [[Function:ChannelMerge|channelMerge]] - Merges R, G and B Channel to form a color image
* [[Function:ChannelSplit|channelSplit]] - Splits a three channel image into R, G and B channels
* [[Function:ColorPick|colorPick]] - Performs color segmentation of image by selecting a single color.
* [[Function:ColorTwist|colorTwist]] - Applies a color twist matrix to an image
* [[Function:Demosaic|demosaic]] - Restores an RGB image from a CFA Bayer image
* [[Function:DemosaicDFPD|'''demosaicDFPD''']] - Restores an RGB image from a CFA Bayer image using DFPD algorithm
* [[Function:GammaCorrect|gammaCorrect]] - Performs gamma correction of an image
* [[Function:Gray2rgb|gray2rgb]] - Copy a grayscale image to each channel of an RGB image.
* [[Function:HistEq|histEq]] - Performs histogram equalization
* [[Function:Hsv2rgb|hsv2rgb]] - Converts image from HSV color space to RGB.
* [[Function:ImageBinary|imageBinary]] - Converts input image into a binary image based on threshold
* [[Function:Lab2rgb|Lab2rgb]] - Converts image from CIE Lab color space to RGB.
* [[Function:LogTransform|logTransform]] - Applies log transformation for contrast enhancement of an image.
* [[Function:LUT|LUT]] - Remaps image values according to look up table
* [[Function:RGB2Gray|rgb2gray]] - Converts an RGB image to gray scale.
* [[Function:Rgb2hsv|rgb2hsv]] - Converts an RGB image to HSV color space.
* [[Function:Rgb2Lab|rgb2Lab]] - Converts an RGB image to CIE Lab color space.
* [[Function:Rgb2ycbcr|rgb2ycbcr]] - Converts an RGB image to YCbCr color space.
* [[Function:RGB2YUV|rgb2yuv]] - Converts RGB image to YUV color space.
* [[Function:Ycbcr2rgb|ycbcr2rgb]] - Converts YCbCr image to an RGB image.
* [[Function:YUV2RGB|yuv2rgb]] - Converts YUV image to an RGB image.

===Computer Vision===
* [[Function:EigenValsVecs|eigenValsVecs]] - Calculates eigen values and eigen vectors at each pixel in an image
* [[Function:GoodFeaturesToTrack|goodFeaturesToTrack]] - selects N best points on a image using KLT or Harris
* [[Function:MinEigenVal|minEigenVal]] - Calculates the minimum eigen value at each pixel in an image
* [[Function:OpticalFlowHS|opticalFlowHS]] - Calculates flow of each image pixel in two frames using Horn–Schunck method
* [[Function:opticalFlowPyrLKDense|opticalFlowPyrLKDense]] - Calculates flow of each image pixel in two frames using pyramidal Lucas–Kanade method
* [[Function:TrackFeatures|trackFeatures]] - Tracks input features from frame 1 onto frame 2 using KLT method
|

===Data Exchange===
* [[Function:BitConversion|bitConversion]] - Converts image pixel values from one data type to another.
* [[Function:ConvertScale|convertScale]] - Converts image data type with optional scaling.
* [[Function:GenerateRandomImage|generateRandomImage]] - Creates a new random image.
* [[Function:GetChannel|getChannel]] - Extracts a channel of an image.
* [[Function:PadImage|padImage]] - Pads any side of the image with the value specified.
* [[Function:Rectangle|rectangle]] - Draws a rectangle on the specified region of an image.
* [[Function:Threshold|threshold]] - Clamps image pixel values between specified thresholds.

===Geometry Transforms===
* [[Function:Crop|crop]] - Crops the desired portion of an image
* [[Function:Flip|flipImage]] - Mirrors an image about a horizontal or vertical axis, or both
* [[Function:Resize|resize]] - Resizes input image using specified interpolation
* [[Function:Rotate|rotate]] - Rotates an image about origin (0,0) or center
* [[Function:Transpose|transpose]] - Takes Transpose of the image
* [[Function:WarpAffine|warpAffine]] - Applies an affine transformation to an image.
* [[Function:WarpAffineBack|warpAffineBack]] - Applies an inverse affine transformation to an image.

===Image Filtering===
* [[Function:Enhance|'''enhance''']] - description
* [[Function:ImageFilter|imageFilter]] - Performs linear 1D and 2D image filtering
* [[Function:ImageGradients|imageGradients]] - Calculates X and Y gradients of image
* [[Function:MinFilter|minFilter]] - Filters an image using a min filter
* [[Function:MaxFilter|maxFilter]] - Filters an image using a max filter
* [[Function:MedianFilter|medianFilter]] - Applies 2D median filter on an image

===Image Statistics===
* [[Function:CalcHist|calcHist]] - Computes the histogram of an 8 bit image.
* [[Function:CountInRange|countInRange]] - Counts the number of pixels within the given intensity range
* [[Function:Max|max]] - Computes the maximum of image pixel values
* [[Function:Mean|mean]] - Computes the mean of image pixel values
* [[Function:MeanStdDev|meanStdDev]] - Computes the mean and standard deviation of image pixel values
* [[Function:Min|min]] - Computes the minimum of image pixel values
* [[Function:MinMax|minMax]] - Computes the minimum and maximum of image pixel values
* [[Function:Sum|sum]] - Computes the sum of image pixel values

===Image Transforms===
* [[Function:Fft2|fft2]] - Computes the 2D Fast Fourier Transform of an image.
* [[Function:FftGetProperty|fftGetProperty]] - Gets magnitude, phase, real and imaginary part of an FFT image with optional scaling.
* [[Function:FftShift|fftShift]] - Moves low frequency components to the center of an FFT image.
* [[Function:haarFwd|haarFwd]] - Performs one-level wavelet decomposition of an image using haar basis
* [[Function:haarInv|haarInv]] - Performs one-level haar wavelet reconstruction of an image

===Video Stabilization===
* [[Function:CuviMotionEstimator|CuviMotionEstimator]] - Class to estimate global motion vectors between an image pair.
* [[Function:CuviVideoStabilizer|CuviVideoStabilizer]] - Class for transparent video stabilization of a video file.
|}
<br/>


==CUVI Core==
CUVI Core includes the following helper functionality:

{| style="width:100%; background:#f6f6f6; margin-top:1.2em; border:1px solid #ccc;"
|style="width:100%;"|
===CuviImage===
A C++ class to hold image data on the device. It has the following methods
* CuviImage(); - default constructor
* CuviImage(CuviSize size, Cuvi32s depth, Cuvi32s channels) - Main Constructor. throws exception in case of failure
* CuviImage(const CuviImage&) - copy constructor
* upload(const void* pSrcHost, const Cuvi32s srcPitch) - Copy image data from host to device.
* upload(const void* pSrcHost, const Cuvi32s srcPitch, const CuviStream& stream) - Asynchronously copy image data from host to device.
* download(void* pDstHost, const Cuvi32s dstPitch) - Copy image data from device to host
* download(void* pDstHost, const Cuvi32s dstPitch, const CuviStream& stream) - Asynchronously copy image data from device to host
* show(const std::string& title = "CUVI Image", Cuvi32s milliseconds = 0) - Render device image directly on the screen
* ~CuviImage() - Destructor. Frees Device Memory. throws exception in case of failure

{|
|-valign="top"
|style="width:50%;"|

===Timer===
CUVI provides a C++ Timer class that accurately profiles your application timing
* Start() - Starts the timer.
* Stop() - Stops the timer
* Reset() - Resets the timer
* GetElapsedTime() - Returns the elapsed time between Start and Stop calls in seconds
|style="width:50%; "|

===DeviceProperties===
CuviDeviceProperties holds all the important properties of underlying CUDA device. Device management functions are present inside the namespace cuvi::device.
*Cuvi32s getDeviceCount() - Gives the count of devices installed in the machine
*Cuvi32s getCurentDevice() - Returns the ID of selected graphics card
*CuviStatus setCurrentDevice(const Cuvi32s ID) - Makes any device an active device
*CuviStatus getDeviceProperties(const Cuvi32s deviceID, CuviDeviceProperties& props) - Returns all the important properties of desired GPU
|}
|}

Function:GenerateRandomImage

2014-06-13T10:25:25Z

Ghazanfar: /* Example */

__NOTOC__
Fills an image with random values.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus generateRandomImage(CuviImage& srcDst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| srcDst
| CuviImage&
| Input/Output Image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input/Output
|-
| 32fC1
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Initialize GPU images
CuviImage image(640, 480, CUVI_32FC1);

//Fill image with random value
cuvi::dataExchange::generateRandomImage(image);

</syntaxhighlight>
|}

Function:GenerateRandomImage

2014-06-13T10:25:05Z

Ghazanfar: Created page with "__NOTOC__ Fills an image with random values. ===Function=== {| |style="font-size:150%;"| <syntaxhighlight lang="cpp"> CuviStatus generateRandomImage(CuviImage& srcDst, ..."

__NOTOC__
Fills an image with random values.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus generateRandomImage(CuviImage& srcDst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| srcDst
| CuviImage&
| Input/Output Image
|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input/Output
|-
| 32fC1
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Initialize GPU images
CuviImage image(640, 480, CUVI_32FC1);

//Fill image with random values
cuvi::dataExchange::generateRandomImage(image);

</syntaxhighlight>
|}

Function:Invert

2014-06-13T10:20:27Z

Ghazanfar:

__NOTOC__
Computes matrix inverse of a square image using LU factorization.
===Function===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">
CuviStatus invert(const CuviImage& src,
CuviImage& dst,
const CuviStream& stream = CuviStream());
</syntaxhighlight>
|}
===Parameters===

{|class="wikitable"
|-
! Name
! Type
! Description
|-
| src
| const CuviImage&
| Input Image
|-
| dst
| CuviImage&
| Destination Image

|-
| stream
| const CuviStream&
| GPU stream ID for execution

|}

===Image Type Support===

{| class="wikitable"
|-
! Input
! Output
|-
| 32fC1
| 32fC1
|}

===Example===
{|
|style="font-size:150%;"|
<syntaxhighlight lang="cpp">

//Initialize GPU image
CuviImage input(3,3,CUVI_32FC1), output;

//Fill input image with random values
cuvi::dataExchange::generateRandomImage(input);

//Calculate the inverse
cuvi::arithmeticLogical::invert(input, output);

</syntaxhighlight>
|}