C# Class ManagedCuda.NPP.NPPImage_8uC3

Absolute difference of this minus src2.

Image addition, scale by 2^(-nScaleFactor), then clamp to saturated value.

In place image addition, scale by 2^(-nScaleFactor), then clamp to saturated value.

Add constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value.

Add constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Inplace.

Image composition using constant alpha.

In place alpha premultiplication using constant alpha.

Image premultiplication using constant alpha.

In place image logical and.

Image logical and.

In place image logical and with constant.

Image logical and with constant.

image average error. User buffer is internally allocated and freed.

image average error.

Device scratch buffer size (in bytes) for AverageError.

image average relative error. User buffer is internally allocated and freed.

image average relative error.

Device scratch buffer size (in bytes) for AverageRelativeError.

3 channel 8-bit unsigned packed BGR to 2 channel 8-bit unsigned packed CbYCr422_709HDTV color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar HLS color conversion.

3 channel 8-bit unsigned planar BGR to 3 channel 8-bit unsigned planar HLS color conversion.

3 channel 8-bit unsigned planar BGR to 3 channel 8-bit unsigned packed HLS color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned packed Lab color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCbCr color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCbCr411 color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCbCr420 color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCbCr420_709CSC color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCbCr422 color conversion.

3 channel 8-bit unsigned packed BGR to 2 channel 8-bit unsigned packed YCbCr422 color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCrCb420 color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YCrCb420_709CSC color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned planar YUV color conversion.

3 channel 8-bit unsigned planar BGR to 3 channel 8-bit unsigned planar YUV color conversion.

3 channel 8-bit unsigned packed BGR to 3 channel 8-bit unsigned packed YUV color conversion.

Color to Gray conversion

3 channel planar 8-bit unsigned color twist. An input color twist matrix with floating-point pixel values is applied within ROI.

3 channel planar 8-bit unsigned inplace color twist. An input color twist matrix with floating-point pixel values is applied within ROI.

An input color twist matrix with floating-point pixel values is applied within ROI.

in place color twist. An input color twist matrix with floating-point coefficient values is applied within ROI.

packed color complement color key replacement of source image 1 by source image 2

Compare pSrc1's pixels with corresponding pixels in pSrc2.

Compare pSrc's pixels with constant value.

8-bit unsigned to 16-bit signed conversion.

8-bit unsigned to 16-bit unsigned conversion.

8-bit unsigned to 32-bit floating point conversion.

8-bit unsigned to 32-bit signed conversion.

Three-channel 8-bit unsigned packed to planar image copy.

Three-channel 8-bit unsigned planar to packed image copy.

Image copy.

image copy.

Masked Operation 8-bit unsigned image copy.

Image copy.

Copy image and pad borders with a constant, user-specifiable color.

image copy with nearest source image pixel color.

linearly interpolated source image subpixel coordinate color copy.

image copy with the borders wrapped by replication of source image pixel colors.

image CountInRange.

image CountInRange.

Device scratch buffer size (in bytes) for CountInRange.

image CrossCorrFull_Norm.

image CrossCorrFull_Norm.

CrossCorrFull_NormLevel. Buffer is internally allocated and freed.

CrossCorrFull_NormLevel.

CrossCorrFull_NormLevel. Buffer is internally allocated and freed.

CrossCorrFull_NormLevel.

image CrossCorrSame_Norm.

image CrossCorrSame_Norm.

CrossCorrSame_NormLevel. Buffer is internally allocated and freed.

CrossCorrSame_NormLevel.

CrossCorrSame_NormLevel. Buffer is internally allocated and freed.

CrossCorrSame_NormLevel.

image CrossCorrValid_Norm.

image CrossCorrValid_Norm.

CrossCorrValid_NormLevel. Buffer is internally allocated and freed.

CrossCorrValid_NormLevel.

CrossCorrValid_NormLevel. Buffer is internally allocated and freed.

CrossCorrValid_NormLevel.

Dilation computes the output pixel as the maximum pixel value of the pixels under the mask. Pixels who’s corresponding mask values are zero to not participate in the maximum search.

3x3 dilation.

3x3 dilation with border control.

Dilation computes the output pixel as the maximum pixel value of the pixels under the mask. Pixels who’s corresponding mask values are zero to not participate in the maximum search. With border control.

Image division, scale by 2^(-nScaleFactor), then clamp to saturated value.

Image division, scale by 2^(-nScaleFactor), then clamp to saturated value.

In place image division, scale by 2^(-nScaleFactor), then clamp to saturated value.

In place image division, scale by 2^(-nScaleFactor), then clamp to saturated value.

Divide constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value.

Divide constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Inplace.

Device scratch buffer size (in bytes) for nppiDotProd_8u64f_C3R.

Three-channel 8-bit unsigned image DotProd. Buffer is internally allocated and freed.

Three-channel 8-bit unsigned image DotProd.

Erosion computes the output pixel as the minimum pixel value of the pixels under the mask. Pixels who’s corresponding mask values are zero to not participate in the maximum search.

3x3 erosion.

3x3 erosion with border control.

Erosion computes the output pixel as the minimum pixel value of the pixels under the mask. Pixels who’s corresponding mask values are zero to not participate in the maximum search. With border control.

Compute levels with even distribution.

Exponential, scale by 2^(-nScaleFactor), then clamp to saturated value.

Inplace exponential, scale by 2^(-nScaleFactor), then clamp to saturated value.

convolution filter.

convolution filter.

Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. Before writing the result pixel the sum is scaled back via division by nDivisor.

Three channel 8-bit unsigned bilateral Gauss filter with border control.

Three channel 8-bit unsigned to 16-bit signed convolution filter with border control. General purpose 2D convolution filter using floating-point weights with border control. Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. Before writing the result pixel the sum is scaled back via division by nDivisor. If any portion of the mask overlaps the source image boundary the requested border type operation is applied to all mask pixels which fall outside of the source image.

Three channel 8-bit unsigned convolution filter with border control. General purpose 2D convolution filter using floating-point weights with border control. Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. Before writing the result pixel the sum is scaled back via division by nDivisor. If any portion of the mask overlaps the source image boundary the requested border type operation is applied to all mask pixels which fall outside of the source image.

Three channel 8-bit unsigned convolution filter with border control. General purpose 2D convolution filter with border control. Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. Before writing the result pixel the sum is scaled back via division by nDivisor. If any portion of the mask overlaps the source image boundary the requested border type operation is applied to all mask pixels which fall outside of the source image.

Computes the average pixel values of the pixels under a rectangular mask.

Computes the average pixel values of the pixels under a rectangular mask.

1D column convolution.

Apply convolution filter with user specified 1D column of weights. Result pixel is equal to the sum of the products between the kernel coefficients (pKernel array) and corresponding neighboring column pixel values in the source image defined by nKernelDim and nAnchorY, divided by nDivisor.

General purpose 1D convolution column filter with border control. Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. If any portion of the mask overlaps the source image boundary the requested border type operation is applied to all mask pixels which fall outside of the source image.

General purpose 1D convolution column filter with border control. Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. Before writing the result pixel the sum is scaled back via division by nDivisor. If any portion of the mask overlaps the source image boundary the requested border type operation is applied to all mask pixels which fall outside of the source image.

Filters the image using a separable Gaussian filter kernel with user supplied floating point coefficients

Gauss filter.

Filters the image using a separable Gaussian filter kernel with user supplied floating point coefficients

Filters the image using a Gaussian filter kernel with border control: 1/16 2/16 1/16 2/16 4/16 2/16 1/16 2/16 1/16 or 2/571 7/571 12/571 7/571 2/571 7/571 31/571 52/571 31/571 7/571 12/571 52/571 127/571 52/571 12/571 7/571 31/571 52/571 31/571 7/571 2/571 7/571 12/571 7/571 2/571

Three channel 8-bit unsigned Gauss filter with downsampling and border control.

Three channel 8-bit unsigned Gauss filter with downsampling and border control.

High pass filter.

High pass filter.

Laplace filter.

Laplace filter.

Low pass filter.

Low pass filter.

Result pixel value is the maximum of pixel values under the rectangular mask region.

Result pixel value is the maximum of pixel values under the rectangular mask region.

Result pixel value is the median of pixel values under the rectangular mask region.

Result pixel value is the median of pixel values under the rectangular mask region.

Device scratch buffer size (in bytes) for FilterMedian.

Result pixel value is the minimum of pixel values under the rectangular mask region.

Result pixel value is the minimum of pixel values under the rectangular mask region.

horizontal Prewitt filter.

horizontal Prewitt filter.

vertical Prewitt filter.

vertical Prewitt filter.

horizontal Roberts filter.

horizontal Roberts filter.

vertical Roberts filter..

vertical Roberts filter.

1D row convolution.

Apply general linear Row convolution filter, with rescaling, in a 1D mask region around each source pixel. Result pixel is equal to the sum of the products between the kernel coefficients (pKernel array) and corresponding neighboring row pixel values in the source image defined by iKernelDim and iAnchorX, divided by iDivisor.

General purpose 1D convolution row filter with border control. Pixels under the mask are multiplied by the respective weights in the mask and the results are summed. If any portion of the mask overlaps the source image boundary the requested border type operation is applied to all mask pixels which fall outside of the source image.

Apply general linear Row convolution filter, with rescaling, in a 1D mask region around each source pixel with border control. Result pixel is equal to the sum of the products between the kernel coefficients (pKernel array) and corresponding neighboring row pixel values in the source image defined by iKernelDim and iAnchorX, divided by iDivisor.

Sharpen filter.

Sharpen filter.

Filters the image using a horizontal Sobel filter kernel with border control.

vertical Sobel filter.

Filters the image using a vertical Sobel filter kernel with border control.

Filters the image using a unsharp-mask sharpening filter kernel with border control. The algorithm involves the following steps: Smooth the original image with a Gaussian filter, with the width controlled by the nRadius. Subtract the smoothed image from the original to create a high-pass filtered image. Apply any clipping needed on the high-pass image, as controlled by the nThreshold. Add a certain percentage of the high-pass filtered image to the original image, with the percentage controlled by the nWeight. In pseudocode this algorithm can be written as: HighPass = Image - Gaussian(Image) Result = Image + nWeight * HighPass * ( |HighPass| >= nThreshold ) where nWeight is the amount, nThreshold is the threshold, and >= indicates a Boolean operation, 1 if true, or 0 otherwise. If any portion of the mask overlaps the source image boundary, the requested border type operation is applied to all mask pixels which fall outside of the source image.

Scratch-buffer size for unsharp filter.

Device scratch buffer size (in bytes) for CrossCorrFull_NormLevel.

Device scratch buffer size (in bytes) for CrossCorrFull_NormLevel.

Inplace image forward gamma correction.

3 channel 8-bit unsigned planar color in place forward gamma correction.

3 channel 8-bit unsigned planar color not in place forward gamma correction.

image forward gamma correction.

Inplace image inverse gamma correction.

3 channel 8-bit unsigned planar color in place inverse gamma correction.

3 channel 8-bit unsigned planar color not in place inverse gamma correction.

image inverse gamma correction.

Calculates bounding box of the affine transform projection of the given source rectangular ROI

Calculates affine transform projection of given source rectangular ROI

Calculates affine transform coefficients given source rectangular ROI and its destination quadrangle projection

Calculate destination image SizeROI width and height from source image ROI width and height and downsampling rate. It is highly recommended that this function be use to determine the destination image ROI for consistent results.

Calculate destination image SizeROI width and height from source image ROI width and height and downsampling rate. It is highly recommended that this function be use to determine the destination image ROI for consistent results.

Calculates bounding box of the affine transform projection of the given source rectangular ROI

Calculates perspective transform projection of given source rectangular ROI

Calculates affine transform coefficients given source rectangular ROI and its destination quadrangle projection

Compute bounding-box of rotated image.

Compute shape of rotated image.

3 channel 8-bit unsigned packed RGB to 1 channel 8-bit unsigned packed Gray Gradient conversion.

3 channel 8-bit unsigned packed RGB to optional 1 channel 16-bit signed X (vertical), Y (horizontal), magnitude, and/or 32-bit floating point angle gradient vectors with user selectable fixed mask size and distance method with border control.

3 channel 8-bit unsigned packed RGB to optional 1 channel 16-bit signed X (vertical), Y (horizontal), magnitude, and/or 32-bit floating point angle gradient vectors with user selectable fixed mask size and distance method with border control.

3 channel 8-bit unsigned packed RGB to optional 1 channel 16-bit signed X (vertical), Y (horizontal), magnitude, and/or 32-bit floating point angle gradient vectors with user selectable fixed mask size and distance method with border control.

3 channel 8-bit unsigned packed HLS to 3 channel 8-bit unsigned planar BGR color conversion.

3 channel 8-bit unsigned planar HLS to 3 channel 8-bit unsigned planar BGR color conversion.

3 channel 8-bit unsigned planar HLS to 3 channel 8-bit unsigned packed BGR color conversion.

3 channel 8-bit unsigned packed HLS to 3 channel 8-bit unsigned packed RGB color conversion.

3 channel 8-bit unsigned packed HSV to 3 channel 8-bit unsigned packed RGB color conversion.

Histogram with evenly distributed bins. Buffer is internally allocated and freed.

Histogram with evenly distributed bins. No additional buffer is allocated.

Scratch-buffer size for HistogramEven.

Histogram with bins determined by pLevels array. Buffer is internally allocated and freed.

Histogram with bins determined by pLevels array. No additional buffer is allocated.

Scratch-buffer size for HistogramRange.

image bit shift by constant (left), inplace.

image bit shift by constant (left).

Inplace look-up-table color conversion. The LUT is derived from a set of user defined mapping points with no interpolation.

look-up-table color conversion. The LUT is derived from a set of user defined mapping points with no interpolation.

Inplace cubic interpolated look-up-table color conversion. The LUT is derived from a set of user defined mapping points through cubic interpolation.

cubic interpolated look-up-table color conversion. The LUT is derived from a set of user defined mapping points through cubic interpolation.

Inplace linear interpolated look-up-table color conversion. The LUT is derived from a set of user defined mapping points through cubic interpolation.

range restricted palette look-up-table color conversion. The LUT is derived from a set of user defined mapping points in a palette and source pixels are then processed using a restricted bit range when looking up palette values.

Three channel 8-bit unsigned source bit range restricted palette look-up-table color conversion to four channel 8-bit unsigned destination output with alpha. The LUT is derived from a set of user defined mapping points in a palette and source pixels are then processed using a restricted bit range when looking up palette values. This function also reverses the source pixel channel order in the destination so the Alpha channel is the first channel.

3 channel 8-bit unsigned packed LUV to 3 channel 8-bit unsigned packed RGB color conversion.

3 channel 8-bit unsigned packed Lab to 3 channel 8-bit unsigned packed BGR color conversion.

Natural logarithm, scale by 2^(-nScaleFactor), then clamp to saturated value.

Natural logarithm, scale by 2^(-nScaleFactor), then clamp to saturated value.

look-up-table color conversion. The LUT is derived from a set of user defined mapping points through linear interpolation.

Image pixel maximum. Buffer is internally allocated and freed.

Image pixel maximum. No additional buffer is allocated.

image maximum error. User buffer is internally allocated and freed.

image maximum error.

Device scratch buffer size (in bytes) for MaxError.

image MaxEvery

Scratch-buffer size for Max.

Image pixel maximum. Buffer is internally allocated and freed.

Image pixel minimum. No additional buffer is allocated.

Scratch-buffer size for MaxIndex.

image maximum relative error. User buffer is internally allocated and freed.

image maximum relative error.

Device scratch buffer size (in bytes) for MaximumRelativeError.

image mean with 64-bit double precision result. Buffer is internally allocated and freed.

image mean with 64-bit double precision result. No additional buffer is allocated.

image mean with 64-bit double precision result. Buffer is internally allocated and freed.

image mean with 64-bit double precision result. No additional buffer is allocated.

Scratch-buffer size for Mean.

Scratch-buffer size for Mean with mask.

image mean and standard deviation. Buffer is internally allocated and freed.

image sum with 64-bit double precision result. No additional buffer is allocated.

image mean and standard deviation. Buffer is internally allocated and freed.

image sum with 64-bit double precision result. No additional buffer is allocated.

Scratch-buffer size for MeanStdDev.

Scratch-buffer size for MeanStdDev (masked).

Image pixel minimum. Buffer is internally allocated and freed.

Image pixel minimum. No additional buffer is allocated.

image MinEvery

Scratch-buffer size for Min.

Image pixel minimum. Buffer is internally allocated and freed.

Image pixel minimum. No additional buffer is allocated.

Scratch-buffer size for MinIndex.

Image pixel minimum and maximum. Buffer is internally allocated and freed.

Image pixel minimum and maximum. No additional buffer is allocated.

Scratch-buffer size for MinMax.

Image pixel minimum and maximum values with their indices. Buffer is internally allocated and freed.

Image pixel minimum and maximum values with their indices. No additional buffer is allocated.

Image pixel minimum and maximum values with their indices. Buffer is internally allocated and freed.

Image pixel minimum and maximum values with their indices. No additional buffer is allocated.

Scratch-buffer size for MinMaxIndex.

Scratch-buffer size for MinMaxIndex with mask.

Mirror image.

Mirror image inplace.

In place image multiplication and scale by max bit width value

Image multiplication and scale by max bit width value.

Image multiplication, scale by 2^(-nScaleFactor), then clamp to saturated value.

In place image multiplication, scale by 2^(-nScaleFactor), then clamp to saturated value.

Multiply constant to image and scale by max bit width value

Multiply constant to image and scale by max bit width value

Multiply constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value.

Multiply constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Inplace.

Creates a new NPPImage from allocated device ptr.

Creates a new NPPImage from allocated device ptr.

Creates a new NPPImage from allocated device ptr. Does not take ownership of decPtr.

Creates a new NPPImage from allocated device ptr.

Creates a new NPPImage from allocated device ptr. Does not take ownership of inner image device pointer.

Allocates new memory on device using NPP-Api.

Allocates new memory on device using NPP-Api.

Device scratch buffer size (in bytes) for NormDiff_Inf.

Device scratch buffer size (in bytes) for NormDiff_Inf.

Device scratch buffer size (in bytes) for NormDiff_L1.

Device scratch buffer size (in bytes) for NormDiff_L1.

Device scratch buffer size (in bytes) for NormDiff_L2.

Device scratch buffer size (in bytes) for NormDiff_L2.

image NormDiff_Inf. Buffer is internally allocated and freed.

image NormDiff_Inf.

image NormDiff_Inf. Buffer is internally allocated and freed.

image NormDiff_Inf.

image NormDiff_L1. Buffer is internally allocated and freed.

image NormDiff_L1.

image NormDiff_L1. Buffer is internally allocated and freed.

image NormDiff_L1.

image NormDiff_L2. Buffer is internally allocated and freed.

image NormDiff_L2.

image NormDiff_L2. Buffer is internally allocated and freed.

image NormDiff_L2.

image infinity norm. Buffer is internally allocated and freed.

image infinity norm. No additional buffer is allocated.

image infinity norm. Buffer is internally allocated and freed.

image infinity norm. No additional buffer is allocated.

Scratch-buffer size for Norm inf.

Scratch-buffer size for Norm inf (masked).

image L1 norm. Buffer is internally allocated and freed.

image L1 norm. No additional buffer is allocated.

image L1 norm. Buffer is internally allocated and freed.

image L1 norm. No additional buffer is allocated.

Scratch-buffer size for Norm L1.

Scratch-buffer size for Norm L1 (masked).

image L2 norm. Buffer is internally allocated and freed.

image L2 norm. No additional buffer is allocated.

image L2 norm. Buffer is internally allocated and freed.

image L2 norm. No additional buffer is allocated.

Scratch-buffer size for Norm L2.

Scratch-buffer size for Norm L2 (masked).

Device scratch buffer size (in bytes) for NormRel_Inf.

Device scratch buffer size (in bytes) for NormRel_Inf.

Device scratch buffer size (in bytes) for NormRel_L1.

Device scratch buffer size (in bytes) for NormRel_L1.

Device scratch buffer size (in bytes) for NormRel_L2.

Device scratch buffer size (in bytes) for NormRel_L2.

image NormRel_Inf. Buffer is internally allocated and freed.

image NormRel_Inf.

image NormRel_Inf. Buffer is internally allocated and freed.

image NormRel_Inf.

image NormRel_L1. Buffer is internally allocated and freed.

image NormRel_L1.

image NormRel_L1. Buffer is internally allocated and freed.

image NormRel_L1.

image NormRel_L2. Buffer is internally allocated and freed.

image NormRel_L2.

image NormRel_L2. Buffer is internally allocated and freed.

image NormRel_L2.

In place image logical Not.

Image logical Not.

In place image logical Or.

Image logical Or.

In place image logical Or with constant.

Image logical Or with constant.

image QualityIndex.

image QualityIndex.

Device scratch buffer size (in bytes) for QualityIndex.

3 channel 8-bit unsigned packed RGB to 2 channel 8-bit unsigned packed CbYCr422 color conversion.

3 channel 8-bit unsigned packed RGB first gets forward gamma corrected then converted to 2 channel 8-bit unsigned packed CbYCr422 color conversion.

RGB to Gray conversion

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned packed HLS color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned packed HSV color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned packed LUV color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned packed XYZ color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned packed YCC color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel unsigned 8-bit packed YCbCr color conversion.

3 channel planar 8-bit unsigned RGB to YCbCr color conversion.

3 channel 8-bit unsigned RGB to 2 channel chroma packed YCbCr422 color conversion.

3 channel 8-bit unsigned packed RGB to packed YCbCr color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned planar YCbCr411 color conversion.

3 channel 8-bit unsigned packed RGB to planar YCbCr420 color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned planar YCbCr422 color conversion.

3 channel 8-bit unsigned planar RGB to 2 channel 8-bit unsigned packed YCbCr422 color conversion.

3 channel 8-bit unsigned planar RGB to 2 channel 8-bit unsigned packed YCrCb422 color conversion.

3 channel 8-bit unsigned packed RGB to 2 channel 8-bit unsigned packed YCrCb422 color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned planar YUV color conversion.

3 channel 8-bit unsigned planar RGB to 3 channel 8-bit unsigned planar YUV color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned packed YUV color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned planar YUV420 color conversion.

3 channel 8-bit unsigned planar RGB to 3 channel 8-bit unsigned planar YUV420 color conversion.

3 channel 8-bit unsigned packed RGB to 3 channel 8-bit unsigned planar YUV422 color conversion.

3 channel 8-bit unsigned planar RGB to 3 channel 8-bit unsigned planar YUV422 color conversion.

3 channel 8-bit unsigned packed RGB to 2 channel 8-bit unsigned packed YUV422 color conversion.

image bit shift by constant (right), inplace.

image bit shift by constant (right).

planar image remap.

image remap.

resizes planar images.

Resizes images.

planar image resize.

image resize.

Rotate images.

Device scratch buffer size (in bytes) for CrossCorrSame_NormLevel.

Device scratch buffer size (in bytes) for CrossCorrSame_NormLevel.

image conversion.

image conversion.

image conversion.

image conversion.

Set pixel values to nValue.

Set pixel values to nValue. The 8-bit mask image affects setting of the respective pixels in the destination image. If the mask value is zero (0) the pixel is not set, if the mask is non-zero, the corresponding destination pixel is set to specified value.

Set pixel values to nValue. The 8-bit mask image affects setting of the respective pixels in the destination image. If the mask value is zero (0) the pixel is not set, if the mask is non-zero, the corresponding destination pixel is set to specified value.

horizontal Sobel filter.

Image squared, scale by 2^(-nScaleFactor), then clamp to saturated value.

Inplace image squared, scale by 2^(-nScaleFactor), then clamp to saturated value.

image SqrDistanceFull_Norm.

image SqrDistanceFull_Norm.

image SqrDistanceSame_Norm.

image SqrDistanceSame_Norm.

image SqrDistanceValid_Norm.

image SqrDistanceValid_Norm.

Image square root, scale by 2^(-nScaleFactor), then clamp to saturated value.

Inplace image square root, scale by 2^(-nScaleFactor), then clamp to saturated value.

Image subtraction, scale by 2^(-nScaleFactor), then clamp to saturated value.

In place image subtraction, scale by 2^(-nScaleFactor), then clamp to saturated value.

Subtract constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value.

Subtract constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Inplace.

image sum with 64-bit double precision result. Buffer is internally allocated and freed.

image sum with 64-bit double precision result. No additional buffer is allocated.

Scratch-buffer size for nppiSum_8u_C3R.

8-bit unsigned 1D (column) sum to 32f. Apply Column Window Summation filter over a 1D mask region around each source pixel for 3-channel 8 bit/pixel input images with 32-bit floating point output. Result 32-bit floating point pixel is equal to the sum of the corresponding and neighboring column pixel values in a mask region of the source image defined by nMaskSize and nAnchor.

Apply Column Window Summation filter over a 1D mask region around each source pixel for 3-channel 8 bit/pixel input images with 32-bit floating point output. Result 32-bit floating point pixel is equal to the sum of the corresponding and neighboring column pixel values in a mask region of the source image defined by nMaskSize and nAnchor.

8-bit unsigned 1D (row) sum to 32f. Apply Row Window Summation filter over a 1D mask region around each source pixel for 3-channel 8-bit pixel input images with 32-bit floating point output. Result 32-bit floating point pixel is equal to the sum of the corresponding and neighboring row pixel values in a mask region of the source image defined by nKernelDim and nAnchorX.

Apply Row Window Summation filter over a 1D mask region around each source pixel for 3-channel 8-bit pixel input images with 32-bit floating point output. Result 32-bit floating point pixel is equal to the sum of the corresponding and neighboring row pixel values in a mask region of the source image defined by nKernelDim and nAnchorX.

Swap color channels

Swap color channels

Swap color channels inplace

Image threshold. If for a comparison operations OP the predicate (sourcePixel OP nThreshold) is true, the pixel is set to nThreshold, otherwise it is set to sourcePixel.

Image threshold. If for a comparison operations OP the predicate (sourcePixel OP nThreshold) is true, the pixel is set to nValue, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations OP the predicate (sourcePixel OP nThreshold) is true, the pixel is set to nThreshold, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations OP the predicate (sourcePixel OP nThreshold) is true, the pixel is set to nValue, otherwise it is set to sourcePixel.

Image threshold. If for a comparison operations sourcePixel is greater than nThreshold is true, the pixel is set to nThreshold, otherwise it is set to sourcePixel.

Image threshold. If for a comparison operations sourcePixel is greater than nThreshold is true, the pixel is set to nValue, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations sourcePixel is greater than nThreshold is true, the pixel is set to nThreshold, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations sourcePixel is greater than nThreshold is true, the pixel is set to nValue, otherwise it is set to sourcePixel.

Image threshold. If for a comparison operations sourcePixel is less than nThreshold is true, the pixel is set to nThreshold, otherwise it is set to sourcePixel.

Image threshold. If for a comparison operations sourcePixel is less than nThreshold is true, the pixel is set to nValue, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations sourcePixel is less than nThreshold is true, the pixel is set to nThreshold, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations sourcePixel is less than nThreshold is true, the pixel is set to nValue, otherwise it is set to sourcePixel.

Image threshold. If for a comparison operations sourcePixel is less than nThresholdLT is true, the pixel is set to nValueLT, else if sourcePixel is greater than nThresholdGT the pixel is set to nValueGT, otherwise it is set to sourcePixel.

In place image threshold. If for a comparison operations sourcePixel is less than nThresholdLT is true, the pixel is set to nValueLT, else if sourcePixel is greater than nThresholdGT the pixel is set to nValueGT, otherwise it is set to sourcePixel.

Converts a NPPImage to a CudaPitchedDeviceVariable

image transpose

Device scratch buffer size (in bytes) for CrossCorrValid_NormLevel.

Device scratch buffer size (in bytes) for CrossCorrValid_NormLevel.

Affine transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetAffineTransform function or set explicitly. The function operates on source and destination regions of interest. The affine warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = C_00 * x + C_01 * y + C_02 Y_new = C_10 * x + C_11 * y + C_12 The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetAffineQuad and nppiGetAffineBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but does not perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Affine transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetAffineTransform function or set explicitly. The function operates on source and destination regions of interest. The affine warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = C_00 * x + C_01 * y + C_02 Y_new = C_10 * x + C_11 * y + C_12 The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetAffineQuad and nppiGetAffineBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but does not perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Inverse affine transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetAffineTransform function or set explicitly. Thus there is no need to invert coefficients in your application before calling WarpAffineBack. The function operates on source and destination regions of interest. The affine warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = C_00 * x + C_01 * y + C_02 Y_new = C_10 * x + C_11 * y + C_12 The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetAffineQuad and nppiGetAffineBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Inverse affine transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetAffineTransform function or set explicitly. Thus there is no need to invert coefficients in your application before calling WarpAffineBack. The function operates on source and destination regions of interest. The affine warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = C_00 * x + C_01 * y + C_02 Y_new = C_10 * x + C_11 * y + C_12 The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetAffineQuad and nppiGetAffineBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Affine transform of an image. This function performs affine warping of a the specified quadrangle in the source image to the specified quadrangle in the destination image. The function nppiWarpAffineQuad uses the same formulas for pixel mapping as in nppiWarpAffine function. The transform coefficients are computed internally. The transformed part of the source image is resampled using the specified eInterpolation method and written to the destination ROI. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Affine transform of an image. This function performs affine warping of a the specified quadrangle in the source image to the specified quadrangle in the destination image. The function nppiWarpAffineQuad uses the same formulas for pixel mapping as in nppiWarpAffine function. The transform coefficients are computed internally. The transformed part of the source image is resampled using the specified eInterpolation method and written to the destination ROI. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Perspective transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetPerspectiveTransform function or set explicitly. The function operates on source and destination regions of interest. The perspective warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = (C_00 * x + C_01 * y + C_02) / (C_20 * x + C_21 * y + C_22) Y_new = (C_10 * x + C_11 * y + C_12) / (C_20 * x + C_21 * y + C_22) The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetPerspectiveQuad and nppiGetPerspectiveBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Perspective transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetPerspectiveTransform function or set explicitly. The function operates on source and destination regions of interest. The perspective warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = (C_00 * x + C_01 * y + C_02) / (C_20 * x + C_21 * y + C_22) Y_new = (C_10 * x + C_11 * y + C_12) / (C_20 * x + C_21 * y + C_22) The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetPerspectiveQuad and nppiGetPerspectiveBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Inverse perspective transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetPerspectiveTransform function or set explicitly. Thus there is no need to invert coefficients in your application before calling WarpPerspectiveBack. The function operates on source and destination regions of interest. The perspective warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = (C_00 * x + C_01 * y + C_02) / (C_20 * x + C_21 * y + C_22) Y_new = (C_10 * x + C_11 * y + C_12) / (C_20 * x + C_21 * y + C_22) The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetPerspectiveQuad and nppiGetPerspectiveBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Inverse perspective transform of an image. This function operates using given transform coefficients that can be obtained by using nppiGetPerspectiveTransform function or set explicitly. Thus there is no need to invert coefficients in your application before calling WarpPerspectiveBack. The function operates on source and destination regions of interest. The perspective warp function transforms the source image pixel coordinates (x,y) according to the following formulas: X_new = (C_00 * x + C_01 * y + C_02) / (C_20 * x + C_21 * y + C_22) Y_new = (C_10 * x + C_11 * y + C_12) / (C_20 * x + C_21 * y + C_22) The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. The functions nppiGetPerspectiveQuad and nppiGetPerspectiveBound can help with destination ROI specification. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.

Perspective transform of an image. This function performs perspective warping of a the specified quadrangle in the source image to the specified quadrangle in the destination image. The function nppiWarpPerspectiveQuad uses the same formulas for pixel mapping as in nppiWarpPerspective function. The transform coefficients are computed internally. The transformed part of the source image is resampled using the specified interpolation method and written to the destination ROI. NPPI specific recommendation: The function operates using 2 types of kernels: fast and accurate. The fast method is about 4 times faster than its accurate variant, but doesn't perform memory access checks and requires the destination ROI to be 64 bytes aligned. Hence any destination ROI is chunked into 3 vertical stripes: the first and the third are processed by accurate kernels and the central one is processed by the fast one. In order to get the maximum available speed of execution, the projection of destination ROI onto image addresses must be 64 bytes aligned. This is always true if the values (int)((void *)(pDst + dstRoi.x)) and (int)((void *)(pDst + dstRoi.x + dstRoi.width)) are multiples of 64. Another rule of thumb is to specify destination ROI in such way that left and right sides of the projected image are separated from the ROI by at least 63 bytes from each side. However, this requires the whole ROI to be part of allocated memory. In case when the conditions above are not satisfied, the function may decrease in speed slightly and will return NPP_MISALIGNED_DST_ROI_WARNING warning.