org.bytedeco.javacpp

Class opencv_cudawarping

java.lang.Object

org.bytedeco.javacpp.presets.opencv_cudawarping

org.bytedeco.javacpp.opencv_cudawarping

All Implemented Interfaces:

org.bytedeco.javacpp.tools.InfoMapper

public class opencv_cudawarping
extends opencv_cudawarping

Constructor Summary

Constructors

Constructor and Description
opencv_cudawarping()

Method Summary

Modifier and Type	Method and Description
static void	buildWarpAffineMaps(opencv_core.GpuMat M, boolean inverse, opencv_core.Size dsize, opencv_core.GpuMat xmap, opencv_core.GpuMat ymap)
static void	buildWarpAffineMaps(opencv_core.GpuMat M, boolean inverse, opencv_core.Size dsize, opencv_core.GpuMat xmap, opencv_core.GpuMat ymap, opencv_core.Stream stream)
static void	buildWarpAffineMaps(opencv_core.Mat M, boolean inverse, opencv_core.Size dsize, opencv_core.Mat xmap, opencv_core.Mat ymap)
static void	buildWarpAffineMaps(opencv_core.Mat M, boolean inverse, opencv_core.Size dsize, opencv_core.Mat xmap, opencv_core.Mat ymap, opencv_core.Stream stream) \brief Builds transformation maps for affine transformation.
static void	buildWarpAffineMaps(opencv_core.UMat M, boolean inverse, opencv_core.Size dsize, opencv_core.UMat xmap, opencv_core.UMat ymap)
static void	buildWarpAffineMaps(opencv_core.UMat M, boolean inverse, opencv_core.Size dsize, opencv_core.UMat xmap, opencv_core.UMat ymap, opencv_core.Stream stream)
static void	buildWarpPerspectiveMaps(opencv_core.GpuMat M, boolean inverse, opencv_core.Size dsize, opencv_core.GpuMat xmap, opencv_core.GpuMat ymap)
static void	buildWarpPerspectiveMaps(opencv_core.GpuMat M, boolean inverse, opencv_core.Size dsize, opencv_core.GpuMat xmap, opencv_core.GpuMat ymap, opencv_core.Stream stream)
static void	buildWarpPerspectiveMaps(opencv_core.Mat M, boolean inverse, opencv_core.Size dsize, opencv_core.Mat xmap, opencv_core.Mat ymap)
static void	buildWarpPerspectiveMaps(opencv_core.Mat M, boolean inverse, opencv_core.Size dsize, opencv_core.Mat xmap, opencv_core.Mat ymap, opencv_core.Stream stream) \brief Builds transformation maps for perspective transformation.
static void	buildWarpPerspectiveMaps(opencv_core.UMat M, boolean inverse, opencv_core.Size dsize, opencv_core.UMat xmap, opencv_core.UMat ymap)
static void	buildWarpPerspectiveMaps(opencv_core.UMat M, boolean inverse, opencv_core.Size dsize, opencv_core.UMat xmap, opencv_core.UMat ymap, opencv_core.Stream stream)
static void	pyrDown(opencv_core.GpuMat src, opencv_core.GpuMat dst)
static void	pyrDown(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.Stream stream)
static void	pyrDown(opencv_core.Mat src, opencv_core.Mat dst)
static void	pyrDown(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Stream stream) \brief Smoothes an image and downsamples it.
static void	pyrDown(opencv_core.UMat src, opencv_core.UMat dst)
static void	pyrDown(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.Stream stream)
static void	pyrUp(opencv_core.GpuMat src, opencv_core.GpuMat dst)
static void	pyrUp(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.Stream stream)
static void	pyrUp(opencv_core.Mat src, opencv_core.Mat dst)
static void	pyrUp(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Stream stream) \brief Upsamples an image and then smoothes it.
static void	pyrUp(opencv_core.UMat src, opencv_core.UMat dst)
static void	pyrUp(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.Stream stream)
static void	remap(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat xmap, opencv_core.GpuMat ymap, int interpolation)
static void	remap(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat xmap, opencv_core.GpuMat ymap, int interpolation, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream)
static void	remap(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat xmap, opencv_core.Mat ymap, int interpolation)
static void	remap(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat xmap, opencv_core.Mat ymap, int interpolation, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream) \addtogroup cudawarping \{
static void	remap(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat xmap, opencv_core.UMat ymap, int interpolation)
static void	remap(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat xmap, opencv_core.UMat ymap, int interpolation, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream)
static void	resize(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.Size dsize)
static void	resize(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.Size dsize, double fx, double fy, int interpolation, opencv_core.Stream stream)
static void	resize(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dsize)
static void	resize(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dsize, double fx, double fy, int interpolation, opencv_core.Stream stream) \brief Resizes an image.
static void	resize(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.Size dsize)
static void	resize(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.Size dsize, double fx, double fy, int interpolation, opencv_core.Stream stream)
static void	rotate(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.Size dsize, double angle)
static void	rotate(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.Size dsize, double angle, double xShift, double yShift, int interpolation, opencv_core.Stream stream)
static void	rotate(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dsize, double angle)
static void	rotate(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Size dsize, double angle, double xShift, double yShift, int interpolation, opencv_core.Stream stream) \brief Rotates an image around the origin (0,0) and then shifts it.
static void	rotate(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.Size dsize, double angle)
static void	rotate(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.Size dsize, double angle, double xShift, double yShift, int interpolation, opencv_core.Stream stream)
static void	warpAffine(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat M, opencv_core.Size dsize)
static void	warpAffine(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream)
static void	warpAffine(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize)
static void	warpAffine(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream) \brief Applies an affine transformation to an image.
static void	warpAffine(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat M, opencv_core.Size dsize)
static void	warpAffine(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream)
static void	warpPerspective(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat M, opencv_core.Size dsize)
static void	warpPerspective(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream)
static void	warpPerspective(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize)
static void	warpPerspective(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream) \brief Applies a perspective transformation to an image.
static void	warpPerspective(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat M, opencv_core.Size dsize)
static void	warpPerspective(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat M, opencv_core.Size dsize, int flags, int borderMode, opencv_core.Scalar borderValue, opencv_core.Stream stream)

Methods inherited from class org.bytedeco.javacpp.presets.opencv_cudawarping

map

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

opencv_cudawarping

public opencv_cudawarping()

Method Detail

remap

@Namespace(value="cv::cuda")
public static void remap(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      @ByVal
                                                      opencv_core.Mat xmap,
                                                      @ByVal
                                                      opencv_core.Mat ymap,
                                                      int interpolation,
                                                      int borderMode,
                                                      @ByVal(nullValue="cv::Scalar()")
                                                      opencv_core.Scalar borderValue,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      opencv_core.Stream stream)

\addtogroup cudawarping \{

/** \brief Applies a generic geometrical transformation to an image.

Parameters:

src - Source image.

dst - Destination image with the size the same as xmap and the type the same as src .

xmap - X values. Only CV_32FC1 type is supported.

ymap - Y values. Only CV_32FC1 type is supported.

interpolation - Interpolation method (see resize ). INTER_NEAREST , INTER_LINEAR and INTER_CUBIC are supported for now.

borderMode - Pixel extrapolation method (see borderInterpolate ). BORDER_REFLECT101 , BORDER_REPLICATE , BORDER_CONSTANT , BORDER_REFLECT and BORDER_WRAP are supported for now.

borderValue - Value used in case of a constant border. By default, it is 0.

stream - Stream for the asynchronous version.

The function transforms the source image using the specified map:

\f[\texttt{dst} (x,y) = \texttt{src} (xmap(x,y), ymap(x,y))\f]

Values of pixels with non-integer coordinates are computed using the bilinear interpolation.

\sa remap

remap

@Namespace(value="cv::cuda")
public static void remap(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      @ByVal
                                                      opencv_core.Mat xmap,
                                                      @ByVal
                                                      opencv_core.Mat ymap,
                                                      int interpolation)

remap

@Namespace(value="cv::cuda")
public static void remap(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      @ByVal
                                                      opencv_core.UMat xmap,
                                                      @ByVal
                                                      opencv_core.UMat ymap,
                                                      int interpolation,
                                                      int borderMode,
                                                      @ByVal(nullValue="cv::Scalar()")
                                                      opencv_core.Scalar borderValue,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      opencv_core.Stream stream)

remap

@Namespace(value="cv::cuda")
public static void remap(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      @ByVal
                                                      opencv_core.UMat xmap,
                                                      @ByVal
                                                      opencv_core.UMat ymap,
                                                      int interpolation)

remap

@Namespace(value="cv::cuda")
public static void remap(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      @ByVal
                                                      opencv_core.GpuMat xmap,
                                                      @ByVal
                                                      opencv_core.GpuMat ymap,
                                                      int interpolation,
                                                      int borderMode,
                                                      @ByVal(nullValue="cv::Scalar()")
                                                      opencv_core.Scalar borderValue,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      opencv_core.Stream stream)

remap

@Namespace(value="cv::cuda")
public static void remap(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      @ByVal
                                                      opencv_core.GpuMat xmap,
                                                      @ByVal
                                                      opencv_core.GpuMat ymap,
                                                      int interpolation)

resize

@Namespace(value="cv::cuda")
public static void resize(@ByVal
                                                       opencv_core.Mat src,
                                                       @ByVal
                                                       opencv_core.Mat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double fx,
                                                       double fy,
                                                       int interpolation,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       opencv_core.Stream stream)

\brief Resizes an image.

Parameters:

src - Source image.

dst - Destination image with the same type as src . The size is dsize (when it is non-zero) or the size is computed from src.size() , fx , and fy .

dsize - Destination image size. If it is zero, it is computed as: \f[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\f] Either dsize or both fx and fy must be non-zero.

fx - Scale factor along the horizontal axis. If it is zero, it is computed as: \f[\texttt{(double)dsize.width/src.cols}\f]

fy - Scale factor along the vertical axis. If it is zero, it is computed as: \f[\texttt{(double)dsize.height/src.rows}\f]

interpolation - Interpolation method. INTER_NEAREST , INTER_LINEAR and INTER_CUBIC are supported for now.

stream - Stream for the asynchronous version.

\sa resize

resize

@Namespace(value="cv::cuda")
public static void resize(@ByVal
                                                       opencv_core.Mat src,
                                                       @ByVal
                                                       opencv_core.Mat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize)

resize

@Namespace(value="cv::cuda")
public static void resize(@ByVal
                                                       opencv_core.UMat src,
                                                       @ByVal
                                                       opencv_core.UMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double fx,
                                                       double fy,
                                                       int interpolation,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       opencv_core.Stream stream)

resize

@Namespace(value="cv::cuda")
public static void resize(@ByVal
                                                       opencv_core.UMat src,
                                                       @ByVal
                                                       opencv_core.UMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize)

resize

@Namespace(value="cv::cuda")
public static void resize(@ByVal
                                                       opencv_core.GpuMat src,
                                                       @ByVal
                                                       opencv_core.GpuMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double fx,
                                                       double fy,
                                                       int interpolation,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       opencv_core.Stream stream)

resize

@Namespace(value="cv::cuda")
public static void resize(@ByVal
                                                       opencv_core.GpuMat src,
                                                       @ByVal
                                                       opencv_core.GpuMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize)

warpAffine

@Namespace(value="cv::cuda")
public static void warpAffine(@ByVal
                                                           opencv_core.Mat src,
                                                           @ByVal
                                                           opencv_core.Mat dst,
                                                           @ByVal
                                                           opencv_core.Mat M,
                                                           @ByVal
                                                           opencv_core.Size dsize,
                                                           int flags,
                                                           int borderMode,
                                                           @ByVal(nullValue="cv::Scalar()")
                                                           opencv_core.Scalar borderValue,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           opencv_core.Stream stream)

\brief Applies an affine transformation to an image.

Parameters:

src - Source image. CV_8U , CV_16U , CV_32S , or CV_32F depth and 1, 3, or 4 channels are supported.

dst - Destination image with the same type as src . The size is dsize .

M - *2x3* transformation matrix.

dsize - Size of the destination image.

flags - Combination of interpolation methods (see resize) and the optional flag WARP_INVERSE_MAP specifying that M is an inverse transformation ( dst=\>src ). Only INTER_NEAREST , INTER_LINEAR , and INTER_CUBIC interpolation methods are supported.

borderMode -

borderValue -

stream - Stream for the asynchronous version.

\sa warpAffine

warpAffine

@Namespace(value="cv::cuda")
public static void warpAffine(@ByVal
                                                           opencv_core.Mat src,
                                                           @ByVal
                                                           opencv_core.Mat dst,
                                                           @ByVal
                                                           opencv_core.Mat M,
                                                           @ByVal
                                                           opencv_core.Size dsize)

warpAffine

@Namespace(value="cv::cuda")
public static void warpAffine(@ByVal
                                                           opencv_core.UMat src,
                                                           @ByVal
                                                           opencv_core.UMat dst,
                                                           @ByVal
                                                           opencv_core.UMat M,
                                                           @ByVal
                                                           opencv_core.Size dsize,
                                                           int flags,
                                                           int borderMode,
                                                           @ByVal(nullValue="cv::Scalar()")
                                                           opencv_core.Scalar borderValue,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           opencv_core.Stream stream)

warpAffine

@Namespace(value="cv::cuda")
public static void warpAffine(@ByVal
                                                           opencv_core.UMat src,
                                                           @ByVal
                                                           opencv_core.UMat dst,
                                                           @ByVal
                                                           opencv_core.UMat M,
                                                           @ByVal
                                                           opencv_core.Size dsize)

warpAffine

@Namespace(value="cv::cuda")
public static void warpAffine(@ByVal
                                                           opencv_core.GpuMat src,
                                                           @ByVal
                                                           opencv_core.GpuMat dst,
                                                           @ByVal
                                                           opencv_core.GpuMat M,
                                                           @ByVal
                                                           opencv_core.Size dsize,
                                                           int flags,
                                                           int borderMode,
                                                           @ByVal(nullValue="cv::Scalar()")
                                                           opencv_core.Scalar borderValue,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           opencv_core.Stream stream)

warpAffine

@Namespace(value="cv::cuda")
public static void warpAffine(@ByVal
                                                           opencv_core.GpuMat src,
                                                           @ByVal
                                                           opencv_core.GpuMat dst,
                                                           @ByVal
                                                           opencv_core.GpuMat M,
                                                           @ByVal
                                                           opencv_core.Size dsize)

buildWarpAffineMaps

@Namespace(value="cv::cuda")
public static void buildWarpAffineMaps(@ByVal
                                                                    opencv_core.Mat M,
                                                                    @Cast(value="bool")
                                                                    boolean inverse,
                                                                    @ByVal
                                                                    opencv_core.Size dsize,
                                                                    @ByVal
                                                                    opencv_core.Mat xmap,
                                                                    @ByVal
                                                                    opencv_core.Mat ymap,
                                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                    opencv_core.Stream stream)

\brief Builds transformation maps for affine transformation.

Parameters:

M - *2x3* transformation matrix.

inverse - Flag specifying that M is an inverse transformation ( dst=\>src ).

dsize - Size of the destination image.

xmap - X values with CV_32FC1 type.

ymap - Y values with CV_32FC1 type.

stream - Stream for the asynchronous version.

\sa cuda::warpAffine , cuda::remap

buildWarpAffineMaps

@Namespace(value="cv::cuda")
public static void buildWarpAffineMaps(@ByVal
                                                                    opencv_core.Mat M,
                                                                    @Cast(value="bool")
                                                                    boolean inverse,
                                                                    @ByVal
                                                                    opencv_core.Size dsize,
                                                                    @ByVal
                                                                    opencv_core.Mat xmap,
                                                                    @ByVal
                                                                    opencv_core.Mat ymap)

buildWarpAffineMaps

@Namespace(value="cv::cuda")
public static void buildWarpAffineMaps(@ByVal
                                                                    opencv_core.UMat M,
                                                                    @Cast(value="bool")
                                                                    boolean inverse,
                                                                    @ByVal
                                                                    opencv_core.Size dsize,
                                                                    @ByVal
                                                                    opencv_core.UMat xmap,
                                                                    @ByVal
                                                                    opencv_core.UMat ymap,
                                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                    opencv_core.Stream stream)

buildWarpAffineMaps

@Namespace(value="cv::cuda")
public static void buildWarpAffineMaps(@ByVal
                                                                    opencv_core.UMat M,
                                                                    @Cast(value="bool")
                                                                    boolean inverse,
                                                                    @ByVal
                                                                    opencv_core.Size dsize,
                                                                    @ByVal
                                                                    opencv_core.UMat xmap,
                                                                    @ByVal
                                                                    opencv_core.UMat ymap)

buildWarpAffineMaps

@Namespace(value="cv::cuda")
public static void buildWarpAffineMaps(@ByVal
                                                                    opencv_core.GpuMat M,
                                                                    @Cast(value="bool")
                                                                    boolean inverse,
                                                                    @ByVal
                                                                    opencv_core.Size dsize,
                                                                    @ByVal
                                                                    opencv_core.GpuMat xmap,
                                                                    @ByVal
                                                                    opencv_core.GpuMat ymap,
                                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                    opencv_core.Stream stream)

buildWarpAffineMaps

@Namespace(value="cv::cuda")
public static void buildWarpAffineMaps(@ByVal
                                                                    opencv_core.GpuMat M,
                                                                    @Cast(value="bool")
                                                                    boolean inverse,
                                                                    @ByVal
                                                                    opencv_core.Size dsize,
                                                                    @ByVal
                                                                    opencv_core.GpuMat xmap,
                                                                    @ByVal
                                                                    opencv_core.GpuMat ymap)

warpPerspective

@Namespace(value="cv::cuda")
public static void warpPerspective(@ByVal
                                                                opencv_core.Mat src,
                                                                @ByVal
                                                                opencv_core.Mat dst,
                                                                @ByVal
                                                                opencv_core.Mat M,
                                                                @ByVal
                                                                opencv_core.Size dsize,
                                                                int flags,
                                                                int borderMode,
                                                                @ByVal(nullValue="cv::Scalar()")
                                                                opencv_core.Scalar borderValue,
                                                                @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                opencv_core.Stream stream)

\brief Applies a perspective transformation to an image.

Parameters:

src - Source image. CV_8U , CV_16U , CV_32S , or CV_32F depth and 1, 3, or 4 channels are supported.

dst - Destination image with the same type as src . The size is dsize .

M - *3x3* transformation matrix.

dsize - Size of the destination image.

flags - Combination of interpolation methods (see resize ) and the optional flag WARP_INVERSE_MAP specifying that M is the inverse transformation ( dst =\> src ). Only INTER_NEAREST , INTER_LINEAR , and INTER_CUBIC interpolation methods are supported.

borderMode -

borderValue -

stream - Stream for the asynchronous version.

\sa warpPerspective

warpPerspective

@Namespace(value="cv::cuda")
public static void warpPerspective(@ByVal
                                                                opencv_core.Mat src,
                                                                @ByVal
                                                                opencv_core.Mat dst,
                                                                @ByVal
                                                                opencv_core.Mat M,
                                                                @ByVal
                                                                opencv_core.Size dsize)

warpPerspective

@Namespace(value="cv::cuda")
public static void warpPerspective(@ByVal
                                                                opencv_core.UMat src,
                                                                @ByVal
                                                                opencv_core.UMat dst,
                                                                @ByVal
                                                                opencv_core.UMat M,
                                                                @ByVal
                                                                opencv_core.Size dsize,
                                                                int flags,
                                                                int borderMode,
                                                                @ByVal(nullValue="cv::Scalar()")
                                                                opencv_core.Scalar borderValue,
                                                                @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                opencv_core.Stream stream)

warpPerspective

@Namespace(value="cv::cuda")
public static void warpPerspective(@ByVal
                                                                opencv_core.UMat src,
                                                                @ByVal
                                                                opencv_core.UMat dst,
                                                                @ByVal
                                                                opencv_core.UMat M,
                                                                @ByVal
                                                                opencv_core.Size dsize)

warpPerspective

@Namespace(value="cv::cuda")
public static void warpPerspective(@ByVal
                                                                opencv_core.GpuMat src,
                                                                @ByVal
                                                                opencv_core.GpuMat dst,
                                                                @ByVal
                                                                opencv_core.GpuMat M,
                                                                @ByVal
                                                                opencv_core.Size dsize,
                                                                int flags,
                                                                int borderMode,
                                                                @ByVal(nullValue="cv::Scalar()")
                                                                opencv_core.Scalar borderValue,
                                                                @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                opencv_core.Stream stream)

warpPerspective

@Namespace(value="cv::cuda")
public static void warpPerspective(@ByVal
                                                                opencv_core.GpuMat src,
                                                                @ByVal
                                                                opencv_core.GpuMat dst,
                                                                @ByVal
                                                                opencv_core.GpuMat M,
                                                                @ByVal
                                                                opencv_core.Size dsize)

buildWarpPerspectiveMaps

@Namespace(value="cv::cuda")
public static void buildWarpPerspectiveMaps(@ByVal
                                                                         opencv_core.Mat M,
                                                                         @Cast(value="bool")
                                                                         boolean inverse,
                                                                         @ByVal
                                                                         opencv_core.Size dsize,
                                                                         @ByVal
                                                                         opencv_core.Mat xmap,
                                                                         @ByVal
                                                                         opencv_core.Mat ymap,
                                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                         opencv_core.Stream stream)

\brief Builds transformation maps for perspective transformation.

Parameters:

M - *3x3* transformation matrix.

inverse - Flag specifying that M is an inverse transformation ( dst=\>src ).

dsize - Size of the destination image.

xmap - X values with CV_32FC1 type.

ymap - Y values with CV_32FC1 type.

stream - Stream for the asynchronous version.

\sa cuda::warpPerspective , cuda::remap

buildWarpPerspectiveMaps

@Namespace(value="cv::cuda")
public static void buildWarpPerspectiveMaps(@ByVal
                                                                         opencv_core.Mat M,
                                                                         @Cast(value="bool")
                                                                         boolean inverse,
                                                                         @ByVal
                                                                         opencv_core.Size dsize,
                                                                         @ByVal
                                                                         opencv_core.Mat xmap,
                                                                         @ByVal
                                                                         opencv_core.Mat ymap)

buildWarpPerspectiveMaps

@Namespace(value="cv::cuda")
public static void buildWarpPerspectiveMaps(@ByVal
                                                                         opencv_core.UMat M,
                                                                         @Cast(value="bool")
                                                                         boolean inverse,
                                                                         @ByVal
                                                                         opencv_core.Size dsize,
                                                                         @ByVal
                                                                         opencv_core.UMat xmap,
                                                                         @ByVal
                                                                         opencv_core.UMat ymap,
                                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                         opencv_core.Stream stream)

buildWarpPerspectiveMaps

@Namespace(value="cv::cuda")
public static void buildWarpPerspectiveMaps(@ByVal
                                                                         opencv_core.UMat M,
                                                                         @Cast(value="bool")
                                                                         boolean inverse,
                                                                         @ByVal
                                                                         opencv_core.Size dsize,
                                                                         @ByVal
                                                                         opencv_core.UMat xmap,
                                                                         @ByVal
                                                                         opencv_core.UMat ymap)

buildWarpPerspectiveMaps

@Namespace(value="cv::cuda")
public static void buildWarpPerspectiveMaps(@ByVal
                                                                         opencv_core.GpuMat M,
                                                                         @Cast(value="bool")
                                                                         boolean inverse,
                                                                         @ByVal
                                                                         opencv_core.Size dsize,
                                                                         @ByVal
                                                                         opencv_core.GpuMat xmap,
                                                                         @ByVal
                                                                         opencv_core.GpuMat ymap,
                                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                         opencv_core.Stream stream)

buildWarpPerspectiveMaps

@Namespace(value="cv::cuda")
public static void buildWarpPerspectiveMaps(@ByVal
                                                                         opencv_core.GpuMat M,
                                                                         @Cast(value="bool")
                                                                         boolean inverse,
                                                                         @ByVal
                                                                         opencv_core.Size dsize,
                                                                         @ByVal
                                                                         opencv_core.GpuMat xmap,
                                                                         @ByVal
                                                                         opencv_core.GpuMat ymap)

rotate

@Namespace(value="cv::cuda")
public static void rotate(@ByVal
                                                       opencv_core.Mat src,
                                                       @ByVal
                                                       opencv_core.Mat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double angle,
                                                       double xShift,
                                                       double yShift,
                                                       int interpolation,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       opencv_core.Stream stream)

\brief Rotates an image around the origin (0,0) and then shifts it.

Parameters:

src - Source image. Supports 1, 3 or 4 channels images with CV_8U , CV_16U or CV_32F depth.

dst - Destination image with the same type as src . The size is dsize .

dsize - Size of the destination image.

angle - Angle of rotation in degrees.

xShift - Shift along the horizontal axis.

yShift - Shift along the vertical axis.

interpolation - Interpolation method. Only INTER_NEAREST , INTER_LINEAR , and INTER_CUBIC are supported.

stream - Stream for the asynchronous version.

\sa cuda::warpAffine

rotate

@Namespace(value="cv::cuda")
public static void rotate(@ByVal
                                                       opencv_core.Mat src,
                                                       @ByVal
                                                       opencv_core.Mat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double angle)

rotate

@Namespace(value="cv::cuda")
public static void rotate(@ByVal
                                                       opencv_core.UMat src,
                                                       @ByVal
                                                       opencv_core.UMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double angle,
                                                       double xShift,
                                                       double yShift,
                                                       int interpolation,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       opencv_core.Stream stream)

rotate

@Namespace(value="cv::cuda")
public static void rotate(@ByVal
                                                       opencv_core.UMat src,
                                                       @ByVal
                                                       opencv_core.UMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double angle)

rotate

@Namespace(value="cv::cuda")
public static void rotate(@ByVal
                                                       opencv_core.GpuMat src,
                                                       @ByVal
                                                       opencv_core.GpuMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double angle,
                                                       double xShift,
                                                       double yShift,
                                                       int interpolation,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       opencv_core.Stream stream)

rotate

@Namespace(value="cv::cuda")
public static void rotate(@ByVal
                                                       opencv_core.GpuMat src,
                                                       @ByVal
                                                       opencv_core.GpuMat dst,
                                                       @ByVal
                                                       opencv_core.Size dsize,
                                                       double angle)

pyrDown

@Namespace(value="cv::cuda")
public static void pyrDown(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        opencv_core.Stream stream)

\brief Smoothes an image and downsamples it.

Parameters:

src - Source image.

dst - Destination image. Will have Size((src.cols+1)/2, (src.rows+1)/2) size and the same type as src .

stream - Stream for the asynchronous version.

\sa pyrDown

pyrDown

@Namespace(value="cv::cuda")
public static void pyrDown(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst)

pyrDown

@Namespace(value="cv::cuda")
public static void pyrDown(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        opencv_core.Stream stream)

pyrDown

@Namespace(value="cv::cuda")
public static void pyrDown(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst)

pyrDown

@Namespace(value="cv::cuda")
public static void pyrDown(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        opencv_core.Stream stream)

pyrDown

@Namespace(value="cv::cuda")
public static void pyrDown(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst)

pyrUp

@Namespace(value="cv::cuda")
public static void pyrUp(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      opencv_core.Stream stream)

\brief Upsamples an image and then smoothes it.

Parameters:

src - Source image.

dst - Destination image. Will have Size(src.cols\*2, src.rows\*2) size and the same type as src .

stream - Stream for the asynchronous version.

pyrUp

@Namespace(value="cv::cuda")
public static void pyrUp(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst)

pyrUp

@Namespace(value="cv::cuda")
public static void pyrUp(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      opencv_core.Stream stream)

pyrUp

@Namespace(value="cv::cuda")
public static void pyrUp(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst)

pyrUp

@Namespace(value="cv::cuda")
public static void pyrUp(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      opencv_core.Stream stream)

pyrUp

@Namespace(value="cv::cuda")
public static void pyrUp(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)