/// <summary>
/// One-channel 8-bit unsigned image SqrIntegral.
/// Destination integral image is 32-bit signed int.
/// Destination square integral image is 64-bit double floating point.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="sqr">Destination-Image</param>
/// <param name="nVal">The value to add to pDst image pixels</param>
/// <param name="nValSqr">The value to add to pSqr image pixels</param>
public void Integral(NPPImage_32sC1 dst, CudaPitchedDeviceVariable<double> sqr, int nVal, double nValSqr)
{
status = NPPNativeMethods.NPPi.Integral.nppiSqrIntegral_8u32s64f_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, sqr.DevicePointer, sqr.Pitch, _sizeRoi, nVal, nValSqr);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiSqrIntegral_8u32s64f_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image bit shift by constant (right).
/// </summary>
/// <param name="nConstant">Constant</param>
/// <param name="dest">Destination image</param>
public void RShiftC(uint nConstant, NPPImage_32sC1 dest)
{
status = NPPNativeMethods.NPPi.RightShiftConst.nppiRShiftC_32s_C1R(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRShiftC_32s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Image copy.
/// </summary>
/// <param name="dst">Destination image</param>
/// <param name="channel">Channel number. This number is added to the dst pointer</param>
public void Copy(NPPImage_32sC1 dst, int channel)
{
if (channel < 0 | channel >= _channels) throw new ArgumentOutOfRangeException("channel", "channel must be in range [0..3].");
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_C4C1R(_devPtrRoi + channel * _typeSize, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_C4C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Three-channel 8-bit unsigned packed to planar image copy.
/// </summary>
/// <param name="dst0">Destination image channel 0</param>
/// <param name="dst1">Destination image channel 1</param>
/// <param name="dst2">Destination image channel 2</param>
/// <param name="dst3">Destination image channel 3</param>
public void Copy(NPPImage_32sC1 dst0, NPPImage_32sC1 dst1, NPPImage_32sC1 dst2, NPPImage_32sC1 dst3)
{
CUdeviceptr[] array = new CUdeviceptr[] { dst0.DevicePointerRoi, dst1.DevicePointerRoi, dst2.DevicePointerRoi, dst3.DevicePointerRoi };
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_C4P4R(_devPtrRoi, _pitch, array, dst0.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_C4P4R", status));
NPPException.CheckNppStatus(status, this);
}
///// <summary>
///// Image composition using image alpha values (0 - max channel pixel value).
///// 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_32sC1 src2, NPPImage_32sC1 dest, NppiAlphaOp nppAlphaOp)
//{
// status = NPPNativeMethods.NPPi.AlphaComp.nppiAlphaComp_32s_AC1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nppAlphaOp);
// Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAlphaComp_32s_AC1R", status));
// NPPException.CheckNppStatus(status, this);
//}
/// <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(int alpha1, NPPImage_32sC1 src2, int alpha2, NPPImage_32sC1 dest, NppiAlphaOp nppAlphaOp)
{
status = NPPNativeMethods.NPPi.AlphaCompConst.nppiAlphaCompC_32s_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_32s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <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>
/// RectStdDev, scaled by 2^(-nScaleFactor).
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="sqr">Destination-Image</param>
/// <param name="nScaleFactor">Integer Result Scaling.</param>
public void RectStdDev(NPPImage_32sC1 dst, NPPImage_32sC1 sqr, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Integral.nppiRectStdDev_32s_C1RSfs(_devPtr, _pitch, sqr.DevicePointer, sqr.Pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, new NppiRect(_pointRoi, _sizeRoi), nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiRectStdDev_32s_C1RSfs", 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_32sC1 src2, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.Div.nppiDiv_32s_C1IRSfs(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDiv_32s_C1IRSfs", 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_32sC1 dst, float nDx, float nDy)
{
status = NPPNativeMethods.NPPi.CopySubpix.nppiCopySubpix_32s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nDx, nDy);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopySubpix_32s_C1R", 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_32sC1 dst, CudaDeviceVariable<float> pKernel, NppiSize oKernelSize, NppiPoint oAnchor)
{
status = NPPNativeMethods.NPPi.Convolution.nppiFilter32f_32s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, pKernel.DevicePointer, oKernelSize, oAnchor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiFilter32f_32s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// One-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. (1 * sizeof(double))</param>
public void DotProduct(NPPImage_32sC1 src2, CudaDeviceVariable<double> pDp)
{
int bufferSize = DotProdGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.DotProd.nppiDotProd_32s64f_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pDp.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDotProd_32s64f_C1R", status));
buffer.Dispose();
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// 16-bit unsigned to 32-bit signed conversion.
/// </summary>
/// <param name="dst">Destination image</param>
public void Convert(NPPImage_32sC1 dst)
{
status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_16u32s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_16u32s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// image conversion.
/// </summary>
/// <param name="dst">Destination-Image</param>
public void Scale(NPPImage_32sC1 dst)
{
NppiRect srcRect = new NppiRect(_pointRoi, _sizeRoi);
status = NPPNativeMethods.NPPi.Scale.nppiScale_8u32s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiScale_8u32s_C1R", 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_32sC1 src2, NPPImage_32sC1 dest)
{
status = NPPNativeMethods.NPPi.And.nppiAnd_32s_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAnd_32s_C1R", 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_32sC1 src2, CudaDeviceVariable<double> pError)
{
int bufferSize = MaximumRelativeErrorGetBufferHostSize();
CudaDeviceVariable<byte> buffer = new CudaDeviceVariable<byte>(bufferSize);
status = NPPNativeMethods.NPPi.MaximumRelativeError.nppiMaximumRelativeError_32s_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMaximumRelativeError_32s_C1R", 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_32sC1 src2)
{
status = NPPNativeMethods.NPPi.Xor.nppiXor_32s_C1IR(src2.DevicePointerRoi, src2.Pitch, _devPtrRoi, _pitch, _sizeRoi);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiXor_32s_C1IR", 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_32sC1 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_C1R(_devPtrRoi, _pitch, src2.DevicePointerRoi, src2.Pitch, _sizeRoi, pError.DevicePointer, buffer.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiAverageRelativeError_32s_C1R", 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_32sC1 dest, int nScaleFactor)
{
status = NPPNativeMethods.NPPi.DivConst.nppiDivC_32s_C1RSfs(_devPtrRoi, _pitch, nConstant, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nScaleFactor);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDivC_32s_C1RSfs", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// One 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_32sC1 dest, CudaDeviceVariable<float> pKernel, NppiSize nKernelSize, NppiPoint oAnchor, NppiBorderType eBorderType)
{
status = NPPNativeMethods.NPPi.FilterBorder32f.nppiFilterBorder32f_32s_C1R(_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_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <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_32sC1 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_C1R(_devPtr, _sizeOriginal, _pitch, rectIn, srcQuad, dest.DevicePointer, dest.Pitch, rectOut, dstQuad, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiWarpAffineQuad_32s_C1R", 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_32sC1 dst, NPPImage_8uC1 mask)
{
status = NPPNativeMethods.NPPi.MemCopy.nppiCopy_32s_C1MR(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, mask.DevicePointerRoi, mask.Pitch);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopy_32s_C1MR", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Graphcut of a flow network (32bit signed integer edge capacities). The
/// function computes the minimal cut (graphcut) of a 2D regular 8-connected
/// graph. <para/>
/// The inputs are the capacities of the horizontal (in transposed form),
/// vertical and terminal (source and sink) edges. The capacities to source and
/// sink
/// are stored as capacity differences in the terminals array
/// ( terminals(x) = source(x) - sink(x) ). The implementation assumes that the
/// edge capacities
/// for boundary edges that would connect to nodes outside the specified domain
/// are set to 0 (for example left(0,*) == 0). If this is not fulfilled the
/// computed labeling may be wrong!<para/>
/// The computed binary labeling is encoded as unsigned 8bit values (0 and >0).
/// </summary>
/// <param name="Terminals">Pointer to differences of terminal edge capacities</param>
/// <param name="LeftTransposed">Pointer to transposed left edge capacities</param>
/// <param name="RightTransposed">Pointer to transposed right edge capacities</param>
/// <param name="Top">Pointer to top edge capacities (top(*,0) must be 0)</param>
/// <param name="TopLeft">Pointer to top left edge capacities (topleft(*,0) </param>
/// <param name="TopRight">Pointer to top right edge capacities (topright(*,0)</param>
/// <param name="Bottom">Pointer to bottom edge capacities (bottom(*,height-1)</param>
/// <param name="BottomLeft">Pointer to bottom left edge capacities </param>
/// <param name="BottomRight">Pointer to bottom right edge capacities </param>
/// <param name="Label">Pointer to destination label image </param>
/// <returns></returns>
public void GraphCut(NPPImage_32sC1 Terminals, NPPImage_32sC1 LeftTransposed, NPPImage_32sC1 RightTransposed,
NPPImage_32sC1 Top, NPPImage_32sC1 TopLeft, NPPImage_32sC1 TopRight, NPPImage_32sC1 Bottom, NPPImage_32sC1 BottomLeft,
NPPImage_32sC1 BottomRight, NPPImage_8uC1 Label)
{
status = NPPNativeMethods.NPPi.ImageLabeling.nppiGraphcut8_32s8u(Terminals.DevicePointer, LeftTransposed.DevicePointer,
RightTransposed.DevicePointer, Top.DevicePointer, TopLeft.DevicePointer, TopRight.DevicePointer, Bottom.DevicePointer,
BottomLeft.DevicePointer, BottomRight.DevicePointer, Terminals.Pitch, LeftTransposed.Pitch, _size, Label.DevicePointer,
Label.Pitch, _state);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiGraphcut8_32s8u", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Copy image and pad borders with a constant, user-specifiable color.
/// </summary>
/// <param name="dst">Destination image. The image ROI defines the destination region, i.e. the region that gets filled with data from
/// the source image (inner part) and constant border color (outer part).</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>
/// <param name="nValue">The pixel value to be set for border pixels.</param>
public void Copy(NPPImage_32sC1 dst, int nTopBorderHeight, int nLeftBorderWidth, int nValue)
{
status = NPPNativeMethods.NPPi.CopyConstBorder.nppiCopyConstBorder_32s_C1R(_devPtrRoi, _pitch, _sizeRoi, dst.DevicePointerRoi, dst.Pitch, dst.SizeRoi, nTopBorderHeight, nLeftBorderWidth, nValue);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCopyConstBorder_32s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
/// <summary>
/// Perspective transform of an image.<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="src0">Source image (Channel 0)</param>
/// <param name="src1">Source image (Channel 1)</param>
/// <param name="src2">Source image (Channel 2)</param>
/// <param name="srcQuad">Source quadrangle [4,2]</param>
/// <param name="dest0">Destination image (Channel 0)</param>
/// <param name="dest1">Destination image (Channel 1)</param>
/// <param name="dest2">Destination image (Channel 2)</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 static void WarpPerspectiveQuad(NPPImage_32sC1 src0, NPPImage_32sC1 src1, NPPImage_32sC1 src2, double[,] srcQuad, NPPImage_32sC1 dest0, NPPImage_32sC1 dest1, NPPImage_32sC1 dest2, double[,] destQuad, InterpolationMode eInterpolation)
{
NppiRect rectIn = new NppiRect(src0.PointRoi, src0.SizeRoi);
NppiRect rectOut = new NppiRect(dest0.PointRoi, dest0.SizeRoi);
CUdeviceptr[] src = new CUdeviceptr[] { src0.DevicePointer, src1.DevicePointer, src2.DevicePointer };
CUdeviceptr[] dst = new CUdeviceptr[] { dest0.DevicePointer, dest1.DevicePointer, dest2.DevicePointer };
NppStatus status = NPPNativeMethods.NPPi.PerspectiveTransforms.nppiWarpPerspectiveQuad_32s_P4R(src, src0.Size, src0.Pitch, rectIn, srcQuad, dst, dest0.Pitch, rectOut, destQuad, eInterpolation);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiWarpPerspectiveQuad_32s_P4R", status));
NPPException.CheckNppStatus(status, null);
}
/// <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_32sC1 dest, NppiAxis flip)
{
status = NPPNativeMethods.NPPi.GeometricTransforms.nppiMirror_32s_C1R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, dest.SizeRoi, flip);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiMirror_32s_C1R", 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>
/// Integral with 32-bit signed output.
/// </summary>
/// <param name="dst">Destination-Image</param>
/// <param name="nVal">The value to add to pDst image pixels</param>
public void Integral(NPPImage_32sC1 dst, int nVal)
{
status = NPPNativeMethods.NPPi.Integral.nppiIntegral_8u32s_C1R(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, nVal);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiIntegral_8u32s_C1R", status));
NPPException.CheckNppStatus(status, this);
}
