/// <summary>
/// Affine transform of an image. <para/>This
/// function performs affine warping of a the specified quadrangle in the
/// source image to the specified quadrangle in the destination image. The
/// function nppiWarpAffineQuad uses the same formulas for pixel mapping as in
/// nppiWarpAffine function. The transform coefficients are computed internally.
/// The transformed part of the source image is resampled using the specified
/// eInterpolation method and written to the destination ROI.<para/>
/// NPPI specific recommendation: <para/>
/// The function operates using 2 types of kernels: fast and accurate. The fast
/// method is about 4 times faster than its accurate variant,
/// but doesn't perform memory access checks and requires the destination ROI
/// to be 64 bytes aligned. Hence any destination ROI is
/// chunked into 3 vertical stripes: the first and the third are processed by
/// accurate kernels and the central one is processed by the fast one.
/// In order to get the maximum available speed of execution, the projection of
/// destination ROI onto image addresses must be 64 bytes aligned. This is
/// always true if the values <para/>
/// <code>(int)((void *)(pDst + dstRoi.x))</code> and <para/>
/// <code>(int)((void *)(pDst + dstRoi.x + dstRoi.width))</code> <para/>
/// are multiples of 64. Another rule of thumb is to specify destination ROI in
/// such way that left and right sides of the projected image are separated from
/// the ROI by at least 63 bytes from each side. However, this requires the
/// whole ROI to be part of allocated memory. In case when the conditions above
/// are not satisfied, the function may decrease in speed slightly and will
/// return NPP_MISALIGNED_DST_ROI_WARNING warning.
/// </summary>
/// <param name="srcQuad">Source quadrangle [4,2]</param>
/// <param name="dest">Destination image</param>
/// <param name="dstQuad">Destination quadrangle [4,2]</param>
/// <param name="eInterpolation">Interpolation mode: can be <see cref="InterpolationMode.NearestNeighbor"/>, <see cref="InterpolationMode.Linear"/> or <see cref="InterpolationMode.Cubic"/></param>
public void WarpAffineQuad(double[,] srcQuad, NPPImage_32sC3 dest, double[,] dstQuad, InterpolationMode eInterpolation)
{
NppiRect rectIn = new NppiRect(_pointRoi, _sizeRoi);
NppiRect rectOut = new NppiRect(dest.PointRoi, dest.SizeRoi);
status = NPPNativeMethods.NPPi.AffinTransforms.nppiWarpAffineQuad_32s_C3R(_devPtr, _sizeOriginal, _pitch, rectIn, srcQuad, dest.DevicePointer, dest.Pitch, rectOut, dstQuad, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiWarpAffineQuad_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Divide constant to image, scale by 2^(-nScaleFactor), then clamp to saturated value.
/// </summary>
/// <param name="nConstant">Value</param>
/// <param name="dest">Destination image</param>
/// <param name="nScaleFactor">scaling factor</param>
public void Div(int[] nConstant, NPPImage_32sC3 dest, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.DivConst.nppiDivC_32s_C3RSfs(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_32s_C3RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Mirror image.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="flip">Specifies the axis about which the image is to be mirrored.</param>
public void Mirror(NPPImage_32sC3 dest, NppiAxis flip)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiMirror_32s_C3R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, flip);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMirror_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image logical Xor with constant.
/// </summary>
/// <param name="nConstant">Value (Array length = 3)</param>
/// <param name="dest">Destination image</param>
public void Xor(int[] nConstant, NPPImage_32sC3 dest)
{
status = NPPNativeMethods.NPPi.XorConst.nppiXorC_32s_C3R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAdd_32s_C3RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image division, scale by 2^(-nScaleFactor), then clamp to saturated value.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="nScaleFactor">scaling factor</param>
public void Div(NPPImage_32sC3 src2, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Div.nppiDiv_32s_C3IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_32s_C3IRSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Three-channel 32-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. (3 * sizeof(double))</param>
public void DotProduct(NPPImage_32sC3 src2, CudaDeviceVariable<double> pDp)
{
int bufferSize = DotProdGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.DotProd.nppiDotProd_32s64f_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pDp.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDotProd_32s64f_C3R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image logical Xor.
/// </summary>
/// <param name="src2">2nd source image</param>
public void Xor(NPPImage_32sC3 src2)
{
status = NPPNativeMethods.NPPi.Xor.nppiXor_32s_C3IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiXor_32s_C3IR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image copy.
/// </summary>
/// <param name="dst">Destination image</param>
/// <param name="channelSrc">Channel number. This number is added to the src pointer</param>
/// <param name="channelDst">Channel number. This number is added to the dst pointer</param>
public void Copy(NPPImage_32sC3 dst, int channelSrc, int channelDst)
{
if (channelSrc < 0 | channelSrc >= _channels) throw new ArgumentOutOfRangeException("channelSrc", "channelSrc must be in range [0..2].");
if (channelDst < 0 | channelDst >= dst.Channels) throw new ArgumentOutOfRangeException("channelDst", "channelDst must be in range [0..2].");
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_C3CR(_devPtrRoi + channelSrc * _typeSize, _pitch, dst.DevicePointerRoi + channelDst * _typeSize, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_C3CR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Masked Operation 8-bit unsigned image copy.
/// </summary>
/// <param name="dst">Destination image</param>
/// <param name="mask">Mask image</param>
public void Copy(NPPImage_32sC3 dst, NPPImage_8uC1 mask)
{
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_C3MR(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, mask.DevicePointerRoi, mask.Pitch);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_C3MR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Three channel 32-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_32sC3 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_32s_C3R(_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_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Three-channel 8-bit unsigned planar to packed image copy.
/// </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 Copy(NPPImage_32sC1 src0, NPPImage_32sC1 src1, NPPImage_32sC1 src2, NPPImage_32sC3 dest)
{
CUdeviceptr[] array = new CUdeviceptr[] { src0.DevicePointerRoi, src1.DevicePointerRoi, src2.DevicePointerRoi };
NppStatus status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_P3C3R(array, src0.Pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_P3C3R", status));
NPPException.CheckNppStatus(status, null);
}
/// <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_32sC3 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_32s_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// linearly interpolated source image subpixel coordinate color copy.
/// </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 CopySubpix(NPPImage_32sC3 dst, float nDx, float nDy)
{
status = NPPNativeMethods.NPPi.CopySubpix.nppiCopySubpix_32s_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nDx, nDy);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopySubpix_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image copy with the borders wrapped by replication of source image pixel colors.
/// </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 CopyWrapBorder(NPPImage_32sC3 dst, int nTopBorderHeight, int nLeftBorderWidth)
{
status = NPPNativeMethods.NPPi.CopyWrapBorder.nppiCopyWrapBorder_32s_C3R(_devPtrRoi, _pitch, _sizeRoi, dst.DevicePointerRoi, dst.Pitch, dst.SizeRoi, nTopBorderHeight, nLeftBorderWidth);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopyWrapBorder_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 16-bit unsigned to 32-bit signed conversion.
/// </summary>
/// <param name="dst">Destination image</param>
public void Convert(NPPImage_32sC3 dst)
{
status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_16u32s_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_16u32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image logical and.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="dest">Destination image</param>
public void And(NPPImage_32sC3 src2, NPPImage_32sC3 dest)
{
status = NPPNativeMethods.NPPi.And.nppiAnd_32s_C3R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAnd_32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Swap channels.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="aDstOrder">Host memory integer array describing how channel values are permutated. The n-th entry
/// of the array contains the number of the channel that is stored in the n-th channel of
/// the output image. <para/>E.g. Given an RGBA image, aDstOrder = [2,1,0] converts this to a 3 channel BGR
/// channel order.</param>
public void SwapChannels(NPPImage_32sC3 dest, int[] aDstOrder)
{
status = NPPNativeMethods.NPPi.SwapChannel.nppiSwapChannels_32s_C4C3R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, aDstOrder);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSwapChannels_32s_C4C3R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image conversion.
/// </summary>
/// <param name="dst">Destination-Image</param>
public void Scale(NPPImage_32sC3 dst)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
status = NPPNativeMethods.NPPi.Scale.nppiScale_8u32s_C3R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiScale_8u32s_C3R", status));
NPPException.CheckNppStatus(status, this);
}