/// <summary>
 /// 16-bit floating point to 32-bit conversion.
 /// </summary>
 /// <param name="dst">Destination image</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void Convert(NPPImage_32fC3 dst, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.BitDepthConversion.nppiConvert_16f32f_C3R_Ctx(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_16f32f_C3R_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #2
0
 /// <summary>
 /// 4 channel 16-bit floating point in place color twist with 4x4 matrix and an additional constant vector addition.
 /// An input 4x4 color twist matrix with floating-point coefficient values with an additional constant vector addition
 /// is applied within ROI.  For this particular version of the function the result is generated as shown below.
 ///  \code
 ///      dst[0] = aTwist[0][0]		/// src[0] + aTwist[0][1]		/// src[1] + aTwist[0][2]		/// src[2] + aTwist[0][3]		/// src[3] + aConstants[0]
 ///      dst[1] = aTwist[1][0]		/// src[0] + aTwist[1][1]		/// src[1] + aTwist[1][2]		/// src[2] + aTwist[1][3]		/// src[3] + aConstants[1]
 ///      dst[2] = aTwist[2][0]		/// src[0] + aTwist[2][1]		/// src[1] + aTwist[2][2]		/// src[2] + aTwist[2][3]		/// src[3] + aConstants[2]
 ///      dst[3] = aTwist[3][0]		/// src[0] + aTwist[3][1]		/// src[1] + aTwist[3][2]		/// src[2] + aTwist[3][3]		/// src[3] + aConstants[3]
 ///  \endcode
 /// </summary>
 /// <param name="twistMatrix">The color twist matrix with floating-point coefficient values [4,4].</param>
 /// <param name="aConstants">fixed size array of constant values, one per channel [4]</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void ColorTwistC(float[,] twistMatrix, float[] aConstants, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.ColorTwist.nppiColorTwist32fC_16f_C4IR_Ctx(_devPtr, _pitch, _sizeRoi, twistMatrix, aConstants, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiColorTwist32fC_16f_C4IR_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #3
0
 /// <summary>
 /// Divide constant to image. Inplace.
 /// </summary>
 /// <param name="nConstant">Value</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void Div(float[] nConstant, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.DivConst.nppiDivC_16f_C4IR_Ctx(nConstant, _devPtrRoi, _pitch, _sizeRoi, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_16f_C4IR_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
 /// <summary>
 /// In place image multiplication, 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>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void MulA(NPPImage_16scC4 src2, int nScaleFactor, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.Mul.nppiMul_16sc_AC4IRSfs_Ctx(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMul_16sc_AC4IRSfs_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
 /// <summary>
 /// Divide constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha.
 /// </summary>
 /// <param name="nConstant">Value</param>
 /// <param name="dest">Destination image</param>
 /// <param name="nScaleFactor">scaling factor</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void DivA(Npp16sc[] nConstant, NPPImage_16scC4 dest, int nScaleFactor, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.DivConst.nppiDivC_16sc_AC4RSfs_Ctx(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_16sc_AC4RSfs_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #6
0
 /// <summary>
 /// Image multiplication.
 /// </summary>
 /// <param name="src2">2nd source image</param>
 /// <param name="dest">Destination image</param>
 public void Mul(NPPImage_32fcC3 src2, NPPImage_32fcC3 dest)
 {
     status = NPPNativeMethods.NPPi.Mul.nppiMul_32fc_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMul_32fc_C3R", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #7
0
 /// <summary>
 /// Divide constant to image.
 /// </summary>
 /// <param name="nConstant">Value</param>
 /// <param name="dest">Destination image</param>
 public void Div(Npp32fc[] nConstant, NPPImage_32fcC3 dest)
 {
     status = NPPNativeMethods.NPPi.DivConst.nppiDivC_32fc_C3R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_32fc_C3R", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #8
0
 /// <summary>
 /// 1 channel 32-bit unsigned integer in place region boundary border image generation.
 /// </summary>
 /// <param name="nBorderVal">Pixel value to be used at connected region boundary borders</param>
 public void BoundSegments(uint nBorderVal)
 {
     status = NPPNativeMethods.NPPi.LabelMarkers.nppiBoundSegments_32u_C1IR(_devPtrRoi, _pitch, _sizeRoi, nBorderVal);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiBoundSegments_32u_C1IR", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #9
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="error"></param>
 public NPPWarning(NppStatus error)
     : base(NPPException.GetErrorMessageFromNppStatus(error))
 {
     this._nppError = error;
 }
Example #10
0
 /// <summary>
 /// 32-bit unsigned to 32-bit float conversion.
 /// </summary>
 /// <param name="dst">Destination image</param>
 public void Convert(NPPImage_32fC1 dst)
 {
     status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_32u32f_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_32u32f_C1R", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #11
0
 /// <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(uint alpha1, NPPImage_32uC1 src2, ushort alpha2, NPPImage_32uC1 dest, NppiAlphaOp nppAlphaOp)
 {
     status = NPPNativeMethods.NPPi.AlphaCompConst.nppiAlphaCompC_32u_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_32u_C1R", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #12
0
 /// <summary>
 /// 32-bit unsigned to 32-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_32sC1 dst, NppRoundMode roundMode, int scaleFactor)
 {
     status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_32u32s_C1RSfs(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, roundMode, scaleFactor);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_32u32s_C1RSfs", status));
     NPPException.CheckNppStatus(status, this);
 }
 /// <summary>
 /// Resizes images.
 /// </summary>
 /// <param name="dest">Destination image</param>
 /// <param name="eInterpolation">Interpolation mode</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void Resize(NPPImage_16fC3 dest, InterpolationMode eInterpolation, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.GeometricTransforms.nppiResize_16f_C3R_Ctx(_devPtr, _pitch, _sizeOriginal, new NppiRect(_pointRoi, _sizeRoi), dest.DevicePointer, dest.Pitch, dest.Size, new NppiRect(dest.PointRoi, dest.SizeRoi), eInterpolation, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiResize_16f_C3R_Ctx", 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>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void Filter(NPPImage_16fC3 dst, CudaDeviceVariable <float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.Convolution.nppiFilter32f_16f_C3R_Ctx(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_16f_C3R_Ctx", 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>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void ColorTwist(NPPImage_16fC2 dest, float[,] twistMatrix, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.ColorTwist.nppiColorTwist32f_16f_C2R_Ctx(_devPtr, _pitch, dest.DevicePointer, dest.Pitch, _sizeRoi, twistMatrix, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiColorTwist32f_16f_C2R_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #16
0
 /// <summary>
 /// image copy. Not affecting Alpha channel.
 /// </summary>
 /// <param name="dst">Destination image</param>
 public void CopyA(NPPImage_32scC4 dst)
 {
     status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32sc_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32sc_AC4R", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #17
0
 /// <summary>
 /// Set pixel values to nValue.
 /// </summary>
 /// <param name="nValue">Value to be set</param>
 public void Set(Npp32fc[] nValue)
 {
     status = NPPNativeMethods.NPPi.MemSet.nppiSet_32fc_C3R(nValue, _devPtrRoi, _pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSet_32fc_C3R", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #18
0
 /// <summary>
 /// Image subtraction, scale by 2^(-nScaleFactor), then clamp to saturated value.
 /// </summary>
 /// <param name="src2">2nd source image</param>
 /// <param name="dest">Destination image</param>
 /// <param name="nScaleFactor">scaling factor</param>
 public void Sub(NPPImage_32scC4 src2, NPPImage_32scC4 dest, int nScaleFactor)
 {
     status = NPPNativeMethods.NPPi.Sub.nppiSub_32sc_C4RSfs(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSub_32sc_C4RSfs", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #19
0
 /// <summary>
 /// In place image division.
 /// </summary>
 /// <param name="src2">2nd source image</param>
 public void Div(NPPImage_32fcC3 src2)
 {
     status = NPPNativeMethods.NPPi.Div.nppiDiv_32fc_C3IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_32fc_C3IR", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #20
0
 /// <summary>
 /// Multiply constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha.
 /// </summary>
 /// <param name="nConstant">Value</param>
 /// <param name="dest">Destination image</param>
 /// <param name="nScaleFactor">scaling factor</param>
 public void MulA(Npp32sc[] nConstant, NPPImage_32scC4 dest, int nScaleFactor)
 {
     status = NPPNativeMethods.NPPi.MulConst.nppiMulC_32sc_AC4RSfs(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMulC_32sc_AC4RSfs", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #21
0
 /// <summary>
 /// Divide constant to image. Inplace.
 /// </summary>
 /// <param name="nConstant">Value</param>
 public void Div(Npp32fc[] nConstant)
 {
     status = NPPNativeMethods.NPPi.DivConst.nppiDivC_32fc_C3IR(nConstant, _devPtrRoi, _pitch, _sizeRoi);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_32fc_C3IR", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #22
0
 /// <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="nScaleFactor">scaling factor</param>
 public void DivA(NPPImage_32scC4 src2, int nScaleFactor)
 {
     status = NPPNativeMethods.NPPi.Div.nppiDiv_32sc_AC4IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_32sc_AC4IRSfs", status));
     NPPException.CheckNppStatus(status, this);
 }
 /// <summary>
 /// Multiply constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Inplace. Unchanged Alpha.
 /// </summary>
 /// <param name="nConstant">Value</param>
 /// <param name="nScaleFactor">scaling factor</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void MulA(Npp16sc[] nConstant, int nScaleFactor, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.MulConst.nppiMulC_16sc_AC4IRSfs_Ctx(nConstant, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMulC_16sc_AC4IRSfs_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #24
0
 /// <summary>
 /// Divide constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value. Inplace. Unchanged Alpha.
 /// </summary>
 /// <param name="nConstant">Value</param>
 /// <param name="nScaleFactor">scaling factor</param>
 public void DivA(Npp32sc[] nConstant, int nScaleFactor)
 {
     status = NPPNativeMethods.NPPi.DivConst.nppiDivC_32sc_AC4IRSfs(nConstant, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_32sc_AC4IRSfs", status));
     NPPException.CheckNppStatus(status, this);
 }
 /// <summary>
 /// Set pixel values to nValue. <para/>
 /// The 8-bit mask image affects setting of the respective pixels in the destination image. <para/>
 /// If the mask value is zero (0) the pixel is not set, if the mask is non-zero, the corresponding
 /// destination pixel is set to specified value. Not affecting alpha channel.
 /// </summary>
 /// <param name="nValue">Value to be set (Array size = 3)</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void SetA(Npp16sc[] nValue, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.MemSet.nppiSet_16sc_AC4R_Ctx(nValue, _devPtrRoi, _pitch, _sizeRoi, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSet_16sc_AC4R_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #26
0
 /// <summary>
 /// in place color twist.
 ///
 /// An input color twist matrix with floating-point coefficient values is applied
 /// within ROI.
 /// </summary>
 /// <param name="aTwist">The color twist matrix with floating-point coefficient values. [3,4]</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void ColorTwist(float[,] aTwist, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.ColorProcessing.nppiColorTwist32f_16s_C2IR_Ctx(_devPtr, _pitch, _sizeRoi, aTwist, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiColorTwist32f_16s_C2IR_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #27
0
 /// <summary>
 /// In place image division.
 /// </summary>
 /// <param name="src2">2nd source image</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void Div(NPPImage_16fC4 src2, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.Div.nppiDiv_16f_C4IR_Ctx(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_16f_C4IR_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #28
0
 /// <summary>
 /// Image composition using image alpha values (0 - max channel pixel value).<para/>
 /// Also the function is called *AC1R, it is a two channel image with second channel as alpha.
 /// </summary>
 /// <param name="src2">2nd source image</param>
 /// <param name="dest">Destination image</param>
 /// <param name="nppAlphaOp">alpha compositing operation</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void AlphaComp(NPPImage_16sC2 src2, NPPImage_16sC2 dest, NppiAlphaOp nppAlphaOp, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.AlphaComp.nppiAlphaComp_16s_AC1R_Ctx(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nppAlphaOp, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAlphaComp_16s_AC1R_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
Example #29
0
 /// <summary>
 /// Image squared.
 /// </summary>
 /// <param name="dest">Destination image</param>
 /// <param name="nppStreamCtx">NPP stream context.</param>
 public void Sqr(NPPImage_16fC4 dest, NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.Sqr.nppiSqr_16f_C4R_Ctx(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSqr_16f_C4R_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }
 /// <summary>
 /// Inplace image square root.
 /// </summary>
 public void Sqrt(NppStreamContext nppStreamCtx)
 {
     status = NPPNativeMethods_Ctx.NPPi.Sqrt.nppiSqrt_16f_C3IR_Ctx(_devPtrRoi, _pitch, _sizeRoi, nppStreamCtx);
     Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSqrt_16f_C3IR_Ctx", status));
     NPPException.CheckNppStatus(status, this);
 }