C# Class ManagedCuda.NPP.NPPImage_16uC1

Absolute difference of this minus src2.

Absolute difference with constant.

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.

One 8-bit unsigned char channel image product added to in place floating point destination image.

One 8-bit unsigned char channel image product added to in place floating point destination image using filter mask (updates destination when mask is non-zero).

One 8-bit unsigned char channel image squared then added to in place floating point destination image.

One 8-bit unsigned char channel image squared then added to in place floating point destination image using filter mask (updates destination when mask is non-zero).

One 8-bit unsigned char channel alpha weighted image added to in place floating point destination image using filter mask (updates destination when mask is non-zero).

One 8-bit unsigned char channel alpha weighted image added to in place floating point destination image.

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.

Grayscale Color Filter Array to RGB Color Debayer conversion. Generates one RGB color pixel for every grayscale source pixel. Source and destination images must have even width and height. Missing pixel colors are generated using bilinear interpolation with chroma correlation of generated green values (eInterpolation MUST be set to 0). eGrid allows the user to specify the Bayer grid registration position at source image location oSrcROI.x, oSrcROI.y relative to pSrc.

Grayscale Color Filter Array to RGB Color Debayer conversion. Generates one RGB color pixel for every grayscale source pixel. Source and destination images must have even width and height. Missing pixel colors are generated using bilinear interpolation with chroma correlation of generated green values (eInterpolation MUST be set to 0). eGrid allows the user to specify the Bayer grid registration position at source image location oSrcROI.x, oSrcROI.y relative to pSrc.

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.

Compare pSrc1's pixels with corresponding pixels in pSrc2.

Compare pSrc's pixels with constant value.

16-bit unsigned to 16-bit signed conversion.

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

16-bit unsigned to 32-bit signed conversion.

16-bit unsigned to 32-bit unsigned conversion.

16-bit unsigned to 8-bit signed conversion.

16-bit unsigned to 8-bit unsigned conversion.

Image copy.

Masked Operation 8-bit unsigned image copy.

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

Image copy.

Image copy.

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 CrossCorrFull_Norm.

CrossCorrFull_NormLevel. Buffer is internally allocated and freed.

CrossCorrFull_NormLevel.

image CrossCorrSame_Norm.

CrossCorrSame_NormLevel. Buffer is internally allocated and freed.

CrossCorrSame_NormLevel.

image CrossCorrValid.

image CrossCorrValid_Norm.

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_16u64f_C1R.

One-channel 16-bit unsigned image DotProd. Buffer is internally allocated and freed.

One-channel 16-bit unsigned image DotProd.

source image duplicated in all 3 channels of destination image.

source image duplicated in all 4 channels of destination image.

source image duplicated in 3 channels of 4 channel destination image with alpha channel unaffected.

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.

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.

Single channel 16-bit unsigned bilateral Gauss filter with border control.

One channel 16-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.

One channel 16-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

Single channel 16-bit unsigned Gauss filter with downsampling and border control.

Single channel 16-bit unsigned Gauss filter with downsampling and border control.

High pass filter.

High pass 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.

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 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.

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.

1 channel 16-bit unsigned packed RGB to optional 1 channel 32-bit floating point 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.

1 channel 16-bit unsigned packed RGB to optional 1 channel 32-bit floating point 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.

1 channel 16-bit unsigned packed RGB to optional 1 channel 32-bit floating point 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.

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.

range restricted palette look-up-table color conversion with 8-bit unsigned destination output per pixel. 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.

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.

linear interpolated look-up-table color conversion. The LUT is derived from a set of user defined mapping points through linear 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.

One channel 8-bit unsigned bit range restricted 32-bit palette look-up-table color conversion with 32-bit destination output per pixel. 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.

One channel 8-bit unsigned bit range restricted 24-bit palette look-up-table color conversion with 24-bit destination output per pixel. 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.

One channel 8-bit unsigned bit range restricted 32-bit palette look-up-table color conversion with 32-bit destination output per pixel. 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.

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

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

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 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.

image bit shift by constant (right), inplace.

image bit shift by constant (right).

image remap.

Resizes images.

image resize.

Rotate images.

Device scratch buffer size (in bytes) for CrossCorrSame_NormLevel.

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.

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 SqrDistanceSame_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_16u_C1R.

16-bit unsigned 1D (column) sum to 32f. Apply Column Window Summation filter over a 1D mask region around each source pixel for 1-channel 16 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 1-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.

16-bit unsigned 1D (row) sum to 32f. Apply Row Window Summation filter over a 1D mask region around each source pixel for 1-channel 16-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 1-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.

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.

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.

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.

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.

In place image logical Xor.

Image logical Xor.

In place image logical Xor with constant.

Image logical Xor with constant.