/// <summary>
/// image remap. Not affecting Alpha.
/// </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 RemapA(NPPImage_16sC4 dst, NPPImage_32fC1 pXMap, NPPImage_32fC1 pYMap, InterpolationMode eInterpolation)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
status = NPPNativeMethods.NPPi.Remap.nppiRemap_16s_AC4R(_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_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 8-bit unsigned to 16-bit signed conversion. Not affecting Alpha channel.
/// </summary>
/// <param name="dst">Destination image</param>
public void ConvertA(NPPImage_16sC4 dst)
{
status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_8u16s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_8u16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image conversion. Not affecting Alpha.
/// </summary>
/// <param name="dst">Destination-Image</param>
public void ScaleA(NPPImage_16sC4 dst)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
status = NPPNativeMethods.NPPi.Scale.nppiScale_8u16s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiScale_8u16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image division, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha.
/// </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 DivA(NPPImage_16sC4 src2, NppRoundMode rndMode, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.DivRound.nppiDiv_Round_16s_AC4IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, rndMode, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_Round_16s_AC4IRSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image copy.
/// </summary>
/// <param name="dst">Destination image</param>
/// <param name="channel">Channel number. This number is added to the dst pointer</param>
public void Copy(NPPImage_16sC4 dst, int channel)
{
if (channel < 0 | channel >= dst.Channels) throw new ArgumentOutOfRangeException("channel", "channel must be in range [0..3].");
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_16s_C1C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi + channel * _typeSize, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_16s_C1C4R", 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 FilterUnsharpBorderA(NPPImage_16sC4 dst, float nRadius, float nSigma, float nWeight, float nThreshold, NppiBorderType eBorderType, CudaDeviceVariable<byte> buffer)
{
if (buffer.Size < FilterUnsharpGetBufferSizeA(nRadius, nSigma))
throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterUnsharpBorder_16s_AC4R(_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_16s_AC4R", 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 FilterGaussBorderA(NPPImage_16sC4 dst, CudaDeviceVariable<float> Kernel, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterGaussBorder.nppiFilterGaussAdvancedBorder_16s_AC4R(_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_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// linearly interpolated source image subpixel coordinate color copy. Not affecting Alpha.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="nDx">Fractional part of source image X coordinate.</param>
/// <param name="nDy">Fractional part of source image Y coordinate.</param>
public void CopySubpixA(NPPImage_16sC4 dst, float nDx, float nDy)
{
status = NPPNativeMethods.NPPi.CopySubpix.nppiCopySubpix_16s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nDx, nDy);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopySubpix_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormRel_L1. Not affecting Alpha.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="pNormRel">Pointer to the computed relative error for the infinity norm of two images. (3 * sizeof(double))</param>
/// <param name="buffer">Allocated device memory with size of at <see cref="NormRelL1AGetBufferHostSize()"/></param>
public void NormRel_L1A(NPPImage_16sC4 tpl, CudaDeviceVariable<double> pNormRel, CudaDeviceVariable<byte> buffer)
{
int bufferSize = NormRelL1AGetBufferHostSize();
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_L1_16s_AC4R(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, _sizeRoi, pNormRel.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L1_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Mirror image. Not affecting Alpha.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="flip">Specifies the axis about which the image is to be mirrored.</param>
public void MirrorA(NPPImage_16sC4 dest, NppiAxis flip)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiMirror_16s_AC4R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, flip);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMirror_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image copy with the borders wrapped by replication of source image pixel colors. Not affecting Alpha.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="nTopBorderHeight">Height (in pixels) of the top border. The height of the border at the bottom of
/// the destination ROI is implicitly defined by the size of the source ROI: nBottomBorderHeight =
/// oDstSizeROI.height - nTopBorderHeight - oSrcSizeROI.height.</param>
/// <param name="nLeftBorderWidth">Width (in pixels) of the left border. The width of the border at the right side of
/// the destination ROI is implicitly defined by the size of the source ROI: nRightBorderWidth =
/// oDstSizeROI.width - nLeftBorderWidth - oSrcSizeROI.width.</param>
public void CopyWrapBorderA(NPPImage_16sC4 dst, int nTopBorderHeight, int nLeftBorderWidth)
{
status = NPPNativeMethods.NPPi.CopyWrapBorder.nppiCopyWrapBorder_16s_AC4R(_devPtrRoi, _pitch, _sizeRoi, dst.DevicePointerRoi, dst.Pitch, dst.SizeRoi, nTopBorderHeight, nLeftBorderWidth);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopyWrapBorder_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image MaxEvery Not affecting Alpha.
/// </summary>
/// <param name="src2">Source-Image</param>
public void MaxEveryA(NPPImage_16sC4 src2)
{
status = NPPNativeMethods.NPPi.MinMaxEvery.nppiMaxEvery_16s_AC4IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaxEvery_16s_AC4IR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// look-up-table color conversion.<para/>
/// The LUT is derived from a set of user defined mapping points through linear interpolation. Not affecting alpha channel.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="values0">array of user defined OUTPUT values, channel 0</param>
/// <param name="levels0">array of user defined INPUT values, channel 0</param>
/// <param name="values1">array of user defined OUTPUT values, channel 1</param>
/// <param name="levels1">array of user defined INPUT values, channel 1</param>
/// <param name="values2">array of user defined OUTPUT values, channel 2</param>
/// <param name="levels2">array of user defined INPUT values, channel 2</param>
public void LutA(NPPImage_16sC4 dest, CudaDeviceVariable<int> values0, CudaDeviceVariable<int> levels0, CudaDeviceVariable<int> values1,
CudaDeviceVariable<int> levels1, CudaDeviceVariable<int> values2, CudaDeviceVariable<int> levels2)
{
if (values0.Size != levels0.Size) throw new ArgumentException("values0 and levels0 must have same size.");
if (values1.Size != levels1.Size) throw new ArgumentException("values1 and levels1 must have same size.");
if (values2.Size != levels2.Size) throw new ArgumentException("values2 and levels2 must have same size.");
CUdeviceptr[] values = new CUdeviceptr[3];
CUdeviceptr[] levels = new CUdeviceptr[3];
int[] levelLengths = new int[3];
values[0] = values0.DevicePointer;
values[1] = values1.DevicePointer;
values[2] = values2.DevicePointer;
levels[0] = levels0.DevicePointer;
levels[1] = levels1.DevicePointer;
levels[2] = levels2.DevicePointer;
levelLengths[0] = levels0.Size;
levelLengths[1] = levels1.Size;
levelLengths[2] = levels2.Size;
status = NPPNativeMethods.NPPi.ColorLUTLinear.nppiLUT_Linear_16s_AC4R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, values, levels, levelLengths);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiLUT_Linear_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// cubic interpolated look-up-table color conversion.
/// The LUT is derived from a set of user defined mapping points through cubic interpolation. Not affecting Alpha.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="pValues">Host pointer to an array of 3 device memory pointers, one per color CHANNEL, pointing to user defined OUTPUT values.</param>
/// <param name="pLevels">Host pointer to an array of 3 device memory pointers, one per color CHANNEL, pointing to user defined INPUT values. pLevels.Size gives nLevels.</param>
public void LUTCubicA(NPPImage_16sC4 dst, CudaDeviceVariable<int>[] pValues, CudaDeviceVariable<int>[] pLevels)
{
CUdeviceptr[] ptrsV = new CUdeviceptr[] { pValues[0].DevicePointer, pValues[1].DevicePointer, pValues[2].DevicePointer };
CUdeviceptr[] ptrsL = new CUdeviceptr[] { pLevels[0].DevicePointer, pLevels[1].DevicePointer, pLevels[2].DevicePointer };
int[] size = new int[] { pLevels[0].Size, pLevels[1].Size, pLevels[2].Size };
status = NPPNativeMethods.NPPi.ColorLUTCubic.nppiLUT_Cubic_16s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, ptrsV, ptrsL, size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiLUT_Cubic_16s_AC4R", 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>
/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
public void FilterMaxBorder(NPPImage_16sC4 dest, NppiSize oMaskSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.RankFilters.nppiFilterMaxBorder_16s_C4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, oMaskSize, oAnchor, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMaxBorder_16s_C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormRel_L2. Buffer is internally allocated and freed. Not affecting Alpha.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="pNormRel">Pointer to the computed relative error for the infinity norm of two images. (3 * sizeof(double))</param>
public void NormRel_L2A(NPPImage_16sC4 tpl, CudaDeviceVariable<double> pNormRel)
{
int bufferSize = NormRelL2AGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_L2_16s_AC4R(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, _sizeRoi, pNormRel.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L2_16s_AC4R", status));
buffer.Dispose();
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 FilterSharpenBorderA(NPPImage_16sC4 dst, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterSharpenBorder_16s_AC4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, eBorderType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterSharpenBorder_16s_AC4R", 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>
public void FilterMedian(NPPImage_16sC4 dst, NppiSize oMaskSize, NppiPoint oAnchor)
{
int bufferSize = FilterMedianGetBufferHostSize(oMaskSize);
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.ImageMedianFilter.nppiFilterMedian_16s_C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, oMaskSize, oAnchor, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMedian_16s_C4R", status));
buffer.Dispose();
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>
public void FilterGauss(NPPImage_16sC4 dst, CudaDeviceVariable<float> Kernel)
{
status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterGaussAdvanced_16s_C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, Kernel.Size, Kernel.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterGaussAdvanced_16s_C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Result pixel value is the median of pixel values under the rectangular mask region, ignoring alpha channel.
/// </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 FilterMedianA(NPPImage_16sC4 dst, NppiSize oMaskSize, NppiPoint oAnchor, CudaDeviceVariable<byte> buffer)
{
int bufferSize = FilterMedianGetBufferHostSizeA(oMaskSize);
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.ImageMedianFilter.nppiFilterMedian_16s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, oMaskSize, oAnchor, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMedian_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image multiplication, scale by 2^(-nScaleFactor), then clamp to saturated value.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="nScaleFactor">scaling factor</param>
public void Mul(NPPImage_16sC4 src2, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Mul.nppiMul_16s_C4IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMul_16s_C4IRSfs", 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_16sC4 src2, CudaDeviceVariable<double> pError)
{
int bufferSize = MaximumRelativeErrorGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_16s_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_16s_C4R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image square root, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="nScaleFactor">scaling factor</param>
public void SqrtA(NPPImage_16sC4 dest, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Sqrt.nppiSqrt_16s_AC4RSfs(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSqrt_16s_AC4RSfs", 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_16sC4 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_16s_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_16s_C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Swap color channels
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="aDstOrder">Integer array describing how channel values are permutated. <para/>The n-th entry of the array
/// contains the number of the channel that is stored in the n-th channel of the output image. <para/>E.g.
/// Given an RGB image, aDstOrder = [3,2,1,0] converts this to VBGR channel order.</param>
/// <param name="nValue">(V) Single channel constant value that can be replicated in one or more of the 4 destination channels.<para/>
/// nValue is either written or not written to a particular channel depending on the aDstOrder entry for that destination
/// channel. <para/>An aDstOrder value of 3 will output nValue to that channel, an aDstOrder value greater than 3 will leave that
/// particular destination channel value unmodified.</param>
public void SwapChannels(NPPImage_16sC4 dest, int[] aDstOrder, short nValue)
{
status = NPPNativeMethods.NPPi.SwapChannel.nppiSwapChannels_16s_C3C4R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, aDstOrder, nValue);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSwapChannels_16s_C3C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image bit shift by constant (right). Unchanged Alpha.
/// </summary>
/// <param name="nConstant">Constant (Array length = 4)</param>
/// <param name="dest">Destination image</param>
public void RShiftCA(uint[] nConstant, NPPImage_16sC4 dest)
{
status = NPPNativeMethods.NPPi.RightShiftConst.nppiRShiftC_16s_AC4R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRShiftC_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// convolution filter. Not affecting Alpha.
/// </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 FilterA(NPPImage_16sC4 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_8u16s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_8u16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <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 FilterColumnBorderA(NPPImage_16sC4 dest, CudaDeviceVariable<int> Kernel, int nAnchor, int nDivisor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.LinearFilter1D.nppiFilterColumnBorder_16s_AC4R(_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_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Four channel 8-bit unsigned to 16-bit signed convolution filter with border control, ignoring alpha channel.<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 FilterBorderA(NPPImage_16sC4 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_8u16s_AC4R(_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_8u16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image resize. Not affecting Alpha.
/// </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 ResizeSqrPixelA(NPPImage_16sC4 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_16s_AC4R(_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_16s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}