/// <summary>
/// 32-bit unsigned to 8-bit signed conversion.
/// </summary>
/// <param name="dst">Destination image</param>
/// <param name="roundMode">Round mode</param>
/// <param name="scaleFactor">scaling factor</param>
public void Convert(NPPImage_8sC1 dst, NppRoundMode roundMode, int scaleFactor)
{
status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_32u8s_C1RSfs(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, roundMode, scaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_32u8s_C1RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormRel_Inf.
/// </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="pMask">Mask image.</param>
/// <param name="buffer">Allocated device memory with size of at <see cref="NormRelInfMaskedGetBufferHostSize()"/></param>
public void NormRel_Inf(NPPImage_8sC1 tpl, CudaDeviceVariable<double> pNormRel, NPPImage_8uC1 pMask, CudaDeviceVariable<byte> buffer)
{
int bufferSize = NormRelInfMaskedGetBufferHostSize();
if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small.");
status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_Inf_8s_C1MR(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, pMask.DevicePointerRoi, pMask.Pitch, _sizeRoi, pNormRel.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_Inf_8s_C1MR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image NormRel_L1. 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="pMask">Mask image.</param>
public void NormRel_L1(NPPImage_8sC1 tpl, CudaDeviceVariable<double> pNormRel, NPPImage_8uC1 pMask)
{
int bufferSize = NormRelL1MaskedGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_L1_8s_C1MR(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, pMask.DevicePointerRoi, pMask.Pitch, _sizeRoi, pNormRel.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L1_8s_C1MR", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image composition using constant alpha.
/// </summary>
/// <param name="alpha1">constant alpha for this image</param>
/// <param name="src2">2nd source image</param>
/// <param name="alpha2">constant alpha for src2</param>
/// <param name="dest">Destination image</param>
/// <param name="nppAlphaOp">alpha compositing operation</param>
public void AlphaComp(sbyte alpha1, NPPImage_8sC1 src2, sbyte alpha2, NPPImage_8sC1 dest, NppiAlphaOp nppAlphaOp)
{
status = NPPNativeMethods.NPPi.AlphaCompConst.nppiAlphaCompC_8s_C1R(_devPtrRoi, _pitch, alpha1, src2.DevicePointerRoi, src2.Pitch, alpha2, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nppAlphaOp);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAlphaCompC_8s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// One-channel 8-bit signed image DotProd. Buffer is internally allocated and freed.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="pDp">Pointer to the computed dot product of the two images. (1 * sizeof(double))</param>
public void DotProduct(NPPImage_8sC1 src2, CudaDeviceVariable<double> pDp)
{
int bufferSize = DotProdGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.DotProd.nppiDotProd_8s64f_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pDp.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDotProd_8s64f_C1R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image copy.
/// </summary>
/// <param name="dst">Destination image</param>
public void Copy(NPPImage_8sC1 dst)
{
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_8s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_8s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image bit shift by constant (right).
/// </summary>
/// <param name="nConstant">Constant</param>
/// <param name="dest">Destination image</param>
public void RShiftC(uint nConstant, NPPImage_8sC1 dest)
{
status = NPPNativeMethods.NPPi.RightShiftConst.nppiRShiftC_8s_C1R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRShiftC_8s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// One channel 8-bit signed 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_8sC1 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_8s_C1R(_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_8s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// An input color twist matrix with floating-point pixel values is applied
/// within ROI.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="twistMatrix">The color twist matrix with floating-point pixel values [3,4].</param>
public void ColorTwist(NPPImage_8sC1 dest, float[,] twistMatrix)
{
status = NPPNativeMethods.NPPi.ColorProcessing.nppiColorTwist32f_8s_C1R(_devPtr, _pitch, dest.DevicePointer, dest.Pitch, _sizeRoi, twistMatrix);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiColorTwist32f_8s_C1R", 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_8sC1 src2, CudaDeviceVariable<double> pError)
{
int bufferSize = MaximumRelativeErrorGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_8s_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_8s_C1R", status));
buffer.Dispose();
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_8sC1 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_8s_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_8s_C1R", 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_8sC1 tpl, NPPImage_32fC1 dst)
{
int bufferSize = ValidNormLevelGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_NormLevel_8s32f_C1R(_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_8s32f_C1R", status));
buffer.Dispose();
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_8sC1 tpl, NPPImage_32fC1 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_8s32f_C1R(_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_8s32f_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image CrossCorrValid.
/// </summary>
/// <param name="tpl">template image.</param>
/// <param name="dst">Destination-Image</param>
public void CrossCorrValid(NPPImage_8sC1 tpl, NPPImage_32fC1 dst)
{
status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_8s32f_C1R(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointerRoi, dst.Pitch);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCrossCorrValid_8s32f_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <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_8sC1 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_8s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_8s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 3 channel planar 8-bit signed inplace color twist.
/// An input color twist matrix with floating-point pixel values is applied
/// within ROI.
/// </summary>
/// <param name="srcDest0">Source / Destination image (Channel 0)</param>
/// <param name="srcDest1">Source / Destinationimage (Channel 1)</param>
/// <param name="srcDest2">Source / Destinationimage (Channel 2)</param>
/// <param name="twistMatrix">The color twist matrix with floating-point pixel values [3,4].</param>
public static void ColorTwist(NPPImage_8sC1 srcDest0, NPPImage_8sC1 srcDest1, NPPImage_8sC1 srcDest2, float[,] twistMatrix)
{
CUdeviceptr[] src = new CUdeviceptr[] { srcDest0.DevicePointerRoi, srcDest1.DevicePointerRoi, srcDest2.DevicePointerRoi };
NppStatus status = NPPNativeMethods.NPPi.ColorTwist.nppiColorTwist32f_8s_IP3R(src, srcDest0.Pitch, srcDest0.SizeRoi, twistMatrix);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiColorTwist32f_8s_IP3R", status));
NPPException.CheckNppStatus(status, null);
}
