/// <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_8uC4 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_8u_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, ptrsV, ptrsL, size); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiLUT_Cubic_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// In place image subtraction, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha. /// </summary> /// <param name="src2">2nd source image</param> /// <param name="nScaleFactor">scaling factor</param> public void SubA(NPPImage_8uC4 src2, int nScaleFactor) { status = NPPNativeMethods.NPPi.Sub.nppiSub_8u_AC4IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSub_8u_AC4IRSfs", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// image conversion. /// </summary> /// <param name="dst">Destination-Image</param> /// <param name="hint">algorithm performance or accuracy selector, currently ignored</param> public void Scale(NPPImage_8uC4 dst, NppHintAlgorithm hint) { NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi); status = NPPNativeMethods.NPPi.Scale.nppiScale_32s8u_C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, hint); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiScale_32s8u_C4R", 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 FilterSharpenBorderA(NPPImage_8uC4 dst, NppiBorderType eBorderType) { status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterSharpenBorder_8u_AC4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, eBorderType); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterSharpenBorder_8u_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> public void FilterGauss(NPPImage_8uC4 dst, CudaDeviceVariable<float> Kernel) { status = NPPNativeMethods.NPPi.FixedFilters.nppiFilterGaussAdvanced_8u_C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, Kernel.Size, Kernel.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterGaussAdvanced_8u_C4R", 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_8uC4 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_8u_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_8u_C4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Image logical Not. /// </summary> /// <param name="dest">Destination image</param> public void Not(NPPImage_8uC4 dest) { status = NPPNativeMethods.NPPi.Not.nppiNot_8u_C4R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNot_8u_C4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// CrossCorrValid_NormLevel. Not affecting Alpha. /// </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="ValidNormLevelAGetBufferHostSize()"/></param> public void CrossCorrValid_NormLevelA(NPPImage_8uC4 tpl, NPPImage_32fC4 dst, CudaDeviceVariable<byte> buffer) { int bufferSize = ValidNormLevelAGetBufferHostSize(); if (bufferSize > buffer.Size) throw new NPPException("Provided buffer is too small."); status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_NormLevel_8u32f_AC4R(_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_8u32f_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// CrossCorrValid_NormLevel. Buffer is internally allocated and freed. Not affecting Alpha. /// </summary> /// <param name="tpl">template image.</param> /// <param name="dst">Destination image</param> /// <param name="nScaleFactor">Integer Result Scaling.</param> public void CrossCorrValid_NormLevelA(NPPImage_8uC4 tpl, NPPImage_8uC4 dst, int nScaleFactor) { int bufferSize = ValidNormLevelScaledAGetBufferHostSize(); CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize); status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_NormLevel_8u_AC4RSfs(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointer, dst.Pitch, nScaleFactor, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCrossCorrValid_NormLevel_8u_AC4RSfs", status)); buffer.Dispose(); 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_8uC4 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_8u_AC4R(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, _sizeRoi, pNormRel.DevicePointer, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L1_8u_AC4R", 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_8uC4 tpl, CudaDeviceVariable<double> pNormRel) { int bufferSize = NormRelL2AGetBufferHostSize(); CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize); status = NPPNativeMethods.NPPi.NormRel.nppiNormRel_L2_8u_AC4R(_devPtrRoi, _pitch, tpl.DevicePointerRoi, tpl.Pitch, _sizeRoi, pNormRel.DevicePointer, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNormRel_L2_8u_AC4R", status)); buffer.Dispose(); 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_8uC4 dst, float nDx, float nDy) { status = NPPNativeMethods.NPPi.CopySubpix.nppiCopySubpix_8u_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nDx, nDy); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopySubpix_8u_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_8uC4 dst, int nTopBorderHeight, int nLeftBorderWidth) { status = NPPNativeMethods.NPPi.CopyWrapBorder.nppiCopyWrapBorder_8u_AC4R(_devPtrRoi, _pitch, _sizeRoi, dst.DevicePointerRoi, dst.Pitch, dst.SizeRoi, nTopBorderHeight, nLeftBorderWidth); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopyWrapBorder_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// 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. Not affecting Alpha. /// </summary> /// <param name="dst">Destination-Image</param> /// <param name="pTable">Host pointer to an array of 3 device memory pointers, one per color CHANNEL, pointing to user defined OUTPUT palette values.</param> /// <param name="nBitSize">Number of least significant bits (must be > 0 and <= 8) of each source pixel value to use as index into palette table during conversion.</param> public void LUTPaletteA(NPPImage_8uC4 dst, CudaDeviceVariable<byte>[] pTable, int nBitSize) { CUdeviceptr[] ptrsT = new CUdeviceptr[] { pTable[0].DevicePointer, pTable[1].DevicePointer, pTable[2].DevicePointer }; status = NPPNativeMethods.NPPi.ColorLUTPalette.nppiLUTPalette_8u_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, ptrsT, nBitSize); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiLUTPalette_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// In place image logical Xor. Unchanged Alpha. /// </summary> /// <param name="src2">2nd source image</param> public void XorA(NPPImage_8uC4 src2) { status = NPPNativeMethods.NPPi.Xor.nppiXor_8u_AC4IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiXor_8u_AC4IR", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// image SqrDistanceValid_Norm. Not affecting Alpha. /// </summary> /// <param name="tpl">template image.</param> /// <param name="dst">Destination-Image</param> public void SqrDistanceValid_NormA(NPPImage_8uC4 tpl, NPPImage_32fC4 dst) { status = NPPNativeMethods.NPPi.ImageProximity.nppiSqrDistanceValid_Norm_8u32f_AC4R(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointerRoi, dst.Pitch); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSqrDistanceValid_Norm_8u32f_AC4R", 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_8uC4 src2, CudaDeviceVariable<double> pError) { int bufferSize = MaximumRelativeErrorGetBufferHostSize(); CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize); status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_8u_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_8u_C4R", status)); buffer.Dispose(); NPPException.CheckNppStatus(status, this); }
/// <summary> /// image CrossCorrValid_Norm. Not affecting Alpha. /// </summary> /// <param name="tpl">template image.</param> /// <param name="dst">Destination-Image</param> /// <param name="nScaleFactor">Integer Result Scaling.</param> public void CrossCorrValid_NormA(NPPImage_8uC4 tpl, NPPImage_8uC4 dst, int nScaleFactor) { status = NPPNativeMethods.NPPi.ImageProximity.nppiCrossCorrValid_Norm_8u_AC4RSfs(_devPtrRoi, _pitch, _sizeRoi, tpl.DevicePointerRoi, tpl.Pitch, tpl.SizeRoi, dst.DevicePointerRoi, dst.Pitch, nScaleFactor); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCrossCorrValid_Norm_8u_AC4RSfs", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// General purpose 1D convolution row filter with border control.<para/> /// 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. /// </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="eBorderType">The border type operation to be applied at source image border boundaries.</param> public void FilterRowBorder(NPPImage_8uC4 dest, CudaDeviceVariable<float> Kernel, int nAnchor, NppiBorderType eBorderType) { status = NPPNativeMethods.NPPi.LinearFilter1D.nppiFilterRowBorder32f_8u_C4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, Kernel.DevicePointer, Kernel.Size, nAnchor, eBorderType); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterRowBorder32f_8u_C4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Four channel 8-bit unsigned 3D trilinear interpolated look-up-table color conversion, not affecting alpha.<para/> /// Alpha channel is the last channel and is not processed.<para/> /// The LUT is derived from a set of user defined mapping points through trilinear interpolation. /// </summary> /// <param name="dst">Destination-Image</param> /// <param name="pValues">Device pointer to aLevels[2] number of contiguous 2D x,y planes of 4-byte packed RGBX values /// containing the user defined base OUTPUT values at that x,y, and z (R,G,B) level location. Each level must contain x * y 4-byte /// packed pixel values (4th byte is used for alignement only and is ignored) in row (x) order.</param> /// <param name="pLevels0">array, cube edge 0, with user defined INPUT level values.</param> /// <param name="pLevels1">array, cube edge 1, with user defined INPUT level values.</param> /// <param name="pLevels2">array, cube edge 2, with user defined INPUT level values.</param> /// <param name="aLevels">Host pointer to an array of 3 user defined number of input/output mapping points, one per 3D cube edge. /// aLevels[0] represents the number of x axis levels (Red), aLevels[1] represents the number of y axis levels (Green), /// and aLevels[2] represets the number of z axis levels (Blue).</param> public void LUTTrilinearA(NPPImage_8uC4 dst, CudaDeviceVariable<int> pValues, int[] pLevels0, int[] pLevels1, int[] pLevels2, int[] aLevels) { GCHandle h0 = new GCHandle(), h1 = new GCHandle(), h2 = new GCHandle(); try { h0 = GCHandle.Alloc(pLevels0, GCHandleType.Pinned); h1 = GCHandle.Alloc(pLevels1, GCHandleType.Pinned); h2 = GCHandle.Alloc(pLevels2, GCHandleType.Pinned); IntPtr[] ptrsLevels = new IntPtr[3]; ptrsLevels[0] = h0.AddrOfPinnedObject(); ptrsLevels[1] = h1.AddrOfPinnedObject(); ptrsLevels[2] = h2.AddrOfPinnedObject(); status = NPPNativeMethods.NPPi.ColorLUTTrilinear.nppiLUT_Trilinear_8u_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pValues.DevicePointer, ptrsLevels, aLevels); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiLUT_Trilinear_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); } catch (Exception) { throw; } finally { h0.Free(); h1.Free(); h2.Free(); } }
/// <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_8uC4 dest, NppiSize oMaskSize, NppiPoint oAnchor, NppiBorderType eBorderType) { status = NPPNativeMethods.NPPi.RankFilters.nppiFilterMaxBorder_8u_C4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, oMaskSize, oAnchor, eBorderType); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMaxBorder_8u_C4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Image logical Xor with constant. /// </summary> /// <param name="nConstant">Value (Array length = 4)</param> /// <param name="dest">Destination image</param> public void Xor(byte[] nConstant, NPPImage_8uC4 dest) { status = NPPNativeMethods.NPPi.XorConst.nppiXorC_8u_C4R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAdd_8u_C4RSfs", 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_8uC4 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_8u_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_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Four channel 8-bit unsigned convolution filter with border control, ignoring alpha channel.<para/> /// General purpose 2D convolution 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="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="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 FilterBorderA(NPPImage_8uC4 dest, CudaDeviceVariable<int> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, int nDivisor, NppiBorderType eBorderType) { status = NPPNativeMethods.NPPi.FilterBorder.nppiFilterBorder_8u_AC4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, pKernel.DevicePointer, nKernelSize, oAnchor, nDivisor, eBorderType); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterBorder_8u_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_8uC4 dst, CudaDeviceVariable<float> Kernel, NppiBorderType eBorderType) { status = NPPNativeMethods.NPPi.FilterGaussBorder.nppiFilterGaussAdvancedBorder_8u_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_8u_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_8uC4 dst, NppiSize oMaskSize, NppiPoint oAnchor) { int bufferSize = FilterMedianGetBufferHostSize(oMaskSize); CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize); status = NPPNativeMethods.NPPi.ImageMedianFilter.nppiFilterMedian_8u_C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, oMaskSize, oAnchor, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMedian_8u_C4R", status)); buffer.Dispose(); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Subtract constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha. /// </summary> /// <param name="nConstant">Value to subtract</param> /// <param name="dest">Destination image</param> /// <param name="nScaleFactor">scaling factor</param> public void SubA(byte[] nConstant, NPPImage_8uC4 dest, int nScaleFactor) { status = NPPNativeMethods.NPPi.SubConst.nppiSubC_8u_AC4RSfs(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSubC_8u_AC4RSfs", 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_8uC4 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_8u_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, oMaskSize, oAnchor, buffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterMedian_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// 32-bit signed to 8-bit unsigned conversion. Not affecting Alpha /// </summary> /// <param name="dst">Destination image</param> public void ConvertA(NPPImage_8uC4 dst) { status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_32s8u_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_32s8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Resizes images. Not affecting Alpha. /// </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 ResizeA(NPPImage_8uC4 dest, double xFactor, double yFactor, InterpolationMode eInterpolation) { status = NPPNativeMethods.NPPi.GeometricTransforms.nppiResize_8u_AC4R(_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_8u_AC4R", status)); NPPException.CheckNppStatus(status, this); }