/// <summary>
/// 4 channel 8-bit unsigned packed BGR with alpha to 2 channel 8-bit unsigned packed CbYCr422_709HDTV color conversion.
/// </summary>
/// <param name="dest">Destination image</param>
public void BGRToCbYCr422_709HDTV(NPPImage_8uC2 dest)
{
status = NPPNativeMethods.NPPi.BGRToCbYCr.nppiBGRToCbYCr422_709HDTV_8u_AC4C2R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiBGRToCbYCr422_709HDTV_8u_AC4C2R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 3 channel 8-bit unsigned packed RGB to 2 channel 8-bit unsigned packed YUV422 color conversion.
/// </summary>
/// <param name="dest">Destination image</param>
public void RGBToYUV422(NPPImage_8uC2 dest)
{
NppStatus status = NPPNativeMethods.NPPi.RGBToYUV422.nppiRGBToYUV422_8u_C3C2R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRGBToYUV422_8u_C3C2R", status));
NPPException.CheckNppStatus(status, null);
}
/// <summary>
/// 3 channel 8-bit unsigned planar YCbCr411 to 2 channel 8-bit unsigned packed YCbCr422 sampling format conversion.
/// </summary>
/// <param name="src0">Source image channel 0</param>
/// <param name="src1">Source image channel 1</param>
/// <param name="src2">Source image channel 2</param>
/// <param name="dest">Destination image</param>
public static void YCbCr411ToYCbCr422(NPPImage_8uC1 src0, NPPImage_8uC1 src1, NPPImage_8uC1 src2, NPPImage_8uC2 dest)
{
CUdeviceptr[] arraySrc = new CUdeviceptr[] { src0.DevicePointerRoi, src1.DevicePointerRoi, src2.DevicePointerRoi };
int[] arrayPitch = new int[] { src0.Pitch, src1.Pitch, src2.Pitch };
NppStatus status = NPPNativeMethods.NPPi.YCbCrAndACrCbAndOther.nppiYCbCr411ToYCbCr422_8u_P3C2R(arraySrc, arrayPitch, dest.DevicePointerRoi, dest.Pitch, src0.SizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiYCbCr411ToYCbCr422_8u_P3C2R", status));
NPPException.CheckNppStatus(status, null);
}
/// <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_8uC2 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_C2R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_8u_C2R", 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_8uC2 dest, float[,] twistMatrix)
{
status = NPPNativeMethods.NPPi.ColorProcessing.nppiColorTwist32f_8u_C2R(_devPtr, _pitch, dest.DevicePointer, dest.Pitch, _sizeRoi, twistMatrix);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiColorTwist32f_8u_C2R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 2 channel 8-bit unsigned planar NV21 to 4 channel 8-bit unsigned packed BGRA color conversion with constant alpha (0xFF).
/// </summary>
/// <param name="srcY">Source image channel Y</param>
/// <param name="srcVU">Source image channel VU</param>
/// <param name="dest">Destination image</param>
public static void NV21ToBGR(NPPImage_8uC1 srcY, NPPImage_8uC1 srcVU, NPPImage_8uC2 dest)
{
CUdeviceptr[] devptrs = new CUdeviceptr[] { srcY.DevicePointer, srcVU.DevicePointer };
NppStatus status = NPPNativeMethods.NPPi.NV21ToBGR.nppiNV21ToBGR_8u_P2C4R(devptrs, srcY.Pitch, dest.DevicePointerRoi, dest.Pitch, srcY.SizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiNV21ToBGR_8u_P2C4R", status));
NPPException.CheckNppStatus(status, null);
}
/// <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_8uC2 src2, CudaDeviceVariable<double> pError)
{
int bufferSize = MaximumRelativeErrorGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_8u_C2R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_8u_C2R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 2 channel 8-bit unsigned packed YCbCr422 to 2 channel 8-bit unsigned packed CbYCr422 sampling format conversion.
/// images.
/// </summary>
/// <param name="dest">Destination image</param>
public void YCbCr422ToCbYCr422(NPPImage_8uC2 dest)
{
status = NPPNativeMethods.NPPi.YCbCrAndACrCbAndOther.nppiYCbCr422ToCbYCr422_8u_C2R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiYCbCr422ToCbYCr422_8u_C2R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 2 channel 8-bit unsigned planar YCbCr411 to 2 channel 8-bit unsigned packed YCbCr422 sampling format conversion.
/// </summary>
/// <param name="srcY">Source image channel Y</param>
/// <param name="srcCbCr">Source image channel CbCr</param>
/// <param name="dest">Destination image</param>
public static void YCbCr411ToYCbCr422(NPPImage_8uC1 srcY, NPPImage_8uC1 srcCbCr, NPPImage_8uC2 dest)
{
NppStatus status = NPPNativeMethods.NPPi.YCbCrAndACrCbAndOther.nppiYCbCr411ToYCbCr422_8u_P2C2R(srcY.DevicePointerRoi, srcY.Pitch, srcCbCr.DevicePointerRoi, srcCbCr.Pitch, dest.DevicePointerRoi, dest.Pitch, srcY.SizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiYCbCr411ToYCbCr422_8u_P2C2R", status));
NPPException.CheckNppStatus(status, null);
}
/// <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>
public void AlphaComp(NPPImage_8uC2 src2, NPPImage_8uC2 dest, NppiAlphaOp nppAlphaOp)
{
status = NPPNativeMethods.NPPi.AlphaComp.nppiAlphaComp_8u_AC1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nppAlphaOp);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAlphaComp_8u_AC1R", 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_8uC2 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_8u_C2R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_8u_C2R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Two channel 8-bit unsigned 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_8uC2 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_8u_C2R(_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_8u_C2R", status));
NPPException.CheckNppStatus(status, this);
}