C# NppiBorderType类代码示例

 public static extern NppStatus nppiDilate3x3Border_16u_C1R(
     IntPtr pSrc,
     Npp32s nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     Npp32s nDstStep,
     NppiSize oSizeROI,
     NppiBorderType eBorderType);

		/// <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>
		/// <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>
		/// Erosion computes the output pixel as the minimum pixel value of the pixels under the mask. Pixels who’s
		/// corresponding mask values are zero to not participate in the maximum search. With border control, ignoring alpha-channel.
		/// </summary>
		/// <param name="dest">Destination image</param>
		/// <param name="Mask">Pointer to the start address of the mask array.</param>
		/// <param name="aMaskSize">Width and Height mask array.</param>
		/// <param name="oAnchor">X and Y offsets of the mask 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 ErodeBorderA(NPPImage_8uC4 dest, CudaDeviceVariable<byte> Mask, NppiSize aMaskSize, NppiPoint oAnchor, NppiBorderType eBorderType)
		{
			status = NPPNativeMethods.NPPi.ErosionWithBorderControl.nppiErodeBorder_8u_AC4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, Mask.DevicePointer, aMaskSize, oAnchor, eBorderType);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiErodeBorder_8u_AC4R", status));
			NPPException.CheckNppStatus(status, this);
		}

		/// <summary>
		/// Apply Row Window Summation filter over a 1D mask region around each source
		/// pixel for 3-channel 8-bit pixel input images with 32-bit floating point output.  
		/// Result 32-bit floating point pixel is equal to the sum of the corresponding and
		/// neighboring row pixel values in a mask region of the source image defined
		/// by nKernelDim and nAnchorX. 
		/// </summary>
		/// <param name="dest">Destination image</param>
		/// <param name="nMaskSize">Length of the linear kernel array.</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 SumWindowRowBorder(NPPImage_32fC4 dest, int nMaskSize, int nAnchor, NppiBorderType eBorderType)
		{
			status = NPPNativeMethods.NPPi.WindowSum1D.nppiSumWindowRowBorder_8u32f_C4R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nMaskSize, nAnchor, eBorderType);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSumWindowRowBorder_8u32f_C4R", status));
			NPPException.CheckNppStatus(status, this);
		}

 public static extern NppStatus nppiFilterMinBorder_8u_C4R(
     IntPtr pSrc,
     Npp32s nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     Npp32s nDstStep,
     NppiSize oSizeROI,
     NppiSize oMaskSize,
     NppiPoint oAnchor,
     NppiBorderType eBorderType);

		/// <summary>
		/// 3x3 erosion with border control.
		/// </summary>
		/// <param name="dest">Destination image</param>
		/// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
		public void Erode3x3Border(NPPImage_16uC3 dest, NppiBorderType eBorderType)
		{
			status = NPPNativeMethods.NPPi.Erode3x3Border.nppiErode3x3Border_16u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, eBorderType);
			Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiErode3x3Border_16u_C3R", status));
			NPPException.CheckNppStatus(status, this);
		}

 public static extern NppStatus nppiFilterScharrHorizBorder_8u16s_C1R(
     IntPtr pSrc,
     Npp32s nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     Npp32s nDstStep,
     NppiSize oSizeROI,
     NppiBorderType eBorderType);

 public static extern NppStatus nppiFilterSharpenBorder_32f_C4R(
     IntPtr pSrc,
     Npp32s nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     Npp32s nDstStep,
     NppiSize oSizeROI,
     NppiBorderType eBorderType);

 /// <summary>
 /// 3 channel 8-bit unsigned packed RGB to optional 1 channel 16-bit signed X (vertical), Y (horizontal), magnitude, 
 /// and/or 32-bit floating point angle gradient vectors with user selectable fixed mask size and distance method with border control.
 /// </summary>
 /// <param name="destX">X vector destination_image_pointer</param>
 /// <param name="destY">Y vector destination_image_pointer.</param>
 /// <param name="destMag">magnitude destination_image_pointer.</param>
 /// <param name="destAngle">angle destination_image_pointer.</param>
 /// <param name="eMaskSize">fixed filter mask size to use.</param>
 /// <param name="eNorm">gradient distance method to use.</param>
 /// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
 public void GradientVectorSobelBorder(NPPImage_16sC1 destX, NPPImage_16sC1 destY, NPPImage_16sC1 destMag, NPPImage_32fC1 destAngle, MaskSize eMaskSize, NppiNorm eNorm, NppiBorderType eBorderType)
 {
     status = NPPNativeMethods.NPPi.GradientVectorSobelBorder.nppiGradientVectorSobelBorder_8u16s_C3C1R(_devPtr, _pitch, _sizeOriginal, _pointRoi, destX.DevicePointerRoi, destX.Pitch, destY.DevicePointerRoi, destY.Pitch, destMag.DevicePointerRoi, destMag.Pitch, destAngle.DevicePointerRoi, destAngle.Pitch, _sizeRoi, eMaskSize, eNorm, eBorderType);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiGradientVectorSobelBorder_8u16s_C3C1R", status));
     NPPException.CheckNppStatus(status, this);
 }

 public static extern NppStatus nppiFilterRobertsUpBorder_16s_C4R(
     IntPtr pSrc,
     Npp32s nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     Npp32s nDstStep,
     NppiSize oSizeROI,
     NppiBorderType eBorderType);

 /// <summary>
 /// Three channel 8-bit unsigned Gauss filter with downsampling and border control.
 /// </summary>
 /// <param name="dest">Destination image</param>
 /// <param name="nRate">The downsampling rate to be used.  For integer equivalent rates unnecessary source pixels are just skipped. For non-integer rates the source image is bilinear interpolated. nRate must be > 1.0F and &lt;=  10.0F. </param>
 /// <param name="nFilterTaps">The number of filter taps where nFilterTaps =  2 * ((int)((float)ceil(radius) + 0.5F) ) + 1.</param>
 /// <param name="pKernel">Pointer to an array of nFilterTaps kernel coefficients which sum to 1.0F. </param>
 /// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
 public void FilterGaussPyramidLayerUpBorder(NPPImage_8uC3 dest, float nRate, int nFilterTaps, CudaDeviceVariable<float> pKernel, NppiBorderType eBorderType)
 {
     status = NPPNativeMethods.NPPi.FilterGaussPyramid.nppiFilterGaussPyramidLayerUpBorder_8u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, nRate, nFilterTaps, pKernel.DevicePointer, eBorderType);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterGaussPyramidLayerUpBorder_8u_C3R", status));
     NPPException.CheckNppStatus(status, this);
 }

 /// <summary>
 /// Three channel 8-bit unsigned bilateral Gauss filter with border control.
 /// </summary>
 /// <param name="dest">Destination image</param>
 /// <param name="nRadius">The radius of the round filter kernel to be used.  A radius of 1 indicates a filter kernel size of 3 by 3, 2 indicates 5 by 5, etc. Radius values from 1 to 32 are supported.</param>
 /// <param name="nStepBetweenSrcPixels">The step size between adjacent source image pixels processed by the filter kernel, most commonly 1. </param>
 /// <param name="nValSquareSigma">The square of the sigma for the relative intensity distance between a source image pixel in the filter kernel and the source image pixel at the center of the filter kernel.</param>
 /// <param name="nPosSquareSigma">The square of the sigma for the relative geometric distance between a source image pixel in the filter kernel and the source image pixel at the center of the filter kernel.</param>
 /// <param name="eBorderType">The border type operation to be applied at source image border boundaries.</param>
 public void FilterBilateralGaussBorder(NPPImage_8uC3 dest, int nRadius, int nStepBetweenSrcPixels, float nValSquareSigma, float nPosSquareSigma, NppiBorderType eBorderType)
 {
     status = NPPNativeMethods.NPPi.FilterBilateralGaussBorder.nppiFilterBilateralGaussBorder_8u_C3R(_devPtr, _pitch, _sizeOriginal, _pointRoi, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nRadius, nStepBetweenSrcPixels, nValSquareSigma, nPosSquareSigma, eBorderType);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilterBilateralGaussBorder_8u_C3R", status));
     NPPException.CheckNppStatus(status, this);
 }

 public static extern NppStatus nppiDilateBorder_8u_C4R(
     IntPtr pSrc,
     int nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     int nDstStep,
     NppiSize oSizeROI,
     IntPtr pMask,
     NppiSize oMaskSize,
     NppiPoint oAnchor,
     NppiBorderType eBorderType);

 public static extern NppStatus nppiFilterGaussAdvancedBorder_8u_C4R(
     IntPtr pSrc,
     Npp32s nSrcStep,
     NppiSize oSrcSize,
     NppiPoint oSrcOffset,
     IntPtr pDst,
     Npp32s nDstStep,
     NppiSize oSizeROI,
     int nFilterTaps,
     IntPtr pKernel,
     NppiBorderType eBorderType);