/// <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); }