/// <summary>
/// Image logical Or.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="dest">Destination image</param>
public void Or(NPPImage_32sC4 src2, NPPImage_32sC4 dest)
{
status = NPPNativeMethods.NPPi.Or.nppiOr_32s_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiOr_32s_C4R", 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_32sC4 src2)
{
status = NPPNativeMethods.NPPi.Xor.nppiXor_32s_AC4IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiXor_32s_AC4IR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Four channel 32-bit signed convolution filter with border control, ignoring alpha channel.<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 FilterBorderA(NPPImage_32sC4 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_32s_AC4R(_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_AC4R", 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="src3">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_32sC1 src3, NPPImage_32sC4 dest)
{
CUdeviceptr[] array = new CUdeviceptr[] { src0.DevicePointerRoi, src1.DevicePointerRoi, src2.DevicePointerRoi, src3.DevicePointerRoi };
NppStatus status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_P4C4R(array, src0.Pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_P4C4R", status));
NPPException.CheckNppStatus(status, null);
}
/// <summary>
/// Mirror image. Not affecting Alpha.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="flip">Specifies the axis about which the image is to be mirrored.</param>
public void MirrorA(NPPImage_32sC4 dest, NppiAxis flip)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiMirror_32s_AC4R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, flip);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMirror_32s_AC4R", 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_32sC4 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_32s_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_32s_C4R", 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_32sC4 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_32s_C4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_32s_C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// In place image multiplication, 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 Mul(NPPImage_32sC4 src2, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Mul.nppiMul_32s_C4IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMul_32s_C4IRSfs", 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_32sC4 dst, int nTopBorderHeight, int nLeftBorderWidth)
{
status = NPPNativeMethods.NPPi.CopyWrapBorder.nppiCopyWrapBorder_32s_C4R(_devPtrRoi, _pitch, _sizeRoi, dst.DevicePointerRoi, dst.Pitch, dst.SizeRoi, nTopBorderHeight, nLeftBorderWidth);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopyWrapBorder_32s_C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Swap channels.
/// </summary>
/// <param name="dest">Destination image</param>
/// <param name="aDstOrder">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. E.g.
/// Given an RGBA image, aDstOrder = [3,2,1,0] converts this to ABGR channel order.</param>
public void SwapChannels(NPPImage_32sC4 dest, int[] aDstOrder)
{
status = NPPNativeMethods.NPPi.SwapChannel.nppiSwapChannels_32s_C4R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, aDstOrder);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSwapChannels_32s_C4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Four-channel 32-bit unsigned image DotProd. Buffer is internally allocated and freed. Ignoring alpha channel.
/// </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 ADotProduct(NPPImage_32sC4 src2, CudaDeviceVariable<double> pDp)
{
int bufferSize = DotProdGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.DotProd.nppiDotProd_32s64f_AC4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pDp.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDotProd_32s64f_AC4R", status));
buffer.Dispose();
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_32sC4 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_C4CR(_devPtrRoi + channelSrc * _typeSize, _pitch, dst.DevicePointerRoi + channelDst * _typeSize, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_C4CR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Perspective transform of an image. Not affecting Alpha channel.<para/>
/// This function performs perspective warping of a the specified
/// quadrangle in the source image to the specified quadrangle in the
/// destination image. The function nppiWarpPerspectiveQuad uses the same
/// formulas for pixel mapping as in nppiWarpPerspective function. The
/// transform coefficients are computed internally.
/// The transformed part of the source image is resampled using the specified
/// interpolation 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="destQuad">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 WarpPerspectiveQuadA(double[,] srcQuad, NPPImage_32sC4 dest, double[,] destQuad, InterpolationMode eInterpolation)
{
NppiRect rectIn = new NppiRect(_pointRoi, _sizeRoi);
NppiRect rectOut = new NppiRect(dest.PointRoi, dest.SizeRoi);
status = NPPNativeMethods.NPPi.PerspectiveTransforms.nppiWarpPerspectiveQuad_32s_AC4R(_devPtr, _sizeOriginal, _pitch, rectIn, srcQuad, dest.DevicePointer, dest.Pitch, rectOut, destQuad, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiWarpPerspectiveQuad_32s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image logical Xor with constant. Unchanged Alpha.
/// </summary>
/// <param name="nConstant">Value (Array length = 4)</param>
/// <param name="dest">Destination image</param>
public void XorA(int[] nConstant, NPPImage_32sC4 dest)
{
status = NPPNativeMethods.NPPi.XorConst.nppiXorC_32s_AC4R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAdd_32s_AC4RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image copy. Not affecting Alpha channel.
/// </summary>
/// <param name="dst">Destination image</param>
public void CopyA(NPPImage_32sC4 dst)
{
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image subtraction, scale by 2^(-nScaleFactor), then clamp to saturated value. Unchanged Alpha.
/// </summary>
/// <param name="src2">2nd source image</param>
/// <param name="dest">Destination image</param>
/// <param name="nScaleFactor">scaling factor</param>
public void SubA(NPPImage_32sC4 src2, NPPImage_32sC4 dest, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Sub.nppiSub_32s_AC4RSfs(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSub_32s_AC4RSfs", 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_32sC4 src2, CudaDeviceVariable<double> pError)
{
int bufferSize = MaximumRelativeErrorGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_32s_C4R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_32s_C4R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Multiply 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 Mul(int[] nConstant, NPPImage_32sC4 dest, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.MulConst.nppiMulC_32s_C4RSfs(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMulC_32s_C4RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image conversion. Not affecting Alpha.
/// </summary>
/// <param name="dst">Destination-Image</param>
public void ScaleA(NPPImage_32sC4 dst)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
status = NPPNativeMethods.NPPi.Scale.nppiScale_8u32s_AC4R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiScale_8u32s_AC4R", status));
NPPException.CheckNppStatus(status, this);
}