/// <summary>
/// convolution filter.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="pKernel">Pointer to the start address of the kernel coefficient array.<para/>
/// Coefficients are expected to be stored in reverse order.</param>
/// <param name="oKernelSize">Width and Height of the rectangular kernel.</param>
/// <param name="oAnchor">X and Y offsets of the kernel origin frame of reference</param>
public void Filter(NPPImage_16uC3 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_16u_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image square root, scale by 2^(-nScaleFactor), then clamp to saturated value.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="nScaleFactor">scaling factor</param>
public void Sqrt(NPPImage_16uC3 dest, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Sqrt.nppiSqrt_16u_C3RSfs(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSqrt_16u_C3RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Mirror image.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="flip">Specifies the axis about which the image is to be mirrored.</param>
public void Mirror(NPPImage_16uC3 dest, NppiAxis flip)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiMirror_16u_C3R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, flip);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMirror_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Filters the image using a separable Gaussian filter kernel with user supplied floating point coefficients
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="Kernel">Pointer to an array of nFilterTaps kernel coefficients which sum to 1.0F, where nFilterTaps = 2 * ((int)((float)ceil(radius) + 0.5F) ) + 1.</param>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
public void FilterGaussBorder(NPPImage_16uC3 dst, CudaDeviceVariable<float> Kernel, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterGaussBorder.nppiFilterGaussAdvancedBorder_16u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, Kernel.Size, Kernel.DevicePointer, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterGaussAdvancedBorder_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Multiply constant to image and scale by max bit width value
/// </summary>
/// <param name="nConstant">Value</param>
/// <param name="dest">Destination image</param>
public void Mul(ushort[] nConstant, NPPImage_16uC3 dest)
{
status = NPPNativeMethods.NPPi.MulConstScale.nppiMulCScale_16u_C3R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMulCScale_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
//New in Cuda 7.0
#region FilterColumnBorder
/// <summary>
/// General purpose 1D convolution column filter with border control.<para/>
/// 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.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="Kernel">Pointer to the start address of the kernel coefficient array. Coeffcients are expected to be stored in reverse order.</param>
/// <param name="nAnchor">X offset of the kernel origin frame of reference w.r.t the source pixel.</param>
/// <param name="nDivisor">The factor by which the convolved summation from the Filter operation should be divided. If equal to the sum of coefficients, this will keep the maximum result value within full scale.</param>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
public void FilterColumnBorder(NPPImage_16uC3 dest, CudaDeviceVariable<int> Kernel, int nAnchor, int nDivisor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.LinearFilter1D.nppiFilterColumnBorder_16u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, Kernel.DevicePointer, Kernel.Size, nAnchor, nDivisor, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterColumnBorder_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Sharpen filter.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
public void FilterSharpenBorder(NPPImage_16uC3 dst, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterSharpenBorder_16u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterSharpenBorder_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image CrossCorrValid_Norm.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="dst">Destination-Image</param>
public void CrossCorrValid_Norm(NPPImage_16uC3 tpl, NPPImage_32fC3 dst)
{
status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_Norm_16u32f_C3R(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointerRoi, dst.Pitch);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCrossCorrValid_Norm_16u32f_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormRel_L1.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="pNormRel">Pointer to the computed relative error for the infinity norm of two images. (1 * sizeof(double))</param>
/// <param name="nCOI">channel of interest.</param>
/// <param name="pMask">Mask image.</param>
/// <param name="buffer">Allocated device memory with size of at <see cref="NormRelL1MaskedGetBufferHostSize()"/></param>
public void NormRel_L1(NPPImage_16uC3 tpl, CudaDeviceVariable<double> pNormRel, int nCOI, NPPImage_8uC1 pMask, CudaDeviceVariable<byte> buffer)
{
int bufferSize = NormRelL1MaskedGetBufferHostSize();
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_L1_16u_C3CMR(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, pMask.DevicePointerRoi, pMask.Pitch, _sizeRoi, nCOI, pNormRel.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L1_16u_C3CMR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// CrossCorrSame_NormLevel.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="dst">Destination image</param>
/// <param name="buffer">Allocated device memory with size of at <see cref="SameNormLevelGetBufferHostSize()"/></param>
public void CrossCorrSame_NormLevel(NPPImage_16uC3 tpl, NPPImage_32fC3 dst, CudaDeviceVariable<byte> buffer)
{
int bufferSize = SameNormLevelGetBufferHostSize();
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrSame_NormLevel_16u32f_C3R(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointer, dst.Pitch, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCrossCorrSame_NormLevel_16u32f_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// CrossCorrValid_NormLevel. Buffer is internally allocated and freed.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="dst">Destination image</param>
public void CrossCorrValid_NormLevel(NPPImage_16uC3 tpl, NPPImage_32fC3 dst)
{
int bufferSize = ValidNormLevelGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_NormLevel_16u32f_C3R(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointer, dst.Pitch, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCrossCorrValid_NormLevel_16u32f_C3R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image logical Xor.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="dest">Destination image</param>
public void Xor(NPPImage_16uC3 src2, NPPImage_16uC3 dest)
{
status = NPPNativeMethods.NPPi.Xor.nppiXor_16u_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiXor_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormDiff_L1. Buffer is internally allocated and freed.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="pNormDiff">Pointer to the computed L1-norm of differences. (3 * sizeof(double))</param>
public void NormDiff_L1(NPPImage_16uC3 tpl, CudaDeviceVariable<double> pNormDiff)
{
int bufferSize = NormDiffL1GetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.NormDiff.nppiNormDiff_L1_16u_C3R(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, _sizeRoi, pNormDiff.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormDiff_L1_16u_C3R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Low pass filter.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="eMaskSize">Enumeration value specifying the mask size.</param>
public void FilterLowPass(NPPImage_16uC3 dst, MaskSize eMaskSize)
{
status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterLowPass_16u_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, eMaskSize);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterLowPass_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image average relative error.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="pError">Pointer to the computed error.</param>
/// <param name="buffer">Pointer to the user-allocated scratch buffer required for the AverageRelativeError operation.</param>
public void AverageRelativeError(NPPImage_16uC3 src2, CudaDeviceVariable<double> pError, CudaDeviceVariable<byte> buffer)
{
int bufferSize = AverageRelativeErrorGetBufferHostSize();
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.AverageRelativeError.nppiAverageRelativeError_16u_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormRel_L2. Buffer is internally allocated and freed.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="pNormRel">Pointer to the computed relative error for the infinity norm of two images. (1 * sizeof(double))</param>
/// <param name="nCOI">channel of interest.</param>
/// <param name="pMask">Mask image.</param>
public void NormRel_L2(NPPImage_16uC3 tpl, CudaDeviceVariable<double> pNormRel, int nCOI, NPPImage_8uC1 pMask)
{
int bufferSize = NormRelL2MaskedGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_L2_16u_C3CMR(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, pMask.DevicePointerRoi, pMask.Pitch, _sizeRoi, nCOI, pNormRel.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L2_16u_C3CMR", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Three channel 16-bit unsigned convolution filter with border control.<para/>
/// General purpose 2D convolution filter using floating-point weights with border control.<para/>
/// 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. <para/>
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="pKernel">Pointer to the start address of the kernel coefficient array. Coeffcients are expected to be stored in reverse order</param>
/// <param name="nKernelSize">Width and Height of the rectangular kernel.</param>
/// <param name="oAnchor">X and Y offsets of the kernel origin frame of reference relative to the source pixel.</param>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
public void FilterBorder(NPPImage_16uC3 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_16u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, pKernel.DevicePointer, nKernelSize, oAnchor, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterBorder32f_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image QualityIndex.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="dst">Pointer to the quality index. (3 * sizeof(float))</param>
public void QualityIndex(NPPImage_16uC3 src2, CudaDeviceVariable<float> dst)
{
int bufferSize = QualityIndexGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.QualityIndex.nppiQualityIndex_16u32f_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, dst.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiQualityIndex_16u32f_C3R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Computes the average pixel values of the pixels under a rectangular mask.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="oMaskSize">Width and Height of the neighborhood region for the local Avg operation.</param>
/// <param name="oAnchor">X and Y offsets of the kernel origin frame of reference w.r.t the source pixel.</param>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
public void FilterBoxBorder(NPPImage_16uC3 dest, NppiSize oMaskSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.LinearFixedFilters2D.nppiFilterBoxBorder_16u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, oMaskSize, oAnchor, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterBoxBorder_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image resize.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="nXFactor">Factor by which x dimension is changed. </param>
/// <param name="nYFactor">Factor by which y dimension is changed. </param>
/// <param name="nXShift">Source pixel shift in x-direction.</param>
/// <param name="nYShift">Source pixel shift in y-direction.</param>
/// <param name="eInterpolation">The type of eInterpolation to perform resampling.</param>
public void ResizeSqrPixel(NPPImage_16uC3 dst, double nXFactor, double nYFactor, double nXShift, double nYShift, InterpolationMode eInterpolation)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
NppiRect dstRect = new NppiRect(dst.PointRoi, dst.SizeRoi);
status = NPPNativeMethods.NPPi.ResizeSqrPixel.nppiResizeSqrPixel_16u_C3R(_devPtr, _sizeRoi, _pitch, srcRect, dst.DevicePointer, dst.Pitch, dstRect, nXFactor, nYFactor, nXShift, nYShift, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiResizeSqrPixel_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Filters the image using a unsharp-mask sharpening filter kernel with border control.<para/>
/// The algorithm involves the following steps:<para/>
/// Smooth the original image with a Gaussian filter, with the width controlled by the nRadius.<para/>
/// Subtract the smoothed image from the original to create a high-pass filtered image.<para/>
/// Apply any clipping needed on the high-pass image, as controlled by the nThreshold.<para/>
/// 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:<para/>
/// HighPass = Image - Gaussian(Image)<para/>
/// Result = Image + nWeight * HighPass * ( |HighPass| >= nThreshold ) <para/>
/// where nWeight is the amount, nThreshold is the threshold, and >= indicates a Boolean operation, 1 if true, or 0 otherwise.
/// <para/>
/// 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.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="nRadius">The radius of the Gaussian filter, in pixles, not counting the center pixel.</param>
/// <param name="nSigma">The standard deviation of the Gaussian filter, in pixel.</param>
/// <param name="nWeight">The percentage of the difference between the original and the high pass image that is added back into the original.</param>
/// <param name="nThreshold">The threshold needed to apply the difference amount.</param>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
/// <param name="buffer">Pointer to the user-allocated device scratch buffer required for the unsharp operation.</param>
public void FilterUnsharpBorder(NPPImage_16uC3 dst, float nRadius, float nSigma, float nWeight, float nThreshold, NppiBorderType eBorderType, CudaDeviceVariable<byte> buffer)
{
if (buffer.Size < FilterUnsharpGetBufferSize(nRadius, nSigma))
throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterUnsharpBorder_16u_C3R(_devPtr, _pitch, _pointRoi, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nRadius, nSigma, nWeight, nThreshold, eBorderType, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterUnsharpBorder_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image remap.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="pXMap">Device memory pointer to 2D image array of X coordinate values to be used when sampling source image. </param>
/// <param name="pYMap">Device memory pointer to 2D image array of Y coordinate values to be used when sampling source image. </param>
/// <param name="eInterpolation">The type of eInterpolation to perform resampling.</param>
public void Remap(NPPImage_16uC3 dst, NPPImage_32fC1 pXMap, NPPImage_32fC1 pYMap, InterpolationMode eInterpolation)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
status = NPPNativeMethods.NPPi.Remap.nppiRemap_16u_C3R(_devPtr, _sizeRoi, _pitch, srcRect, pXMap.DevicePointerRoi, pXMap.Pitch, pYMap.DevicePointerRoi, pYMap.Pitch, dst.DevicePointerRoi, dst.Pitch, dst.SizeRoi, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRemap_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image multiplication and scale by max bit width value
/// </summary>
/// <param name="src2">2nd source image</param>
public void Mul(NPPImage_16uC3 src2)
{
status = NPPNativeMethods.NPPi.MulScale.nppiMulScale_16u_C3IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMulScale_16u_C3IR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Resizes images.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="xFactor">X scaling factor</param>
/// <param name="yFactor">Y scaling factor</param>
/// <param name="eInterpolation">Interpolation mode</param>
public void Resize(NPPImage_16uC3 dest, double xFactor, double yFactor, InterpolationMode eInterpolation)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiResize_16u_C3R(_devPtr, _sizeOriginal, _pitch, new NppiRect(_pointRoi, _sizeRoi), dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, xFactor, yFactor, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiResize_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image division, scale by 2^(-nScaleFactor), then clamp to saturated value.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="rndMode">Result Rounding mode to be used</param>
/// <param name="nScaleFactor">scaling factor</param>
public void Div(NPPImage_16uC3 src2, NppRoundMode rndMode, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.DivRound.nppiDiv_Round_16u_C3IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, rndMode, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_Round_16u_C3IRSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Result pixel value is the median of pixel values under the rectangular mask region.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="oMaskSize">Width and Height of the neighborhood region for the local Median operation.</param>
/// <param name="oAnchor">X and Y offsets of the kernel origin frame of reference relative to the source pixel.</param>
/// <param name="buffer">Pointer to the user-allocated scratch buffer required for the Median operation.</param>
public void FilterMedian(NPPImage_16uC3 dst, NppiSize oMaskSize, NppiPoint oAnchor, CudaDeviceVariable<byte> buffer)
{
int bufferSize = FilterMedianGetBufferHostSize(oMaskSize);
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.ImageMedianFilter.nppiFilterMedian_16u_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, oMaskSize, oAnchor, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMedian_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Rotate images.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="nAngle">The angle of rotation in degrees.</param>
/// <param name="nShiftX">Shift along horizontal axis</param>
/// <param name="nShiftY">Shift along vertical axis</param>
/// <param name="eInterpolation">Interpolation mode</param>
public void Rotate(NPPImage_16uC3 dest, double nAngle, double nShiftX, double nShiftY, InterpolationMode eInterpolation)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiRotate_16u_C3R(_devPtr, _sizeRoi, _pitch, new NppiRect(_pointRoi, _sizeRoi),
dest.DevicePointer, dest.Pitch, new NppiRect(dest.PointRoi, dest.SizeRoi), nAngle, nShiftX, nShiftY, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRotate_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image maximum relative error. User buffer is internally allocated and freed.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="pError">Pointer to the computed error.</param>
public void MaximumRelativeError(NPPImage_16uC3 src2, CudaDeviceVariable<double> pError)
{
int bufferSize = MaximumRelativeErrorGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_16u_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_16u_C3R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Inverse affine transform of an image.<para/>
/// 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.<para/>
/// The affine warp function transforms the source image pixel coordinates
/// (x,y) according to the following formulas:<para/>
/// X_new = C_00 * x + C_01 * y + C_02<para/>
/// Y_new = C_10 * x + C_11 * y + C_12<para/>
/// 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.<para/><para/>
/// NPPI specific recommendation: <para/>
/// 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 <para/>
/// <code>(int)((void *)(pDst + dstRoi.x))</code> and <para/>
/// <code>(int)((void *)(pDst + dstRoi.x + dstRoi.width))</code> <para/>
/// 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.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="coeffs">Affine transform coefficients [2,3]</param>
/// <param name="eInterpolation">Interpolation mode: can be <see cref="InterpolationMode.NearestNeighbor"/>, <see cref="InterpolationMode.Linear"/> or <see cref="InterpolationMode.Cubic"/></param>
public void WarpAffineBack(NPPImage_16uC3 dest, double[,] coeffs, InterpolationMode eInterpolation)
{
NppiRect rectIn = new NppiRect(_pointRoi, _sizeRoi);
NppiRect rectOut = new NppiRect(dest.PointRoi, dest.SizeRoi);
status = NPPNativeMethods.NPPi.AffinTransforms.nppiWarpAffineBack_16u_C3R(_devPtr, _sizeOriginal, _pitch, rectIn, dest.DevicePointer, dest.Pitch, rectOut, coeffs, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiWarpAffineBack_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Result pixel value is the maximum of pixel values under the rectangular mask region.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="oMaskSize">Width and Height of the neighborhood region for the local Avg operation.</param>
/// <param name="oAnchor">X and Y offsets of the kernel origin frame of reference w.r.t the source pixel.</param>
public void FilterMax(NPPImage_16uC3 dest, NppiSize oMaskSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.RankFilters.nppiFilterMax_16u_C3R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, oMaskSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMax_16u_C3R", status));
NPPException.CheckNppStatus(status, this);
}
