public class opencv_cudaarithm extends opencv_cudaarithm
| Modifier and Type | Class and Description |
|---|---|
static class |
opencv_cudaarithm.Convolution
\brief Base class for convolution (or cross-correlation) operator.
|
static class |
opencv_cudaarithm.DFT
\brief Base class for DFT operator as a cv::Algorithm.
|
static class |
opencv_cudaarithm.LookUpTable
\brief Base class for transform using lookup table.
|
| Constructor and Description |
|---|
opencv_cudaarithm() |
map@Namespace(value="cv::cuda")
public static void add(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
\addtogroup cudaarithm_elem \{
/** \brief Computes a matrix-matrix or matrix-scalar sum.
src1 - First source matrix or scalar.src2 - Second source matrix or scalar. Matrix should have the same size and type as src1 .dst - Destination matrix that has the same size and number of channels as the input array(s).
The depth is defined by dtype or src1 depth.mask - Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.dtype - Optional depth of the output array.stream - Stream for the asynchronous version.
\sa add
@Namespace(value="cv::cuda")
public static void add(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void add(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void add(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void add(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void add(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void subtract(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar. Matrix should have the same size and type as src1 .dst - Destination matrix that has the same size and number of channels as the input array(s).
The depth is defined by dtype or src1 depth.mask - Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.dtype - Optional depth of the output array.stream - Stream for the asynchronous version.
\sa subtract
@Namespace(value="cv::cuda")
public static void subtract(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void subtract(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void subtract(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void subtract(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void subtract(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void multiply(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
double scale,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and number of channels as the input array(s).
The depth is defined by dtype or src1 depth.scale - Optional scale factor.dtype - Optional depth of the output array.stream - Stream for the asynchronous version.
\sa multiply
@Namespace(value="cv::cuda")
public static void multiply(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void multiply(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
double scale,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void multiply(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void multiply(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
double scale,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void multiply(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void divide(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
double scale,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or a scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and number of channels as the input array(s).
The depth is defined by dtype or src1 depth.scale - Optional scale factor.dtype - Optional depth of the output array.stream - Stream for the asynchronous version.
This function, in contrast to divide, uses a round-down rounding mode.
\sa divide
@Namespace(value="cv::cuda")
public static void divide(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void divide(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
double scale,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void divide(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void divide(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
double scale,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void divide(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).stream - Stream for the asynchronous version.
\sa absdiff
@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void abs(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.
\sa abs
@Namespace(value="cv::cuda")
public static void abs(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void abs(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void abs(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void abs(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void abs(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void sqr(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void sqr(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void sqr(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void sqr(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void sqr(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void sqr(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void sqrt(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.
\sa sqrt
@Namespace(value="cv::cuda")
public static void sqrt(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void sqrt(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void sqrt(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void sqrt(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void sqrt(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void exp(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.
\sa exp
@Namespace(value="cv::cuda")
public static void exp(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void exp(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void exp(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void exp(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void exp(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void log(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.
\sa log
@Namespace(value="cv::cuda")
public static void log(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void log(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void log(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void log(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void log(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void pow(@ByVal
opencv_core.Mat src,
double power,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.power - Exponent of power.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.
The function pow raises every element of the input matrix to power :
\f[\texttt{dst} (I) = \fork{\texttt{src}(I)^power}{if \texttt{power} is integer}{|\texttt{src}(I)|^power}{otherwise}\f]
\sa pow
@Namespace(value="cv::cuda")
public static void pow(@ByVal
opencv_core.Mat src,
double power,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void pow(@ByVal
opencv_core.UMat src,
double power,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void pow(@ByVal
opencv_core.UMat src,
double power,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void pow(@ByVal
opencv_core.GpuMat src,
double power,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void pow(@ByVal
opencv_core.GpuMat src,
double power,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void compare(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int cmpop,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).cmpop - Flag specifying the relation between the elements to be checked:
- **CMP_EQ:** a(.) == b(.)
- **CMP_GT:** a(.) \> b(.)
- **CMP_GE:** a(.) \>= b(.)
- **CMP_LT:** a(.) \< b(.)
- **CMP_LE:** a(.) \<= b(.)
- **CMP_NE:** a(.) != b(.)stream - Stream for the asynchronous version.
\sa compare
@Namespace(value="cv::cuda")
public static void compare(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int cmpop)
@Namespace(value="cv::cuda")
public static void compare(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int cmpop,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void compare(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int cmpop)
@Namespace(value="cv::cuda")
public static void compare(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int cmpop,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void compare(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int cmpop)
@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination matrix with the same size and type as src .mask - Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).mask - Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).mask - Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).mask - Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void rshift(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix. Supports 1, 3 and 4 channels images with integers elements.val - Constant values, one per channel.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void rshift(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void rshift(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void rshift(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void rshift(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void rshift(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void lshift(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix. Supports 1, 3 and 4 channels images with CV_8U , CV_16U or CV_32S
depth.val - Constant values, one per channel.dst - Destination matrix with the same size and type as src .stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void lshift(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void lshift(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void lshift(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void lshift(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void lshift(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.Scalar4i val,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void min(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).stream - Stream for the asynchronous version.
\sa min
@Namespace(value="cv::cuda")
public static void min(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void min(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void min(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void min(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void min(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void max(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source matrix or scalar.src2 - Second source matrix or scalar.dst - Destination matrix that has the same size and type as the input array(s).stream - Stream for the asynchronous version.
\sa max
@Namespace(value="cv::cuda")
public static void max(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void max(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void max(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void max(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void max(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
opencv_core.Mat src1,
double alpha,
@ByVal
opencv_core.Mat src2,
double beta,
double gamma,
@ByVal
opencv_core.Mat dst,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First source array.alpha - Weight for the first array elements.src2 - Second source array of the same size and channel number as src1 .beta - Weight for the second array elements.dst - Destination array that has the same size and number of channels as the input arrays.gamma - Scalar added to each sum.dtype - Optional depth of the destination array. When both input arrays have the same depth,
dtype can be set to -1, which will be equivalent to src1.depth().stream - Stream for the asynchronous version.
The function addWeighted calculates the weighted sum of two arrays as follows:
\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f]
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.
\sa addWeighted
@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
opencv_core.Mat src1,
double alpha,
@ByVal
opencv_core.Mat src2,
double beta,
double gamma,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
opencv_core.UMat src1,
double alpha,
@ByVal
opencv_core.UMat src2,
double beta,
double gamma,
@ByVal
opencv_core.UMat dst,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
opencv_core.UMat src1,
double alpha,
@ByVal
opencv_core.UMat src2,
double beta,
double gamma,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
opencv_core.GpuMat src1,
double alpha,
@ByVal
opencv_core.GpuMat src2,
double beta,
double gamma,
@ByVal
opencv_core.GpuMat dst,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
opencv_core.GpuMat src1,
double alpha,
@ByVal
opencv_core.GpuMat src2,
double beta,
double gamma,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
opencv_core.Mat src1,
double alpha,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
opencv_core.Mat src1,
double alpha,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
opencv_core.UMat src1,
double alpha,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
opencv_core.UMat src1,
double alpha,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
opencv_core.GpuMat src1,
double alpha,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
opencv_core.GpuMat src1,
double alpha,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static double threshold(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
double thresh,
double maxval,
int type,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source array (single-channel).dst - Destination array with the same size and type as src .thresh - Threshold value.maxval - Maximum value to use with THRESH_BINARY and THRESH_BINARY_INV threshold types.type - Threshold type. For details, see threshold . The THRESH_OTSU and THRESH_TRIANGLE
threshold types are not supported.stream - Stream for the asynchronous version.
\sa threshold
@Namespace(value="cv::cuda")
public static double threshold(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
double thresh,
double maxval,
int type)
@Namespace(value="cv::cuda")
public static double threshold(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
double thresh,
double maxval,
int type,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static double threshold(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
double thresh,
double maxval,
int type)
@Namespace(value="cv::cuda")
public static double threshold(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
double thresh,
double maxval,
int type,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static double threshold(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
double thresh,
double maxval,
int type)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.Mat xy,
@ByVal
opencv_core.Mat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
xy - Source complex matrix in the interleaved format ( CV_32FC2 ).magnitude - Destination matrix of float magnitudes ( CV_32FC1 ).stream - Stream for the asynchronous version.
\sa magnitude
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.Mat xy,
@ByVal
opencv_core.Mat magnitude)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.UMat xy,
@ByVal
opencv_core.UMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.UMat xy,
@ByVal
opencv_core.UMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.GpuMat xy,
@ByVal
opencv_core.GpuMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.GpuMat xy,
@ByVal
opencv_core.GpuMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.Mat xy,
@ByVal
opencv_core.Mat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
xy - Source complex matrix in the interleaved format ( CV_32FC2 ).magnitude - Destination matrix of float magnitude squares ( CV_32FC1 ).stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.Mat xy,
@ByVal
opencv_core.Mat magnitude)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.UMat xy,
@ByVal
opencv_core.UMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.UMat xy,
@ByVal
opencv_core.UMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.GpuMat xy,
@ByVal
opencv_core.GpuMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.GpuMat xy,
@ByVal
opencv_core.GpuMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
x - Source matrix containing real components ( CV_32FC1 ).y - Source matrix containing imaginary components ( CV_32FC1 ).magnitude - Destination matrix of float magnitudes ( CV_32FC1 ).stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat magnitude)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
x - Source matrix containing real components ( CV_32FC1 ).y - Source matrix containing imaginary components ( CV_32FC1 ).magnitude - Destination matrix of float magnitude squares ( CV_32FC1 ).stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat magnitude)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat magnitude)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat magnitude,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat magnitude)
@Namespace(value="cv::cuda")
public static void phase(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat angle,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
x - Source matrix containing real components ( CV_32FC1 ).y - Source matrix containing imaginary components ( CV_32FC1 ).angle - Destination matrix of angles ( CV_32FC1 ).angleInDegrees - Flag for angles that must be evaluated in degrees.stream - Stream for the asynchronous version.
\sa phase
@Namespace(value="cv::cuda")
public static void phase(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat angle)
@Namespace(value="cv::cuda")
public static void phase(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat angle,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void phase(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat angle)
@Namespace(value="cv::cuda")
public static void phase(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat angle,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void phase(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat angle)
@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat magnitude,
@ByVal
opencv_core.Mat angle,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
x - Source matrix containing real components ( CV_32FC1 ).y - Source matrix containing imaginary components ( CV_32FC1 ).magnitude - Destination matrix of float magnitudes ( CV_32FC1 ).angle - Destination matrix of angles ( CV_32FC1 ).angleInDegrees - Flag for angles that must be evaluated in degrees.stream - Stream for the asynchronous version.
\sa cartToPolar
@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@ByVal
opencv_core.Mat magnitude,
@ByVal
opencv_core.Mat angle)
@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat magnitude,
@ByVal
opencv_core.UMat angle,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@ByVal
opencv_core.UMat magnitude,
@ByVal
opencv_core.UMat angle)
@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat magnitude,
@ByVal
opencv_core.GpuMat angle,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@ByVal
opencv_core.GpuMat magnitude,
@ByVal
opencv_core.GpuMat angle)
@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
opencv_core.Mat magnitude,
@ByVal
opencv_core.Mat angle,
@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
magnitude - Source matrix containing magnitudes ( CV_32FC1 ).angle - Source matrix containing angles ( CV_32FC1 ).x - Destination matrix of real components ( CV_32FC1 ).y - Destination matrix of imaginary components ( CV_32FC1 ).angleInDegrees - Flag that indicates angles in degrees.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
opencv_core.Mat magnitude,
@ByVal
opencv_core.Mat angle,
@ByVal
opencv_core.Mat x,
@ByVal
opencv_core.Mat y)
@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
opencv_core.UMat magnitude,
@ByVal
opencv_core.UMat angle,
@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
opencv_core.UMat magnitude,
@ByVal
opencv_core.UMat angle,
@ByVal
opencv_core.UMat x,
@ByVal
opencv_core.UMat y)
@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
opencv_core.GpuMat magnitude,
@ByVal
opencv_core.GpuMat angle,
@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y,
@Cast(value="bool")
boolean angleInDegrees,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
opencv_core.GpuMat magnitude,
@ByVal
opencv_core.GpuMat angle,
@ByVal
opencv_core.GpuMat x,
@ByVal
opencv_core.GpuMat y)
@Namespace(value="cv::cuda")
public static void merge(@Const
opencv_core.GpuMat src,
@Cast(value="size_t")
long n,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
\addtogroup cudaarithm_core \{
/** \brief Makes a multi-channel matrix out of several single-channel matrices.
src - Array/vector of source matrices.n - Number of source matrices.dst - Destination matrix.stream - Stream for the asynchronous version.
\sa merge
@Namespace(value="cv::cuda")
public static void merge(@Const
opencv_core.GpuMat src,
@Cast(value="size_t")
long n,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void merge(@Const
opencv_core.GpuMat src,
@Cast(value="size_t")
long n,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void merge(@Const
opencv_core.GpuMat src,
@Cast(value="size_t")
long n,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void merge(@Const
opencv_core.GpuMat src,
@Cast(value="size_t")
long n,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void merge(@Const
opencv_core.GpuMat src,
@Cast(value="size_t")
long n,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
opencv_core.GpuMatVector src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
opencv_core.GpuMatVector src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
opencv_core.GpuMatVector src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
opencv_core.GpuMatVector src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
opencv_core.GpuMatVector src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
opencv_core.GpuMatVector src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.Mat src,
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix.dst - Destination array/vector of single-channel matrices.stream - Stream for the asynchronous version.
\sa split
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.Mat src,
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.UMat src,
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.UMat src,
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.GpuMat src,
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.GpuMat src,
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.Mat src,
@ByRef
opencv_core.GpuMatVector dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.Mat src,
@ByRef
opencv_core.GpuMatVector dst)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.UMat src,
@ByRef
opencv_core.GpuMatVector dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.UMat src,
@ByRef
opencv_core.GpuMatVector dst)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.GpuMat src,
@ByRef
opencv_core.GpuMatVector dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void split(@ByVal
opencv_core.GpuMat src,
@ByRef
opencv_core.GpuMatVector dst)
@Namespace(value="cv::cuda")
public static void transpose(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - Source matrix. 1-, 4-, 8-byte element sizes are supported for now.dst - Destination matrix.stream - Stream for the asynchronous version.
\sa transpose
@Namespace(value="cv::cuda")
public static void transpose(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void transpose(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void transpose(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void transpose(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void transpose(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void flip(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
int flipCode,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix. Supports 1, 3 and 4 channels images with CV_8U, CV_16U, CV_32S or
CV_32F depth.dst - Destination matrix.flipCode - Flip mode for the source:
- 0 Flips around x-axis.
- \> 0 Flips around y-axis.
- \< 0 Flips around both axes.stream - Stream for the asynchronous version.
\sa flip
@Namespace(value="cv::cuda")
public static void flip(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
int flipCode)
@Namespace(value="cv::cuda")
public static void flip(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
int flipCode,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void flip(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
int flipCode)
@Namespace(value="cv::cuda")
public static void flip(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
int flipCode,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void flip(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
int flipCode)
@Namespace(value="cv::cuda") @opencv_core.Ptr public static opencv_cudaarithm.LookUpTable createLookUpTable(@ByVal opencv_core.Mat lut)
lut - Look-up table of 256 elements. It is a continuous CV_8U matrix.@Namespace(value="cv::cuda") @opencv_core.Ptr public static opencv_cudaarithm.LookUpTable createLookUpTable(@ByVal opencv_core.UMat lut)
@Namespace(value="cv::cuda") @opencv_core.Ptr public static opencv_cudaarithm.LookUpTable createLookUpTable(@ByVal opencv_core.GpuMat lut)
@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
int top,
int bottom,
int left,
int right,
int borderType,
@ByVal(nullValue="cv::Scalar()")
opencv_core.Scalar value,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source image. CV_8UC1 , CV_8UC4 , CV_32SC1 , and CV_32FC1 types are supported.dst - Destination image with the same type as src. The size is
Size(src.cols+left+right, src.rows+top+bottom) .top - bottom - left - right - Number of pixels in each direction from the source image rectangle to extrapolate.
For example: top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs to be built.borderType - Border type. See borderInterpolate for details. BORDER_REFLECT101 ,
BORDER_REPLICATE , BORDER_CONSTANT , BORDER_REFLECT and BORDER_WRAP are supported for now.value - Border value.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
int top,
int bottom,
int left,
int right,
int borderType)
@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
int top,
int bottom,
int left,
int right,
int borderType,
@ByVal(nullValue="cv::Scalar()")
opencv_core.Scalar value,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
int top,
int bottom,
int left,
int right,
int borderType)
@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
int top,
int bottom,
int left,
int right,
int borderType,
@ByVal(nullValue="cv::Scalar()")
opencv_core.Scalar value,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
int top,
int bottom,
int left,
int right,
int borderType)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.Mat src1,
int normType,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
\addtogroup cudaarithm_reduce \{
/** \brief Returns the norm of a matrix (or difference of two matrices).
src1 - Source matrix. Any matrices except 64F are supported.normType - Norm type. NORM_L1 , NORM_L2 , and NORM_INF are supported for now.mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.
\sa norm
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.Mat src1,
int normType)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.UMat src1,
int normType,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.UMat src1,
int normType)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.GpuMat src1,
int normType,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.GpuMat src1,
int normType)
@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
int normType,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
int normType)
@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
int normType,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
int normType)
@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
int normType,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
int normType)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
int normType)
src1 - Source matrix. Any matrices except 64F are supported.src2 - Second source matrix (if any) with the same size and type as src1.normType - Norm type. NORM_L1 , NORM_L2 , and NORM_INF are supported for now.
\sa norm
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
int normType)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
int normType)
@Namespace(value="cv::cuda")
public static double norm(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2)
@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int normType,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int normType,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int normType,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sum(@ByVal opencv_core.Mat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.Mat mask)
src - Source image of any depth except for CV_64F .mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.
\sa sum
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sum(@ByVal opencv_core.Mat src)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sum(@ByVal opencv_core.UMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.UMat mask)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sum(@ByVal opencv_core.UMat src)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sum(@ByVal opencv_core.GpuMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.GpuMat mask)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sum(@ByVal opencv_core.GpuMat src)
@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar absSum(@ByVal opencv_core.Mat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.Mat mask)
src - Source image of any depth except for CV_64F .mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar absSum(@ByVal opencv_core.Mat src)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar absSum(@ByVal opencv_core.UMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.UMat mask)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar absSum(@ByVal opencv_core.UMat src)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar absSum(@ByVal opencv_core.GpuMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.GpuMat mask)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar absSum(@ByVal opencv_core.GpuMat src)
@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sqrSum(@ByVal opencv_core.Mat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.Mat mask)
src - Source image of any depth except for CV_64F .mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sqrSum(@ByVal opencv_core.Mat src)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sqrSum(@ByVal opencv_core.UMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.UMat mask)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sqrSum(@ByVal opencv_core.UMat src)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sqrSum(@ByVal opencv_core.GpuMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") opencv_core.GpuMat mask)
@Namespace(value="cv::cuda") @ByVal public static opencv_core.Scalar sqrSum(@ByVal opencv_core.GpuMat src)
@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.Mat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
src - Single-channel source image.minVal - Pointer to the returned minimum value. Use NULL if not required.maxVal - Pointer to the returned maximum value. Use NULL if not required.mask - Optional mask to select a sub-matrix.
The function does not work with CV_64F images on GPUs with the compute capability \< 1.3.
\sa minMaxLoc
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.Mat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.Mat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.Mat src,
DoubleBuffer minVal,
DoubleBuffer maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.Mat src,
double[] minVal,
double[] maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.Mat src,
double[] minVal,
double[] maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.UMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.UMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.UMat src,
double[] minVal,
double[] maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.UMat src,
double[] minVal,
double[] maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.GpuMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.GpuMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.GpuMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.GpuMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.GpuMat src,
double[] minVal,
double[] maxVal,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static void minMax(@ByVal
opencv_core.GpuMat src,
double[] minVal,
double[] maxVal)
@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.Mat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
src - Single-channel source image.minVal - Pointer to the returned minimum value. Use NULL if not required.maxVal - Pointer to the returned maximum value. Use NULL if not required.minLoc - Pointer to the returned minimum location. Use NULL if not required.maxLoc - Pointer to the returned maximum location. Use NULL if not required.mask - Optional mask to select a sub-matrix.
The function does not work with CV_64F images on GPU with the compute capability \< 1.3.
\sa minMaxLoc
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.Mat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.Mat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.Mat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.Mat src,
double[] minVal,
double[] maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.Mat src,
double[] minVal,
double[] maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.UMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.UMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.UMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.UMat src,
double[] minVal,
double[] maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.UMat src,
double[] minVal,
double[] maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.GpuMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.GpuMat src,
org.bytedeco.javacpp.DoublePointer minVal,
org.bytedeco.javacpp.DoublePointer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.GpuMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.GpuMat src,
DoubleBuffer minVal,
DoubleBuffer maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.GpuMat src,
double[] minVal,
double[] maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask)
@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
opencv_core.GpuMat src,
double[] minVal,
double[] maxVal,
opencv_core.Point minLoc,
opencv_core.Point maxLoc)
@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat minMaxVals,
@ByVal
opencv_core.Mat loc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat minMaxVals,
@ByVal
opencv_core.Mat loc)
@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat minMaxVals,
@ByVal
opencv_core.UMat loc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat minMaxVals,
@ByVal
opencv_core.UMat loc)
@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat minMaxVals,
@ByVal
opencv_core.GpuMat loc,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat minMaxVals,
@ByVal
opencv_core.GpuMat loc)
@Namespace(value="cv::cuda")
public static int countNonZero(@ByVal
opencv_core.Mat src)
src - Single-channel source image.
The function does not work with CV_64F images on GPUs with the compute capability \< 1.3.
\sa countNonZero
@Namespace(value="cv::cuda")
public static int countNonZero(@ByVal
opencv_core.UMat src)
@Namespace(value="cv::cuda")
public static int countNonZero(@ByVal
opencv_core.GpuMat src)
@Namespace(value="cv::cuda")
public static void countNonZero(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void countNonZero(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void countNonZero(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void countNonZero(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void countNonZero(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void countNonZero(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
opencv_core.Mat mtx,
@ByVal
opencv_core.Mat vec,
int dim,
int reduceOp,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
mtx - Source 2D matrix.vec - Destination vector. Its size and type is defined by dim and dtype parameters.dim - Dimension index along which the matrix is reduced. 0 means that the matrix is reduced
to a single row. 1 means that the matrix is reduced to a single column.reduceOp - Reduction operation that could be one of the following:
- **CV_REDUCE_SUM** The output is the sum of all rows/columns of the matrix.
- **CV_REDUCE_AVG** The output is the mean vector of all rows/columns of the matrix.
- **CV_REDUCE_MAX** The output is the maximum (column/row-wise) of all rows/columns of the
matrix.
- **CV_REDUCE_MIN** The output is the minimum (column/row-wise) of all rows/columns of the
matrix.dtype - When it is negative, the destination vector will have the same type as the source
matrix. Otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), mtx.channels()) .stream - Stream for the asynchronous version.
The function reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of CV_REDUCE_SUM and CV_REDUCE_AVG , the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.
\sa reduce
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
opencv_core.Mat mtx,
@ByVal
opencv_core.Mat vec,
int dim,
int reduceOp)
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
opencv_core.UMat mtx,
@ByVal
opencv_core.UMat vec,
int dim,
int reduceOp,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
opencv_core.UMat mtx,
@ByVal
opencv_core.UMat vec,
int dim,
int reduceOp)
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
opencv_core.GpuMat mtx,
@ByVal
opencv_core.GpuMat vec,
int dim,
int reduceOp,
int dtype,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
opencv_core.GpuMat mtx,
@ByVal
opencv_core.GpuMat vec,
int dim,
int reduceOp)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.Mat mtx,
@ByRef
opencv_core.Scalar mean,
@ByRef
opencv_core.Scalar stddev)
mtx - Source matrix. CV_8UC1 matrices are supported for now.mean - Mean value.stddev - Standard deviation value.
\sa meanStdDev
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.UMat mtx,
@ByRef
opencv_core.Scalar mean,
@ByRef
opencv_core.Scalar stddev)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.GpuMat mtx,
@ByRef
opencv_core.Scalar mean,
@ByRef
opencv_core.Scalar stddev)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.Mat mtx,
@ByVal
opencv_core.Mat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.Mat mtx,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.UMat mtx,
@ByVal
opencv_core.UMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.UMat mtx,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.GpuMat mtx,
@ByVal
opencv_core.GpuMat dst,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
opencv_core.GpuMat mtx,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat sqr,
@ByVal
opencv_core.Mat dst,
@ByVal
opencv_core.Rect rect,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source image. Only the CV_32SC1 type is supported.sqr - Squared source image. Only the CV_32FC1 type is supported.dst - Destination image with the same type and size as src .rect - Rectangular window.stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat sqr,
@ByVal
opencv_core.Mat dst,
@ByVal
opencv_core.Rect rect)
@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat sqr,
@ByVal
opencv_core.UMat dst,
@ByVal
opencv_core.Rect rect,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat sqr,
@ByVal
opencv_core.UMat dst,
@ByVal
opencv_core.Rect rect)
@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat sqr,
@ByVal
opencv_core.GpuMat dst,
@ByVal
opencv_core.Rect rect,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat sqr,
@ByVal
opencv_core.GpuMat dst,
@ByVal
opencv_core.Rect rect)
@Namespace(value="cv::cuda")
public static void normalize(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
double alpha,
double beta,
int norm_type,
int dtype,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.Mat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Input array.dst - Output array of the same size as src .alpha - Norm value to normalize to or the lower range boundary in case of the range
normalization.beta - Upper range boundary in case of the range normalization; it is not used for the norm
normalization.norm_type - Normalization type ( NORM_MINMAX , NORM_L2 , NORM_L1 or NORM_INF ).dtype - When negative, the output array has the same type as src; otherwise, it has the same
number of channels as src and the depth =CV_MAT_DEPTH(dtype).mask - Optional operation mask.stream - Stream for the asynchronous version.
\sa normalize
@Namespace(value="cv::cuda")
public static void normalize(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
double alpha,
double beta,
int norm_type,
int dtype)
@Namespace(value="cv::cuda")
public static void normalize(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
double alpha,
double beta,
int norm_type,
int dtype,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.UMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void normalize(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
double alpha,
double beta,
int norm_type,
int dtype)
@Namespace(value="cv::cuda")
public static void normalize(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
double alpha,
double beta,
int norm_type,
int dtype,
@ByVal(nullValue="cv::InputArray(cv::noArray())")
opencv_core.GpuMat mask,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void normalize(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
double alpha,
double beta,
int norm_type,
int dtype)
@Namespace(value="cv::cuda")
public static void integral(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat sum,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source image. Only CV_8UC1 images are supported for now.sum - Integral image containing 32-bit unsigned integer values packed into CV_32SC1 .stream - Stream for the asynchronous version.
\sa integral
@Namespace(value="cv::cuda")
public static void integral(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat sum)
@Namespace(value="cv::cuda")
public static void integral(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat sum,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void integral(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat sum)
@Namespace(value="cv::cuda")
public static void integral(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat sum,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void integral(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat sum)
@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat sqsum,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source image. Only CV_8UC1 images are supported for now.sqsum - Squared integral image containing 64-bit unsigned integer values packed into
CV_64FC1 .stream - Stream for the asynchronous version.@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat sqsum)
@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat sqsum,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat sqsum)
@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat sqsum,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat sqsum)
@Namespace(value="cv::cuda")
public static void gemm(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
double alpha,
@ByVal
opencv_core.Mat src3,
double beta,
@ByVal
opencv_core.Mat dst,
int flags,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
\addtogroup cudaarithm_arithm \{
/** \brief Performs generalized matrix multiplication.
src1 - First multiplied input matrix that should have CV_32FC1 , CV_64FC1 , CV_32FC2 , or
CV_64FC2 type.src2 - Second multiplied input matrix of the same type as src1 .alpha - Weight of the matrix product.src3 - Third optional delta matrix added to the matrix product. It should have the same type
as src1 and src2 .beta - Weight of src3 .dst - Destination matrix. It has the proper size and the same type as input matrices.flags - Operation flags:
- **GEMM_1_T** transpose src1
- **GEMM_2_T** transpose src2
- **GEMM_3_T** transpose src3stream - Stream for the asynchronous version.
The function performs generalized matrix multiplication similar to the gemm functions in BLAS level 3. For example, gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) corresponds to
\f[\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\f]
\note Transposition operation doesn't support CV_64FC2 input type.
\sa gemm
@Namespace(value="cv::cuda")
public static void gemm(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
double alpha,
@ByVal
opencv_core.Mat src3,
double beta,
@ByVal
opencv_core.Mat dst)
@Namespace(value="cv::cuda")
public static void gemm(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
double alpha,
@ByVal
opencv_core.UMat src3,
double beta,
@ByVal
opencv_core.UMat dst,
int flags,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void gemm(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
double alpha,
@ByVal
opencv_core.UMat src3,
double beta,
@ByVal
opencv_core.UMat dst)
@Namespace(value="cv::cuda")
public static void gemm(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
double alpha,
@ByVal
opencv_core.GpuMat src3,
double beta,
@ByVal
opencv_core.GpuMat dst,
int flags,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void gemm(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
double alpha,
@ByVal
opencv_core.GpuMat src3,
double beta,
@ByVal
opencv_core.GpuMat dst)
@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int flags,
@Cast(value="bool")
boolean conjB,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First spectrum.src2 - Second spectrum with the same size and type as a .dst - Destination spectrum.flags - Mock parameter used for CPU/CUDA interfaces similarity.conjB - Optional flag to specify if the second spectrum needs to be conjugated before the
multiplication.stream - Stream for the asynchronous version.
Only full (not packed) CV_32FC2 complex spectrums in the interleaved format are supported for now.
\sa mulSpectrums
@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int flags)
@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int flags,
@Cast(value="bool")
boolean conjB,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int flags)
@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int flags,
@Cast(value="bool")
boolean conjB,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int flags)
@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int flags,
float scale,
@Cast(value="bool")
boolean conjB,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src1 - First spectrum.src2 - Second spectrum with the same size and type as a .dst - Destination spectrum.flags - Mock parameter used for CPU/CUDA interfaces similarity, simply add a 0 value.scale - Scale constant.conjB - Optional flag to specify if the second spectrum needs to be conjugated before the
multiplication.stream - Stream for the asynchronous version.
Only full (not packed) CV_32FC2 complex spectrums in the interleaved format are supported for now.
\sa mulSpectrums
@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
opencv_core.Mat src1,
@ByVal
opencv_core.Mat src2,
@ByVal
opencv_core.Mat dst,
int flags,
float scale)
@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int flags,
float scale,
@Cast(value="bool")
boolean conjB,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
opencv_core.UMat src1,
@ByVal
opencv_core.UMat src2,
@ByVal
opencv_core.UMat dst,
int flags,
float scale)
@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int flags,
float scale,
@Cast(value="bool")
boolean conjB,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
opencv_core.GpuMat src1,
@ByVal
opencv_core.GpuMat src2,
@ByVal
opencv_core.GpuMat dst,
int flags,
float scale)
@Namespace(value="cv::cuda")
public static void dft(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal
opencv_core.Size dft_size,
int flags,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
src - Source matrix (real or complex).dst - Destination matrix (real or complex).dft_size - Size of a discrete Fourier transform.flags - Optional flags:
- **DFT_ROWS** transforms each individual row of the source matrix.
- **DFT_SCALE** scales the result: divide it by the number of elements in the transform
(obtained from dft_size ).
- **DFT_INVERSE** inverts DFT. Use for complex-complex cases (real-complex and complex-real
cases are always forward and inverse, respectively).
- **DFT_COMPLEX_INPUT** Specifies that input is complex input with 2 channels.
- **DFT_REAL_OUTPUT** specifies the output as real. The source matrix is the result of
real-complex transform, so the destination matrix must be real.stream - Stream for the asynchronous version.
Use to handle real matrices ( CV32FC1 ) and complex matrices in the interleaved format ( CV32FC2 ).
The source matrix should be continuous, otherwise reallocation and data copying is performed. The function chooses an operation mode depending on the flags, size, and channel count of the source matrix:
- If the source matrix is complex and the output is not specified as real, the destination matrix is complex and has the dft_size size and CV_32FC2 type. The destination matrix contains a full result of the DFT (forward or inverse). - If the source matrix is complex and the output is specified as real, the function assumes that its input is the result of the forward transform (see the next item). The destination matrix has the dft_size size and CV_32FC1 type. It contains the result of the inverse DFT. - If the source matrix is real (its type is CV_32FC1 ), forward DFT is performed. The result of the DFT is packed into complex ( CV_32FC2 ) matrix. So, the width of the destination matrix is dft_size.width / 2 + 1 . But if the source is a single column, the height is reduced instead of the width.
\sa dft
@Namespace(value="cv::cuda")
public static void dft(@ByVal
opencv_core.Mat src,
@ByVal
opencv_core.Mat dst,
@ByVal
opencv_core.Size dft_size)
@Namespace(value="cv::cuda")
public static void dft(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal
opencv_core.Size dft_size,
int flags,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void dft(@ByVal
opencv_core.UMat src,
@ByVal
opencv_core.UMat dst,
@ByVal
opencv_core.Size dft_size)
@Namespace(value="cv::cuda")
public static void dft(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal
opencv_core.Size dft_size,
int flags,
@ByRef(nullValue="cv::cuda::Stream::Null()")
opencv_core.Stream stream)
@Namespace(value="cv::cuda")
public static void dft(@ByVal
opencv_core.GpuMat src,
@ByVal
opencv_core.GpuMat dst,
@ByVal
opencv_core.Size dft_size)
@Namespace(value="cv::cuda") @opencv_core.Ptr public static opencv_cudaarithm.DFT createDFT(@ByVal opencv_core.Size dft_size, int flags)
dft_size - The image size.flags - Optional flags:
- **DFT_ROWS** transforms each individual row of the source matrix.
- **DFT_SCALE** scales the result: divide it by the number of elements in the transform
(obtained from dft_size ).
- **DFT_INVERSE** inverts DFT. Use for complex-complex cases (real-complex and complex-real
cases are always forward and inverse, respectively).
- **DFT_COMPLEX_INPUT** Specifies that inputs will be complex with 2 channels.
- **DFT_REAL_OUTPUT** specifies the output as real. The source matrix is the result of
real-complex transform, so the destination matrix must be real.@Namespace(value="cv::cuda") @opencv_core.Ptr public static opencv_cudaarithm.Convolution createConvolution(@ByVal(nullValue="cv::Size()") opencv_core.Size user_block_size)
user_block_size - Block size. If you leave default value Size(0,0) then automatic
estimation of block size will be used (which is optimized for speed). By varying user_block_size
you can reduce memory requirements at the cost of speed.@Namespace(value="cv::cuda") @opencv_core.Ptr public static opencv_cudaarithm.Convolution createConvolution()
Copyright © 2018. All rights reserved.