opencv_cudaarithm (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_cudaarithm
- - org.bytedeco.opencv.global.opencv_cudaarithm

All Implemented Interfaces:: InfoMapper

public class opencv_cudaarithm
extends opencv_cudaarithm

Constructor Summary

Constructors
Constructor and Description

opencv_cudaarithm()

Constructors
Constructor and Description
`opencv_cudaarithm()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`abs(GpuMat src, GpuMat dst)`
`static void`	`abs(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`abs(Mat src, Mat dst)`
`static void`	`abs(Mat src, Mat dst, Stream stream)` \brief Computes an absolute value of each matrix element.
`static void`	`abs(UMat src, UMat dst)`
`static void`	`abs(UMat src, UMat dst, Stream stream)`
`static void`	`absdiff(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`absdiff(GpuMat src1, GpuMat src2, GpuMat dst, Stream stream)`
`static void`	`absdiff(Mat src1, Mat src2, Mat dst)`
`static void`	`absdiff(Mat src1, Mat src2, Mat dst, Stream stream)` \brief Computes per-element absolute difference of two matrices (or of a matrix and scalar).
`static void`	`absdiff(UMat src1, UMat src2, UMat dst)`
`static void`	`absdiff(UMat src1, UMat src2, UMat dst, Stream stream)`
`static Scalar`	`absSum(GpuMat src)`
`static Scalar`	`absSum(GpuMat src, GpuMat mask)`
`static Scalar`	`absSum(Mat src)`
`static Scalar`	`absSum(Mat src, Mat mask)` \brief Returns the sum of absolute values for matrix elements.
`static Scalar`	`absSum(UMat src)`
`static Scalar`	`absSum(UMat src, UMat mask)`
`static void`	`add(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`add(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, int dtype, Stream stream)`
`static void`	`add(Mat src1, Mat src2, Mat dst)`
`static void`	`add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype, Stream stream)` \addtogroup cudaarithm \{
`static void`	`add(UMat src1, UMat src2, UMat dst)`
`static void`	`add(UMat src1, UMat src2, UMat dst, UMat mask, int dtype, Stream stream)`
`static void`	`addWeighted(GpuMat src1, double alpha, GpuMat src2, double beta, double gamma, GpuMat dst)`
`static void`	`addWeighted(GpuMat src1, double alpha, GpuMat src2, double beta, double gamma, GpuMat dst, int dtype, Stream stream)`
`static void`	`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)`
`static void`	`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype, Stream stream)` \brief Computes the weighted sum of two arrays.
`static void`	`addWeighted(UMat src1, double alpha, UMat src2, double beta, double gamma, UMat dst)`
`static void`	`addWeighted(UMat src1, double alpha, UMat src2, double beta, double gamma, UMat dst, int dtype, Stream stream)`
`static void`	`bitwise_and(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`bitwise_and(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`bitwise_and(Mat src1, Mat src2, Mat dst)`
`static void`	`bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise conjunction of two matrices (or of matrix and scalar).
`static void`	`bitwise_and(UMat src1, UMat src2, UMat dst)`
`static void`	`bitwise_and(UMat src1, UMat src2, UMat dst, UMat mask, Stream stream)`
`static void`	`bitwise_not(GpuMat src, GpuMat dst)`
`static void`	`bitwise_not(GpuMat src, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`bitwise_not(Mat src, Mat dst)`
`static void`	`bitwise_not(Mat src, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise inversion.
`static void`	`bitwise_not(UMat src, UMat dst)`
`static void`	`bitwise_not(UMat src, UMat dst, UMat mask, Stream stream)`
`static void`	`bitwise_or(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`bitwise_or(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`bitwise_or(Mat src1, Mat src2, Mat dst)`
`static void`	`bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise disjunction of two matrices (or of matrix and scalar).
`static void`	`bitwise_or(UMat src1, UMat src2, UMat dst)`
`static void`	`bitwise_or(UMat src1, UMat src2, UMat dst, UMat mask, Stream stream)`
`static void`	`bitwise_xor(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`bitwise_xor(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`bitwise_xor(Mat src1, Mat src2, Mat dst)`
`static void`	`bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask, Stream stream)` \brief Performs a per-element bitwise exclusive or operation of two matrices (or of matrix and scalar).
`static void`	`bitwise_xor(UMat src1, UMat src2, UMat dst)`
`static void`	`bitwise_xor(UMat src1, UMat src2, UMat dst, UMat mask, Stream stream)`
`static void`	`calcAbsSum(GpuMat src, GpuMat dst)`
`static void`	`calcAbsSum(GpuMat src, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`calcAbsSum(Mat src, Mat dst)`
`static void`	`calcAbsSum(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	`calcAbsSum(UMat src, UMat dst)`
`static void`	`calcAbsSum(UMat src, UMat dst, UMat mask, Stream stream)`
`static void`	`calcNorm(GpuMat src, GpuMat dst, int normType)`
`static void`	`calcNorm(GpuMat src, GpuMat dst, int normType, GpuMat mask, Stream stream)`
`static void`	`calcNorm(Mat src, Mat dst, int normType)`
`static void`	`calcNorm(Mat src, Mat dst, int normType, Mat mask, Stream stream)` \overload
`static void`	`calcNorm(UMat src, UMat dst, int normType)`
`static void`	`calcNorm(UMat src, UMat dst, int normType, UMat mask, Stream stream)`
`static void`	`calcNormDiff(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`calcNormDiff(GpuMat src1, GpuMat src2, GpuMat dst, int normType, Stream stream)`
`static void`	`calcNormDiff(Mat src1, Mat src2, Mat dst)`
`static void`	`calcNormDiff(Mat src1, Mat src2, Mat dst, int normType, Stream stream)` \overload
`static void`	`calcNormDiff(UMat src1, UMat src2, UMat dst)`
`static void`	`calcNormDiff(UMat src1, UMat src2, UMat dst, int normType, Stream stream)`
`static void`	`calcSqrSum(GpuMat src, GpuMat dst)`
`static void`	`calcSqrSum(GpuMat src, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`calcSqrSum(Mat src, Mat dst)`
`static void`	`calcSqrSum(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	`calcSqrSum(UMat src, UMat dst)`
`static void`	`calcSqrSum(UMat src, UMat dst, UMat mask, Stream stream)`
`static void`	`calcSum(GpuMat src, GpuMat dst)`
`static void`	`calcSum(GpuMat src, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`calcSum(Mat src, Mat dst)`
`static void`	`calcSum(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	`calcSum(UMat src, UMat dst)`
`static void`	`calcSum(UMat src, UMat dst, UMat mask, Stream stream)`
`static void`	`cartToPolar(GpuMat x, GpuMat y, GpuMat magnitude, GpuMat angle)`
`static void`	`cartToPolar(GpuMat x, GpuMat y, GpuMat magnitude, GpuMat angle, boolean angleInDegrees, Stream stream)`
`static void`	`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)`
`static void`	`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees, Stream stream)` \brief Converts Cartesian coordinates into polar.
`static void`	`cartToPolar(UMat x, UMat y, UMat magnitude, UMat angle)`
`static void`	`cartToPolar(UMat x, UMat y, UMat magnitude, UMat angle, boolean angleInDegrees, Stream stream)`
`static void`	`compare(GpuMat src1, GpuMat src2, GpuMat dst, int cmpop)`
`static void`	`compare(GpuMat src1, GpuMat src2, GpuMat dst, int cmpop, Stream stream)`
`static void`	`compare(Mat src1, Mat src2, Mat dst, int cmpop)`
`static void`	`compare(Mat src1, Mat src2, Mat dst, int cmpop, Stream stream)` \brief Compares elements of two matrices (or of a matrix and scalar).
`static void`	`compare(UMat src1, UMat src2, UMat dst, int cmpop)`
`static void`	`compare(UMat src1, UMat src2, UMat dst, int cmpop, Stream stream)`
`static void`	`copyMakeBorder(GpuMat src, GpuMat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(GpuMat src, GpuMat dst, int top, int bottom, int left, int right, int borderType, Scalar value, Stream stream)`
`static void`	`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value, Stream stream)` \brief Forms a border around an image.
`static void`	`copyMakeBorder(UMat src, UMat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(UMat src, UMat dst, int top, int bottom, int left, int right, int borderType, Scalar value, Stream stream)`
`static int`	`countNonZero(GpuMat src)`
`static void`	`countNonZero(GpuMat src, GpuMat dst)`
`static void`	`countNonZero(GpuMat src, GpuMat dst, Stream stream)`
`static int`	`countNonZero(Mat src)` \brief Counts non-zero matrix elements.
`static void`	`countNonZero(Mat src, Mat dst)`
`static void`	`countNonZero(Mat src, Mat dst, Stream stream)` \overload
`static int`	`countNonZero(UMat src)`
`static void`	`countNonZero(UMat src, UMat dst)`
`static void`	`countNonZero(UMat src, UMat dst, Stream stream)`
`static Convolution`	`createConvolution()`
`static Convolution`	`createConvolution(Size user_block_size)` \brief Creates implementation for cuda::Convolution .
`static DFT`	`createDFT(Size dft_size, int flags)` \brief Creates implementation for cuda::DFT.
`static LookUpTable`	`createLookUpTable(GpuMat lut)`
`static LookUpTable`	`createLookUpTable(Mat lut)` \brief Creates implementation for cuda::LookUpTable .
`static LookUpTable`	`createLookUpTable(UMat lut)`
`static void`	`dft(GpuMat src, GpuMat dst, Size dft_size)`
`static void`	`dft(GpuMat src, GpuMat dst, Size dft_size, int flags, Stream stream)`
`static void`	`dft(Mat src, Mat dst, Size dft_size)`
`static void`	`dft(Mat src, Mat dst, Size dft_size, int flags, Stream stream)` \brief Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
`static void`	`dft(UMat src, UMat dst, Size dft_size)`
`static void`	`dft(UMat src, UMat dst, Size dft_size, int flags, Stream stream)`
`static void`	`divide(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`divide(GpuMat src1, GpuMat src2, GpuMat dst, double scale, int dtype, Stream stream)`
`static void`	`divide(Mat src1, Mat src2, Mat dst)`
`static void`	`divide(Mat src1, Mat src2, Mat dst, double scale, int dtype, Stream stream)` \brief Computes a matrix-matrix or matrix-scalar division.
`static void`	`divide(UMat src1, UMat src2, UMat dst)`
`static void`	`divide(UMat src1, UMat src2, UMat dst, double scale, int dtype, Stream stream)`
`static void`	`exp(GpuMat src, GpuMat dst)`
`static void`	`exp(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`exp(Mat src, Mat dst)`
`static void`	`exp(Mat src, Mat dst, Stream stream)` \brief Computes an exponent of each matrix element.
`static void`	`exp(UMat src, UMat dst)`
`static void`	`exp(UMat src, UMat dst, Stream stream)`
`static void`	`findMinMax(GpuMat src, GpuMat dst)`
`static void`	`findMinMax(GpuMat src, GpuMat dst, GpuMat mask, Stream stream)`
`static void`	`findMinMax(Mat src, Mat dst)`
`static void`	`findMinMax(Mat src, Mat dst, Mat mask, Stream stream)` \overload
`static void`	`findMinMax(UMat src, UMat dst)`
`static void`	`findMinMax(UMat src, UMat dst, UMat mask, Stream stream)`
`static void`	`findMinMaxLoc(GpuMat src, GpuMat minMaxVals, GpuMat loc)`
`static void`	`findMinMaxLoc(GpuMat src, GpuMat minMaxVals, GpuMat loc, GpuMat mask, Stream stream)`
`static void`	`findMinMaxLoc(Mat src, Mat minMaxVals, Mat loc)`
`static void`	`findMinMaxLoc(Mat src, Mat minMaxVals, Mat loc, Mat mask, Stream stream)` \overload
`static void`	`findMinMaxLoc(UMat src, UMat minMaxVals, UMat loc)`
`static void`	`findMinMaxLoc(UMat src, UMat minMaxVals, UMat loc, UMat mask, Stream stream)`
`static void`	`flip(GpuMat src, GpuMat dst, int flipCode)`
`static void`	`flip(GpuMat src, GpuMat dst, int flipCode, Stream stream)`
`static void`	`flip(Mat src, Mat dst, int flipCode)`
`static void`	`flip(Mat src, Mat dst, int flipCode, Stream stream)` \brief Flips a 2D matrix around vertical, horizontal, or both axes.
`static void`	`flip(UMat src, UMat dst, int flipCode)`
`static void`	`flip(UMat src, UMat dst, int flipCode, Stream stream)`
`static void`	`gemm(GpuMat src1, GpuMat src2, double alpha, GpuMat src3, double beta, GpuMat dst)`
`static void`	`gemm(GpuMat src1, GpuMat src2, double alpha, GpuMat src3, double beta, GpuMat dst, int flags, Stream stream)`
`static void`	`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)`
`static void`	`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags, Stream stream)` \} cudaarithm_reduce
`static void`	`gemm(UMat src1, UMat src2, double alpha, UMat src3, double beta, UMat dst)`
`static void`	`gemm(UMat src1, UMat src2, double alpha, UMat src3, double beta, UMat dst, int flags, Stream stream)`
`static void`	`integral(GpuMat src, GpuMat sum)`
`static void`	`integral(GpuMat src, GpuMat sum, Stream stream)`
`static void`	`integral(Mat src, Mat sum)`
`static void`	`integral(Mat src, Mat sum, Stream stream)` \brief Computes an integral image.
`static void`	`integral(UMat src, UMat sum)`
`static void`	`integral(UMat src, UMat sum, Stream stream)`
`static void`	`log(GpuMat src, GpuMat dst)`
`static void`	`log(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`log(Mat src, Mat dst)`
`static void`	`log(Mat src, Mat dst, Stream stream)` \brief Computes a natural logarithm of absolute value of each matrix element.
`static void`	`log(UMat src, UMat dst)`
`static void`	`log(UMat src, UMat dst, Stream stream)`
`static void`	`lshift(GpuMat src, Scalar4i val, GpuMat dst)`
`static void`	`lshift(GpuMat src, Scalar4i val, GpuMat dst, Stream stream)`
`static void`	`lshift(GpuMat src, Scalar val, GpuMat dst)`
`static void`	`lshift(GpuMat src, Scalar val, GpuMat dst, Stream stream)`
`static void`	`lshift(Mat src, Scalar4i val, Mat dst)`
`static void`	`lshift(Mat src, Scalar4i val, Mat dst, Stream stream)` \brief Performs pixel by pixel right left of an image by a constant value.
`static void`	`lshift(Mat src, Scalar val, Mat dst)`
`static void`	`lshift(Mat src, Scalar val, Mat dst, Stream stream)`
`static void`	`lshift(UMat src, Scalar4i val, UMat dst)`
`static void`	`lshift(UMat src, Scalar4i val, UMat dst, Stream stream)`
`static void`	`lshift(UMat src, Scalar val, UMat dst)`
`static void`	`lshift(UMat src, Scalar val, UMat dst, Stream stream)`
`static void`	`magnitude(GpuMat xy, GpuMat magnitude)`
`static void`	`magnitude(GpuMat x, GpuMat y, GpuMat magnitude)`
`static void`	`magnitude(GpuMat x, GpuMat y, GpuMat magnitude, Stream stream)`
`static void`	`magnitude(GpuMat xy, GpuMat magnitude, Stream stream)`
`static void`	`magnitude(Mat xy, Mat magnitude)`
`static void`	`magnitude(Mat x, Mat y, Mat magnitude)`
`static void`	`magnitude(Mat x, Mat y, Mat magnitude, Stream stream)` \overload computes magnitude of each (x(i), y(i)) vector supports only floating-point source
`static void`	`magnitude(Mat xy, Mat magnitude, Stream stream)` \brief Computes magnitudes of complex matrix elements.
`static void`	`magnitude(UMat xy, UMat magnitude)`
`static void`	`magnitude(UMat xy, UMat magnitude, Stream stream)`
`static void`	`magnitude(UMat x, UMat y, UMat magnitude)`
`static void`	`magnitude(UMat x, UMat y, UMat magnitude, Stream stream)`
`static void`	`magnitudeSqr(GpuMat xy, GpuMat magnitude)`
`static void`	`magnitudeSqr(GpuMat x, GpuMat y, GpuMat magnitude)`
`static void`	`magnitudeSqr(GpuMat x, GpuMat y, GpuMat magnitude, Stream stream)`
`static void`	`magnitudeSqr(GpuMat xy, GpuMat magnitude, Stream stream)`
`static void`	`magnitudeSqr(Mat xy, Mat magnitude)`
`static void`	`magnitudeSqr(Mat x, Mat y, Mat magnitude)`
`static void`	`magnitudeSqr(Mat x, Mat y, Mat magnitude, Stream stream)` \overload computes squared magnitude of each (x(i), y(i)) vector supports only floating-point source
`static void`	`magnitudeSqr(Mat xy, Mat magnitude, Stream stream)` \brief Computes squared magnitudes of complex matrix elements.
`static void`	`magnitudeSqr(UMat xy, UMat magnitude)`
`static void`	`magnitudeSqr(UMat xy, UMat magnitude, Stream stream)`
`static void`	`magnitudeSqr(UMat x, UMat y, UMat magnitude)`
`static void`	`magnitudeSqr(UMat x, UMat y, UMat magnitude, Stream stream)`
`static void`	`max(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`max(GpuMat src1, GpuMat src2, GpuMat dst, Stream stream)`
`static void`	`max(Mat src1, Mat src2, Mat dst)`
`static void`	`max(Mat src1, Mat src2, Mat dst, Stream stream)` \brief Computes the per-element maximum of two matrices (or a matrix and a scalar).
`static void`	`max(UMat src1, UMat src2, UMat dst)`
`static void`	`max(UMat src1, UMat src2, UMat dst, Stream stream)`
`static void`	`meanStdDev(GpuMat mtx, GpuMat dst)`
`static void`	`meanStdDev(GpuMat mtx, GpuMat dst, Stream stream)`
`static void`	`meanStdDev(GpuMat mtx, Scalar mean, Scalar stddev)`
`static void`	`meanStdDev(Mat mtx, Mat dst)`
`static void`	`meanStdDev(Mat mtx, Mat dst, Stream stream)` \overload
`static void`	`meanStdDev(Mat mtx, Scalar mean, Scalar stddev)` \brief Computes a mean value and a standard deviation of matrix elements.
`static void`	`meanStdDev(UMat mtx, Scalar mean, Scalar stddev)`
`static void`	`meanStdDev(UMat mtx, UMat dst)`
`static void`	`meanStdDev(UMat mtx, UMat dst, Stream stream)`
`static void`	`merge(GpuMat src, long n, GpuMat dst)`
`static void`	`merge(GpuMat src, long n, GpuMat dst, Stream stream)`
`static void`	`merge(GpuMat src, long n, Mat dst)`
`static void`	`merge(GpuMat src, long n, Mat dst, Stream stream)` \} cudaarithm_elem
`static void`	`merge(GpuMat src, long n, UMat dst)`
`static void`	`merge(GpuMat src, long n, UMat dst, Stream stream)`
`static void`	`merge(GpuMatVector src, GpuMat dst)`
`static void`	`merge(GpuMatVector src, GpuMat dst, Stream stream)`
`static void`	`merge(GpuMatVector src, Mat dst)`
`static void`	`merge(GpuMatVector src, Mat dst, Stream stream)` \overload
`static void`	`merge(GpuMatVector src, UMat dst)`
`static void`	`merge(GpuMatVector src, UMat dst, Stream stream)`
`static void`	`min(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`min(GpuMat src1, GpuMat src2, GpuMat dst, Stream stream)`
`static void`	`min(Mat src1, Mat src2, Mat dst)`
`static void`	`min(Mat src1, Mat src2, Mat dst, Stream stream)` \brief Computes the per-element minimum of two matrices (or a matrix and a scalar).
`static void`	`min(UMat src1, UMat src2, UMat dst)`
`static void`	`min(UMat src1, UMat src2, UMat dst, Stream stream)`
`static void`	`minMax(GpuMat src, double[] minVal, double[] maxVal)`
`static void`	`minMax(GpuMat src, double[] minVal, double[] maxVal, GpuMat mask)`
`static void`	`minMax(GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	`minMax(GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, GpuMat mask)`
`static void`	`minMax(GpuMat src, DoublePointer minVal, DoublePointer maxVal)`
`static void`	`minMax(GpuMat src, DoublePointer minVal, DoublePointer maxVal, GpuMat mask)`
`static void`	`minMax(Mat src, double[] minVal, double[] maxVal)`
`static void`	`minMax(Mat src, double[] minVal, double[] maxVal, Mat mask)`
`static void`	`minMax(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	`minMax(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Mat mask)`
`static void`	`minMax(Mat src, DoublePointer minVal, DoublePointer maxVal)`
`static void`	`minMax(Mat src, DoublePointer minVal, DoublePointer maxVal, Mat mask)` \brief Finds global minimum and maximum matrix elements and returns their values.
`static void`	`minMax(UMat src, double[] minVal, double[] maxVal)`
`static void`	`minMax(UMat src, double[] minVal, double[] maxVal, UMat mask)`
`static void`	`minMax(UMat src, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	`minMax(UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, UMat mask)`
`static void`	`minMax(UMat src, DoublePointer minVal, DoublePointer maxVal)`
`static void`	`minMax(UMat src, DoublePointer minVal, DoublePointer maxVal, UMat mask)`
`static void`	`minMaxLoc(GpuMat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(GpuMat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, GpuMat mask)`
`static void`	`minMaxLoc(GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, GpuMat mask)`
`static void`	`minMaxLoc(GpuMat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(GpuMat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, GpuMat mask)`
`static void`	`minMaxLoc(Mat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(Mat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	`minMaxLoc(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	`minMaxLoc(Mat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(Mat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, Mat mask)` \brief Finds global minimum and maximum matrix elements and returns their values with locations.
`static void`	`minMaxLoc(UMat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(UMat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, UMat mask)`
`static void`	`minMaxLoc(UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, UMat mask)`
`static void`	`minMaxLoc(UMat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc)`
`static void`	`minMaxLoc(UMat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, UMat mask)`
`static void`	`mulAndScaleSpectrums(GpuMat src1, GpuMat src2, GpuMat dst, int flags, float scale)`
`static void`	`mulAndScaleSpectrums(GpuMat src1, GpuMat src2, GpuMat dst, int flags, float scale, boolean conjB, Stream stream)`
`static void`	`mulAndScaleSpectrums(Mat src1, Mat src2, Mat dst, int flags, float scale)`
`static void`	`mulAndScaleSpectrums(Mat src1, Mat src2, Mat dst, int flags, float scale, boolean conjB, Stream stream)` \brief Performs a per-element multiplication of two Fourier spectrums and scales the result.
`static void`	`mulAndScaleSpectrums(UMat src1, UMat src2, UMat dst, int flags, float scale)`
`static void`	`mulAndScaleSpectrums(UMat src1, UMat src2, UMat dst, int flags, float scale, boolean conjB, Stream stream)`
`static void`	`mulSpectrums(GpuMat src1, GpuMat src2, GpuMat dst, int flags)`
`static void`	`mulSpectrums(GpuMat src1, GpuMat src2, GpuMat dst, int flags, boolean conjB, Stream stream)`
`static void`	`mulSpectrums(Mat src1, Mat src2, Mat dst, int flags)`
`static void`	`mulSpectrums(Mat src1, Mat src2, Mat dst, int flags, boolean conjB, Stream stream)` \brief Performs a per-element multiplication of two Fourier spectrums.
`static void`	`mulSpectrums(UMat src1, UMat src2, UMat dst, int flags)`
`static void`	`mulSpectrums(UMat src1, UMat src2, UMat dst, int flags, boolean conjB, Stream stream)`
`static void`	`multiply(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`multiply(GpuMat src1, GpuMat src2, GpuMat dst, double scale, int dtype, Stream stream)`
`static void`	`multiply(Mat src1, Mat src2, Mat dst)`
`static void`	`multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype, Stream stream)` \brief Computes a matrix-matrix or matrix-scalar per-element product.
`static void`	`multiply(UMat src1, UMat src2, UMat dst)`
`static void`	`multiply(UMat src1, UMat src2, UMat dst, double scale, int dtype, Stream stream)`
`static double`	`norm(GpuMat src1, GpuMat src2)`
`static double`	`norm(GpuMat src1, GpuMat src2, int normType)`
`static double`	`norm(GpuMat src1, int normType)`
`static double`	`norm(GpuMat src1, int normType, GpuMat mask)`
`static double`	`norm(Mat src1, int normType)`
`static double`	`norm(Mat src1, int normType, Mat mask)` \} cudaarithm_core
`static double`	`norm(Mat src1, Mat src2)`
`static double`	`norm(Mat src1, Mat src2, int normType)` \brief Returns the difference of two matrices.
`static double`	`norm(UMat src1, int normType)`
`static double`	`norm(UMat src1, int normType, UMat mask)`
`static double`	`norm(UMat src1, UMat src2)`
`static double`	`norm(UMat src1, UMat src2, int normType)`
`static void`	`normalize(GpuMat src, GpuMat dst, double alpha, double beta, int norm_type, int dtype)`
`static void`	`normalize(GpuMat src, GpuMat dst, double alpha, double beta, int norm_type, int dtype, GpuMat mask, Stream stream)`
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)`
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask, Stream stream)` \brief Normalizes the norm or value range of an array.
`static void`	`normalize(UMat src, UMat dst, double alpha, double beta, int norm_type, int dtype)`
`static void`	`normalize(UMat src, UMat dst, double alpha, double beta, int norm_type, int dtype, UMat mask, Stream stream)`
`static void`	`phase(GpuMat x, GpuMat y, GpuMat angle)`
`static void`	`phase(GpuMat x, GpuMat y, GpuMat angle, boolean angleInDegrees, Stream stream)`
`static void`	`phase(Mat x, Mat y, Mat angle)`
`static void`	`phase(Mat x, Mat y, Mat angle, boolean angleInDegrees, Stream stream)` \brief Computes polar angles of complex matrix elements.
`static void`	`phase(UMat x, UMat y, UMat angle)`
`static void`	`phase(UMat x, UMat y, UMat angle, boolean angleInDegrees, Stream stream)`
`static void`	`polarToCart(GpuMat magnitude, GpuMat angle, GpuMat x, GpuMat y)`
`static void`	`polarToCart(GpuMat magnitude, GpuMat angle, GpuMat x, GpuMat y, boolean angleInDegrees, Stream stream)`
`static void`	`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)`
`static void`	`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees, Stream stream)` \brief Converts polar coordinates into Cartesian.
`static void`	`polarToCart(UMat magnitude, UMat angle, UMat x, UMat y)`
`static void`	`polarToCart(UMat magnitude, UMat angle, UMat x, UMat y, boolean angleInDegrees, Stream stream)`
`static void`	`pow(GpuMat src, double power, GpuMat dst)`
`static void`	`pow(GpuMat src, double power, GpuMat dst, Stream stream)`
`static void`	`pow(Mat src, double power, Mat dst)`
`static void`	`pow(Mat src, double power, Mat dst, Stream stream)` \brief Raises every matrix element to a power.
`static void`	`pow(UMat src, double power, UMat dst)`
`static void`	`pow(UMat src, double power, UMat dst, Stream stream)`
`static void`	`rectStdDev(GpuMat src, GpuMat sqr, GpuMat dst, Rect rect)`
`static void`	`rectStdDev(GpuMat src, GpuMat sqr, GpuMat dst, Rect rect, Stream stream)`
`static void`	`rectStdDev(Mat src, Mat sqr, Mat dst, Rect rect)`
`static void`	`rectStdDev(Mat src, Mat sqr, Mat dst, Rect rect, Stream stream)` \brief Computes a standard deviation of integral images.
`static void`	`rectStdDev(UMat src, UMat sqr, UMat dst, Rect rect)`
`static void`	`rectStdDev(UMat src, UMat sqr, UMat dst, Rect rect, Stream stream)`
`static void`	`reduce(GpuMat mtx, GpuMat vec, int dim, int reduceOp)`
`static void`	`reduce(GpuMat mtx, GpuMat vec, int dim, int reduceOp, int dtype, Stream stream)`
`static void`	`reduce(Mat mtx, Mat vec, int dim, int reduceOp)`
`static void`	`reduce(Mat mtx, Mat vec, int dim, int reduceOp, int dtype, Stream stream)` \brief Reduces a matrix to a vector.
`static void`	`reduce(UMat mtx, UMat vec, int dim, int reduceOp)`
`static void`	`reduce(UMat mtx, UMat vec, int dim, int reduceOp, int dtype, Stream stream)`
`static void`	`rshift(GpuMat src, Scalar4i val, GpuMat dst)`
`static void`	`rshift(GpuMat src, Scalar4i val, GpuMat dst, Stream stream)`
`static void`	`rshift(GpuMat src, Scalar val, GpuMat dst)`
`static void`	`rshift(GpuMat src, Scalar val, GpuMat dst, Stream stream)`
`static void`	`rshift(Mat src, Scalar4i val, Mat dst)`
`static void`	`rshift(Mat src, Scalar4i val, Mat dst, Stream stream)` \brief Performs pixel by pixel right shift of an image by a constant value.
`static void`	`rshift(Mat src, Scalar val, Mat dst)`
`static void`	`rshift(Mat src, Scalar val, Mat dst, Stream stream)`
`static void`	`rshift(UMat src, Scalar4i val, UMat dst)`
`static void`	`rshift(UMat src, Scalar4i val, UMat dst, Stream stream)`
`static void`	`rshift(UMat src, Scalar val, UMat dst)`
`static void`	`rshift(UMat src, Scalar val, UMat dst, Stream stream)`
`static void`	`scaleAdd(GpuMat src1, double alpha, GpuMat src2, GpuMat dst)`
`static void`	`scaleAdd(GpuMat src1, double alpha, GpuMat src2, GpuMat dst, Stream stream)`
`static void`	`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)`
`static void`	`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst, Stream stream)` adds scaled array to another one (dst = alpha*src1 + src2)
`static void`	`scaleAdd(UMat src1, double alpha, UMat src2, UMat dst)`
`static void`	`scaleAdd(UMat src1, double alpha, UMat src2, UMat dst, Stream stream)`
`static void`	`split(GpuMat src, GpuMat dst)`
`static void`	`split(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`split(GpuMat src, GpuMatVector dst)`
`static void`	`split(GpuMat src, GpuMatVector dst, Stream stream)`
`static void`	`split(Mat src, GpuMat dst)`
`static void`	`split(Mat src, GpuMat dst, Stream stream)` \brief Copies each plane of a multi-channel matrix into an array.
`static void`	`split(Mat src, GpuMatVector dst)`
`static void`	`split(Mat src, GpuMatVector dst, Stream stream)` \overload
`static void`	`split(UMat src, GpuMat dst)`
`static void`	`split(UMat src, GpuMat dst, Stream stream)`
`static void`	`split(UMat src, GpuMatVector dst)`
`static void`	`split(UMat src, GpuMatVector dst, Stream stream)`
`static void`	`sqr(GpuMat src, GpuMat dst)`
`static void`	`sqr(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`sqr(Mat src, Mat dst)`
`static void`	`sqr(Mat src, Mat dst, Stream stream)` \brief Computes a square value of each matrix element.
`static void`	`sqr(UMat src, UMat dst)`
`static void`	`sqr(UMat src, UMat dst, Stream stream)`
`static void`	`sqrIntegral(GpuMat src, GpuMat sqsum)`
`static void`	`sqrIntegral(GpuMat src, GpuMat sqsum, Stream stream)`
`static void`	`sqrIntegral(Mat src, Mat sqsum)`
`static void`	`sqrIntegral(Mat src, Mat sqsum, Stream stream)` \brief Computes a squared integral image.
`static void`	`sqrIntegral(UMat src, UMat sqsum)`
`static void`	`sqrIntegral(UMat src, UMat sqsum, Stream stream)`
`static Scalar`	`sqrSum(GpuMat src)`
`static Scalar`	`sqrSum(GpuMat src, GpuMat mask)`
`static Scalar`	`sqrSum(Mat src)`
`static Scalar`	`sqrSum(Mat src, Mat mask)` \brief Returns the squared sum of matrix elements.
`static Scalar`	`sqrSum(UMat src)`
`static Scalar`	`sqrSum(UMat src, UMat mask)`
`static void`	`sqrt(GpuMat src, GpuMat dst)`
`static void`	`sqrt(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`sqrt(Mat src, Mat dst)`
`static void`	`sqrt(Mat src, Mat dst, Stream stream)` \brief Computes a square root of each matrix element.
`static void`	`sqrt(UMat src, UMat dst)`
`static void`	`sqrt(UMat src, UMat dst, Stream stream)`
`static void`	`subtract(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`subtract(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, int dtype, Stream stream)`
`static void`	`subtract(Mat src1, Mat src2, Mat dst)`
`static void`	`subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype, Stream stream)` \brief Computes a matrix-matrix or matrix-scalar difference.
`static void`	`subtract(UMat src1, UMat src2, UMat dst)`
`static void`	`subtract(UMat src1, UMat src2, UMat dst, UMat mask, int dtype, Stream stream)`
`static Scalar`	`sum(GpuMat src)`
`static Scalar`	`sum(GpuMat src, GpuMat mask)`
`static Scalar`	`sum(Mat src)`
`static Scalar`	`sum(Mat src, Mat mask)` \brief Returns the sum of matrix elements.
`static Scalar`	`sum(UMat src)`
`static Scalar`	`sum(UMat src, UMat mask)`
`static double`	`threshold(GpuMat src, GpuMat dst, double thresh, double maxval, int type)`
`static double`	`threshold(GpuMat src, GpuMat dst, double thresh, double maxval, int type, Stream stream)`
`static double`	`threshold(Mat src, Mat dst, double thresh, double maxval, int type)`
`static double`	`threshold(Mat src, Mat dst, double thresh, double maxval, int type, Stream stream)` \brief Applies a fixed-level threshold to each array element.
`static double`	`threshold(UMat src, UMat dst, double thresh, double maxval, int type)`
`static double`	`threshold(UMat src, UMat dst, double thresh, double maxval, int type, Stream stream)`
`static void`	`transpose(GpuMat src1, GpuMat dst)`
`static void`	`transpose(GpuMat src1, GpuMat dst, Stream stream)`
`static void`	`transpose(Mat src1, Mat dst)`
`static void`	`transpose(Mat src1, Mat dst, Stream stream)` \brief Transposes a matrix.
`static void`	`transpose(UMat src1, UMat dst)`
`static void`	`transpose(UMat src1, UMat dst, Stream stream)`

Methods inherited from class org.bytedeco.opencv.presets.opencv_cudaarithm
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- opencv_cudaarithm
```
public opencv_cudaarithm()
```

Method Detail

add

@Namespace(value="cv::cuda")
public static void add(@ByVal
                                                    Mat src1,
                                                    @ByVal
                                                    Mat src2,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    Mat mask,
                                                    int dtype,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

\addtogroup cudaarithm \{

\addtogroup cudaarithm_elem \{

/** \brief Computes a matrix-matrix or matrix-scalar sum.

Parameters:: 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.
See Also:: add

add

@Namespace(value="cv::cuda")
public static void add(@ByVal
                                                    Mat src1,
                                                    @ByVal
                                                    Mat src2,
                                                    @ByVal
                                                    Mat dst)

add

@Namespace(value="cv::cuda")
public static void add(@ByVal
                                                    UMat src1,
                                                    @ByVal
                                                    UMat src2,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask,
                                                    int dtype,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

add

@Namespace(value="cv::cuda")
public static void add(@ByVal
                                                    UMat src1,
                                                    @ByVal
                                                    UMat src2,
                                                    @ByVal
                                                    UMat dst)

add

@Namespace(value="cv::cuda")
public static void add(@ByVal
                                                    GpuMat src1,
                                                    @ByVal
                                                    GpuMat src2,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask,
                                                    int dtype,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

add

@Namespace(value="cv::cuda")
public static void add(@ByVal
                                                    GpuMat src1,
                                                    @ByVal
                                                    GpuMat src2,
                                                    @ByVal
                                                    GpuMat dst)

subtract

@Namespace(value="cv::cuda")
public static void subtract(@ByVal
                                                         Mat src1,
                                                         @ByVal
                                                         Mat src2,
                                                         @ByVal
                                                         Mat dst,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         Mat mask,
                                                         int dtype,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

\brief Computes a matrix-matrix or matrix-scalar difference.

Parameters:: 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.
See Also:: subtract

subtract

@Namespace(value="cv::cuda")
public static void subtract(@ByVal
                                                         Mat src1,
                                                         @ByVal
                                                         Mat src2,
                                                         @ByVal
                                                         Mat dst)

subtract

@Namespace(value="cv::cuda")
public static void subtract(@ByVal
                                                         UMat src1,
                                                         @ByVal
                                                         UMat src2,
                                                         @ByVal
                                                         UMat dst,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         UMat mask,
                                                         int dtype,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

subtract

@Namespace(value="cv::cuda")
public static void subtract(@ByVal
                                                         UMat src1,
                                                         @ByVal
                                                         UMat src2,
                                                         @ByVal
                                                         UMat dst)

subtract

@Namespace(value="cv::cuda")
public static void subtract(@ByVal
                                                         GpuMat src1,
                                                         @ByVal
                                                         GpuMat src2,
                                                         @ByVal
                                                         GpuMat dst,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         GpuMat mask,
                                                         int dtype,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

subtract

@Namespace(value="cv::cuda")
public static void subtract(@ByVal
                                                         GpuMat src1,
                                                         @ByVal
                                                         GpuMat src2,
                                                         @ByVal
                                                         GpuMat dst)

multiply

@Namespace(value="cv::cuda")
public static void multiply(@ByVal
                                                         Mat src1,
                                                         @ByVal
                                                         Mat src2,
                                                         @ByVal
                                                         Mat dst,
                                                         double scale,
                                                         int dtype,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

\brief Computes a matrix-matrix or matrix-scalar per-element product.

Parameters:: 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.
See Also:: multiply

multiply

@Namespace(value="cv::cuda")
public static void multiply(@ByVal
                                                         Mat src1,
                                                         @ByVal
                                                         Mat src2,
                                                         @ByVal
                                                         Mat dst)

multiply

@Namespace(value="cv::cuda")
public static void multiply(@ByVal
                                                         UMat src1,
                                                         @ByVal
                                                         UMat src2,
                                                         @ByVal
                                                         UMat dst,
                                                         double scale,
                                                         int dtype,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

multiply

@Namespace(value="cv::cuda")
public static void multiply(@ByVal
                                                         UMat src1,
                                                         @ByVal
                                                         UMat src2,
                                                         @ByVal
                                                         UMat dst)

multiply

@Namespace(value="cv::cuda")
public static void multiply(@ByVal
                                                         GpuMat src1,
                                                         @ByVal
                                                         GpuMat src2,
                                                         @ByVal
                                                         GpuMat dst,
                                                         double scale,
                                                         int dtype,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

multiply

@Namespace(value="cv::cuda")
public static void multiply(@ByVal
                                                         GpuMat src1,
                                                         @ByVal
                                                         GpuMat src2,
                                                         @ByVal
                                                         GpuMat dst)

divide

@Namespace(value="cv::cuda")
public static void divide(@ByVal
                                                       Mat src1,
                                                       @ByVal
                                                       Mat src2,
                                                       @ByVal
                                                       Mat dst,
                                                       double scale,
                                                       int dtype,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

\brief Computes a matrix-matrix or matrix-scalar division.

Parameters:

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.

See Also:

divide

divide

@Namespace(value="cv::cuda")
public static void divide(@ByVal
                                                       Mat src1,
                                                       @ByVal
                                                       Mat src2,
                                                       @ByVal
                                                       Mat dst)

divide

@Namespace(value="cv::cuda")
public static void divide(@ByVal
                                                       UMat src1,
                                                       @ByVal
                                                       UMat src2,
                                                       @ByVal
                                                       UMat dst,
                                                       double scale,
                                                       int dtype,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

divide

@Namespace(value="cv::cuda")
public static void divide(@ByVal
                                                       UMat src1,
                                                       @ByVal
                                                       UMat src2,
                                                       @ByVal
                                                       UMat dst)

divide

@Namespace(value="cv::cuda")
public static void divide(@ByVal
                                                       GpuMat src1,
                                                       @ByVal
                                                       GpuMat src2,
                                                       @ByVal
                                                       GpuMat dst,
                                                       double scale,
                                                       int dtype,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

divide

@Namespace(value="cv::cuda")
public static void divide(@ByVal
                                                       GpuMat src1,
                                                       @ByVal
                                                       GpuMat src2,
                                                       @ByVal
                                                       GpuMat dst)

absdiff

@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
                                                        Mat src1,
                                                        @ByVal
                                                        Mat src2,
                                                        @ByVal
                                                        Mat dst,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

\brief Computes per-element absolute difference of two matrices (or of a matrix and scalar).

Parameters:: 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.
See Also:: absdiff

absdiff

@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
                                                        Mat src1,
                                                        @ByVal
                                                        Mat src2,
                                                        @ByVal
                                                        Mat dst)

absdiff

@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
                                                        UMat src1,
                                                        @ByVal
                                                        UMat src2,
                                                        @ByVal
                                                        UMat dst,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

absdiff

@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
                                                        UMat src1,
                                                        @ByVal
                                                        UMat src2,
                                                        @ByVal
                                                        UMat dst)

absdiff

@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
                                                        GpuMat src1,
                                                        @ByVal
                                                        GpuMat src2,
                                                        @ByVal
                                                        GpuMat dst,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

absdiff

@Namespace(value="cv::cuda")
public static void absdiff(@ByVal
                                                        GpuMat src1,
                                                        @ByVal
                                                        GpuMat src2,
                                                        @ByVal
                                                        GpuMat dst)

abs

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

\brief Computes an absolute value of each matrix element.

Parameters:: src - Source matrix.; dst - Destination matrix with the same size and type as src .; stream - Stream for the asynchronous version.
See Also:: abs

abs

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

abs

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

abs

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

abs

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

abs

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

sqr

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

\brief Computes a square value of each matrix element.

Parameters:: src - Source matrix.; dst - Destination matrix with the same size and type as src .; stream - Stream for the asynchronous version.

sqr

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

sqr

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

sqr

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

sqr

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

sqr

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

sqrt

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

\brief Computes a square root of each matrix element.

Parameters:: src - Source matrix.; dst - Destination matrix with the same size and type as src .; stream - Stream for the asynchronous version.
See Also:: sqrt

sqrt

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

sqrt

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

sqrt

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

sqrt

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

sqrt

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

exp

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

\brief Computes an exponent of each matrix element.

Parameters:: src - Source matrix.; dst - Destination matrix with the same size and type as src .; stream - Stream for the asynchronous version.
See Also:: exp

exp

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

exp

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

exp

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

exp

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

exp

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

log

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

\brief Computes a natural logarithm of absolute value of each matrix element.

Parameters:: src - Source matrix.; dst - Destination matrix with the same size and type as src .; stream - Stream for the asynchronous version.
See Also:: log

log

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

log

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

log

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

log

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

log

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

pow

@Namespace(value="cv::cuda")
public static void pow(@ByVal
                                                    Mat src,
                                                    double power,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

\brief Raises every matrix element to a power.

Parameters:

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 :

 \[\texttt{dst} (I) =  \fork{\texttt{src}(I)^power}{if \texttt{power} is integer}{|\texttt{src}(I)|^power}{otherwise}\]

See Also:

pow

pow

@Namespace(value="cv::cuda")
public static void pow(@ByVal
                                                    Mat src,
                                                    double power,
                                                    @ByVal
                                                    Mat dst)

pow

@Namespace(value="cv::cuda")
public static void pow(@ByVal
                                                    UMat src,
                                                    double power,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

pow

@Namespace(value="cv::cuda")
public static void pow(@ByVal
                                                    UMat src,
                                                    double power,
                                                    @ByVal
                                                    UMat dst)

pow

@Namespace(value="cv::cuda")
public static void pow(@ByVal
                                                    GpuMat src,
                                                    double power,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

pow

@Namespace(value="cv::cuda")
public static void pow(@ByVal
                                                    GpuMat src,
                                                    double power,
                                                    @ByVal
                                                    GpuMat dst)

compare

@Namespace(value="cv::cuda")
public static void compare(@ByVal
                                                        Mat src1,
                                                        @ByVal
                                                        Mat src2,
                                                        @ByVal
                                                        Mat dst,
                                                        int cmpop,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

\brief Compares elements of two matrices (or of a matrix and scalar).

Parameters:: src1 - First source matrix or scalar.; src2 - Second source matrix or scalar.; dst - Destination matrix that has the same size as the input array(s) and type CV_8U.; 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.
See Also:: compare

compare

@Namespace(value="cv::cuda")
public static void compare(@ByVal
                                                        Mat src1,
                                                        @ByVal
                                                        Mat src2,
                                                        @ByVal
                                                        Mat dst,
                                                        int cmpop)

compare

@Namespace(value="cv::cuda")
public static void compare(@ByVal
                                                        UMat src1,
                                                        @ByVal
                                                        UMat src2,
                                                        @ByVal
                                                        UMat dst,
                                                        int cmpop,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

compare

@Namespace(value="cv::cuda")
public static void compare(@ByVal
                                                        UMat src1,
                                                        @ByVal
                                                        UMat src2,
                                                        @ByVal
                                                        UMat dst,
                                                        int cmpop)

compare

@Namespace(value="cv::cuda")
public static void compare(@ByVal
                                                        GpuMat src1,
                                                        @ByVal
                                                        GpuMat src2,
                                                        @ByVal
                                                        GpuMat dst,
                                                        int cmpop,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

compare

@Namespace(value="cv::cuda")
public static void compare(@ByVal
                                                        GpuMat src1,
                                                        @ByVal
                                                        GpuMat src2,
                                                        @ByVal
                                                        GpuMat dst,
                                                        int cmpop)

bitwise_not

@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            Mat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Performs a per-element bitwise inversion.

Parameters:: 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.

bitwise_not

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

bitwise_not

@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
                                                            UMat src,
                                                            @ByVal
                                                            UMat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            UMat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

bitwise_not

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

bitwise_not

@Namespace(value="cv::cuda")
public static void bitwise_not(@ByVal
                                                            GpuMat src,
                                                            @ByVal
                                                            GpuMat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            GpuMat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

bitwise_not

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

bitwise_or

@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
                                                           Mat src1,
                                                           @ByVal
                                                           Mat src2,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           Mat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\brief Performs a per-element bitwise disjunction of two matrices (or of matrix and scalar).

Parameters:: 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.

bitwise_or

@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
                                                           Mat src1,
                                                           @ByVal
                                                           Mat src2,
                                                           @ByVal
                                                           Mat dst)

bitwise_or

@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
                                                           UMat src1,
                                                           @ByVal
                                                           UMat src2,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           UMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

bitwise_or

@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
                                                           UMat src1,
                                                           @ByVal
                                                           UMat src2,
                                                           @ByVal
                                                           UMat dst)

bitwise_or

@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
                                                           GpuMat src1,
                                                           @ByVal
                                                           GpuMat src2,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           GpuMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

bitwise_or

@Namespace(value="cv::cuda")
public static void bitwise_or(@ByVal
                                                           GpuMat src1,
                                                           @ByVal
                                                           GpuMat src2,
                                                           @ByVal
                                                           GpuMat dst)

bitwise_and

@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
                                                            Mat src1,
                                                            @ByVal
                                                            Mat src2,
                                                            @ByVal
                                                            Mat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            Mat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Performs a per-element bitwise conjunction of two matrices (or of matrix and scalar).

Parameters:: 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.

bitwise_and

@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
                                                            Mat src1,
                                                            @ByVal
                                                            Mat src2,
                                                            @ByVal
                                                            Mat dst)

bitwise_and

@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
                                                            UMat src1,
                                                            @ByVal
                                                            UMat src2,
                                                            @ByVal
                                                            UMat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            UMat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

bitwise_and

@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
                                                            UMat src1,
                                                            @ByVal
                                                            UMat src2,
                                                            @ByVal
                                                            UMat dst)

bitwise_and

@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
                                                            GpuMat src1,
                                                            @ByVal
                                                            GpuMat src2,
                                                            @ByVal
                                                            GpuMat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            GpuMat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

bitwise_and

@Namespace(value="cv::cuda")
public static void bitwise_and(@ByVal
                                                            GpuMat src1,
                                                            @ByVal
                                                            GpuMat src2,
                                                            @ByVal
                                                            GpuMat dst)

bitwise_xor

@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
                                                            Mat src1,
                                                            @ByVal
                                                            Mat src2,
                                                            @ByVal
                                                            Mat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            Mat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Performs a per-element bitwise exclusive or operation of two matrices (or of matrix and scalar).

Parameters:: 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.

bitwise_xor

@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
                                                            Mat src1,
                                                            @ByVal
                                                            Mat src2,
                                                            @ByVal
                                                            Mat dst)

bitwise_xor

@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
                                                            UMat src1,
                                                            @ByVal
                                                            UMat src2,
                                                            @ByVal
                                                            UMat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            UMat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

bitwise_xor

@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
                                                            UMat src1,
                                                            @ByVal
                                                            UMat src2,
                                                            @ByVal
                                                            UMat dst)

bitwise_xor

@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
                                                            GpuMat src1,
                                                            @ByVal
                                                            GpuMat src2,
                                                            @ByVal
                                                            GpuMat dst,
                                                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                            GpuMat mask,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

bitwise_xor

@Namespace(value="cv::cuda")
public static void bitwise_xor(@ByVal
                                                            GpuMat src1,
                                                            @ByVal
                                                            GpuMat src2,
                                                            @ByVal
                                                            GpuMat dst)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       Mat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

\brief Performs pixel by pixel right shift of an image by a constant value.

Parameters:: 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.

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       Mat dst)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       UMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       UMat dst)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       GpuMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       GpuMat dst)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       Mat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       Mat dst)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       UMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       UMat dst)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       GpuMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

rshift

@Namespace(value="cv::cuda")
public static void rshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       GpuMat dst)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       Mat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

\brief Performs pixel by pixel right left of an image by a constant value.

Parameters:: 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.

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       Mat dst)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       UMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       UMat dst)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       GpuMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar4i val,
                                                       @ByVal
                                                       GpuMat dst)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       Mat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       Mat dst)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       UMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       UMat dst)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       GpuMat dst,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

lshift

@Namespace(value="cv::cuda")
public static void lshift(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       Scalar val,
                                                       @ByVal
                                                       GpuMat dst)

min

@Namespace(value="cv::cuda")
public static void min(@ByVal
                                                    Mat src1,
                                                    @ByVal
                                                    Mat src2,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

\brief Computes the per-element minimum of two matrices (or a matrix and a scalar).

Parameters:: 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.
See Also:: min

min

@Namespace(value="cv::cuda")
public static void min(@ByVal
                                                    Mat src1,
                                                    @ByVal
                                                    Mat src2,
                                                    @ByVal
                                                    Mat dst)

min

@Namespace(value="cv::cuda")
public static void min(@ByVal
                                                    UMat src1,
                                                    @ByVal
                                                    UMat src2,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

min

@Namespace(value="cv::cuda")
public static void min(@ByVal
                                                    UMat src1,
                                                    @ByVal
                                                    UMat src2,
                                                    @ByVal
                                                    UMat dst)

min

@Namespace(value="cv::cuda")
public static void min(@ByVal
                                                    GpuMat src1,
                                                    @ByVal
                                                    GpuMat src2,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

min

@Namespace(value="cv::cuda")
public static void min(@ByVal
                                                    GpuMat src1,
                                                    @ByVal
                                                    GpuMat src2,
                                                    @ByVal
                                                    GpuMat dst)

max

@Namespace(value="cv::cuda")
public static void max(@ByVal
                                                    Mat src1,
                                                    @ByVal
                                                    Mat src2,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

\brief Computes the per-element maximum of two matrices (or a matrix and a scalar).

Parameters:: 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.
See Also:: max

max

@Namespace(value="cv::cuda")
public static void max(@ByVal
                                                    Mat src1,
                                                    @ByVal
                                                    Mat src2,
                                                    @ByVal
                                                    Mat dst)

max

@Namespace(value="cv::cuda")
public static void max(@ByVal
                                                    UMat src1,
                                                    @ByVal
                                                    UMat src2,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

max

@Namespace(value="cv::cuda")
public static void max(@ByVal
                                                    UMat src1,
                                                    @ByVal
                                                    UMat src2,
                                                    @ByVal
                                                    UMat dst)

max

@Namespace(value="cv::cuda")
public static void max(@ByVal
                                                    GpuMat src1,
                                                    @ByVal
                                                    GpuMat src2,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

max

@Namespace(value="cv::cuda")
public static void max(@ByVal
                                                    GpuMat src1,
                                                    @ByVal
                                                    GpuMat src2,
                                                    @ByVal
                                                    GpuMat dst)

addWeighted

@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
                                                            Mat src1,
                                                            double alpha,
                                                            @ByVal
                                                            Mat src2,
                                                            double beta,
                                                            double gamma,
                                                            @ByVal
                                                            Mat dst,
                                                            int dtype,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Computes the weighted sum of two arrays.

Parameters:

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:

 \[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} +  \texttt{src2} (I)* \texttt{beta} +  \texttt{gamma} )\]

where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

See Also:

addWeighted

addWeighted

@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
                                                            Mat src1,
                                                            double alpha,
                                                            @ByVal
                                                            Mat src2,
                                                            double beta,
                                                            double gamma,
                                                            @ByVal
                                                            Mat dst)

addWeighted

@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
                                                            UMat src1,
                                                            double alpha,
                                                            @ByVal
                                                            UMat src2,
                                                            double beta,
                                                            double gamma,
                                                            @ByVal
                                                            UMat dst,
                                                            int dtype,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

addWeighted

@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
                                                            UMat src1,
                                                            double alpha,
                                                            @ByVal
                                                            UMat src2,
                                                            double beta,
                                                            double gamma,
                                                            @ByVal
                                                            UMat dst)

addWeighted

@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
                                                            GpuMat src1,
                                                            double alpha,
                                                            @ByVal
                                                            GpuMat src2,
                                                            double beta,
                                                            double gamma,
                                                            @ByVal
                                                            GpuMat dst,
                                                            int dtype,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

addWeighted

@Namespace(value="cv::cuda")
public static void addWeighted(@ByVal
                                                            GpuMat src1,
                                                            double alpha,
                                                            @ByVal
                                                            GpuMat src2,
                                                            double beta,
                                                            double gamma,
                                                            @ByVal
                                                            GpuMat dst)

scaleAdd

@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
                                                         Mat src1,
                                                         double alpha,
                                                         @ByVal
                                                         Mat src2,
                                                         @ByVal
                                                         Mat dst,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

adds scaled array to another one (dst = alpha*src1 + src2)

scaleAdd

@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
                                                         Mat src1,
                                                         double alpha,
                                                         @ByVal
                                                         Mat src2,
                                                         @ByVal
                                                         Mat dst)

scaleAdd

@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
                                                         UMat src1,
                                                         double alpha,
                                                         @ByVal
                                                         UMat src2,
                                                         @ByVal
                                                         UMat dst,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

scaleAdd

@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
                                                         UMat src1,
                                                         double alpha,
                                                         @ByVal
                                                         UMat src2,
                                                         @ByVal
                                                         UMat dst)

scaleAdd

@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
                                                         GpuMat src1,
                                                         double alpha,
                                                         @ByVal
                                                         GpuMat src2,
                                                         @ByVal
                                                         GpuMat dst,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

scaleAdd

@Namespace(value="cv::cuda")
public static void scaleAdd(@ByVal
                                                         GpuMat src1,
                                                         double alpha,
                                                         @ByVal
                                                         GpuMat src2,
                                                         @ByVal
                                                         GpuMat dst)

threshold

@Namespace(value="cv::cuda")
public static double threshold(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat dst,
                                                            double thresh,
                                                            double maxval,
                                                            int type,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Applies a fixed-level threshold to each array element.

Parameters:: 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.
See Also:: threshold

threshold

@Namespace(value="cv::cuda")
public static double threshold(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat dst,
                                                            double thresh,
                                                            double maxval,
                                                            int type)

threshold

@Namespace(value="cv::cuda")
public static double threshold(@ByVal
                                                            UMat src,
                                                            @ByVal
                                                            UMat dst,
                                                            double thresh,
                                                            double maxval,
                                                            int type,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

threshold

@Namespace(value="cv::cuda")
public static double threshold(@ByVal
                                                            UMat src,
                                                            @ByVal
                                                            UMat dst,
                                                            double thresh,
                                                            double maxval,
                                                            int type)

threshold

@Namespace(value="cv::cuda")
public static double threshold(@ByVal
                                                            GpuMat src,
                                                            @ByVal
                                                            GpuMat dst,
                                                            double thresh,
                                                            double maxval,
                                                            int type,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

threshold

@Namespace(value="cv::cuda")
public static double threshold(@ByVal
                                                            GpuMat src,
                                                            @ByVal
                                                            GpuMat dst,
                                                            double thresh,
                                                            double maxval,
                                                            int type)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          Mat xy,
                                                          @ByVal
                                                          Mat magnitude,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\brief Computes magnitudes of complex matrix elements.

Parameters:: xy - Source complex matrix in the interleaved format ( CV_32FC2 ).; magnitude - Destination matrix of float magnitudes ( CV_32FC1 ).; stream - Stream for the asynchronous version.
See Also:: magnitude

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          Mat xy,
                                                          @ByVal
                                                          Mat magnitude)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          UMat xy,
                                                          @ByVal
                                                          UMat magnitude,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          UMat xy,
                                                          @ByVal
                                                          UMat magnitude)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          GpuMat xy,
                                                          @ByVal
                                                          GpuMat magnitude,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          GpuMat xy,
                                                          @ByVal
                                                          GpuMat magnitude)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             Mat xy,
                                                             @ByVal
                                                             Mat magnitude,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

\brief Computes squared magnitudes of complex matrix elements.

Parameters:: 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.

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             Mat xy,
                                                             @ByVal
                                                             Mat magnitude)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             UMat xy,
                                                             @ByVal
                                                             UMat magnitude,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             UMat xy,
                                                             @ByVal
                                                             UMat magnitude)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             GpuMat xy,
                                                             @ByVal
                                                             GpuMat magnitude,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             GpuMat xy,
                                                             @ByVal
                                                             GpuMat magnitude)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          Mat x,
                                                          @ByVal
                                                          Mat y,
                                                          @ByVal
                                                          Mat magnitude,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\overload computes magnitude of each (x(i), y(i)) vector supports only floating-point source

Parameters:: 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.

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          Mat x,
                                                          @ByVal
                                                          Mat y,
                                                          @ByVal
                                                          Mat magnitude)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          UMat x,
                                                          @ByVal
                                                          UMat y,
                                                          @ByVal
                                                          UMat magnitude,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          UMat x,
                                                          @ByVal
                                                          UMat y,
                                                          @ByVal
                                                          UMat magnitude)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          GpuMat x,
                                                          @ByVal
                                                          GpuMat y,
                                                          @ByVal
                                                          GpuMat magnitude,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

magnitude

@Namespace(value="cv::cuda")
public static void magnitude(@ByVal
                                                          GpuMat x,
                                                          @ByVal
                                                          GpuMat y,
                                                          @ByVal
                                                          GpuMat magnitude)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             Mat x,
                                                             @ByVal
                                                             Mat y,
                                                             @ByVal
                                                             Mat magnitude,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

\overload computes squared magnitude of each (x(i), y(i)) vector supports only floating-point source

Parameters:: 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.

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             Mat x,
                                                             @ByVal
                                                             Mat y,
                                                             @ByVal
                                                             Mat magnitude)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             UMat x,
                                                             @ByVal
                                                             UMat y,
                                                             @ByVal
                                                             UMat magnitude,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             UMat x,
                                                             @ByVal
                                                             UMat y,
                                                             @ByVal
                                                             UMat magnitude)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             GpuMat x,
                                                             @ByVal
                                                             GpuMat y,
                                                             @ByVal
                                                             GpuMat magnitude,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

magnitudeSqr

@Namespace(value="cv::cuda")
public static void magnitudeSqr(@ByVal
                                                             GpuMat x,
                                                             @ByVal
                                                             GpuMat y,
                                                             @ByVal
                                                             GpuMat magnitude)

phase

@Namespace(value="cv::cuda")
public static void phase(@ByVal
                                                      Mat x,
                                                      @ByVal
                                                      Mat y,
                                                      @ByVal
                                                      Mat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

\brief Computes polar angles of complex matrix elements.

Parameters:: 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.
See Also:: phase

phase

@Namespace(value="cv::cuda")
public static void phase(@ByVal
                                                      Mat x,
                                                      @ByVal
                                                      Mat y,
                                                      @ByVal
                                                      Mat angle)

phase

@Namespace(value="cv::cuda")
public static void phase(@ByVal
                                                      UMat x,
                                                      @ByVal
                                                      UMat y,
                                                      @ByVal
                                                      UMat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

phase

@Namespace(value="cv::cuda")
public static void phase(@ByVal
                                                      UMat x,
                                                      @ByVal
                                                      UMat y,
                                                      @ByVal
                                                      UMat angle)

phase

@Namespace(value="cv::cuda")
public static void phase(@ByVal
                                                      GpuMat x,
                                                      @ByVal
                                                      GpuMat y,
                                                      @ByVal
                                                      GpuMat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

phase

@Namespace(value="cv::cuda")
public static void phase(@ByVal
                                                      GpuMat x,
                                                      @ByVal
                                                      GpuMat y,
                                                      @ByVal
                                                      GpuMat angle)

cartToPolar

@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
                                                            Mat x,
                                                            @ByVal
                                                            Mat y,
                                                            @ByVal
                                                            Mat magnitude,
                                                            @ByVal
                                                            Mat angle,
                                                            @Cast(value="bool")
                                                            boolean angleInDegrees,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Converts Cartesian coordinates into polar.

Parameters:: 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.
See Also:: cartToPolar

cartToPolar

@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
                                                            Mat x,
                                                            @ByVal
                                                            Mat y,
                                                            @ByVal
                                                            Mat magnitude,
                                                            @ByVal
                                                            Mat angle)

cartToPolar

@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
                                                            UMat x,
                                                            @ByVal
                                                            UMat y,
                                                            @ByVal
                                                            UMat magnitude,
                                                            @ByVal
                                                            UMat angle,
                                                            @Cast(value="bool")
                                                            boolean angleInDegrees,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

cartToPolar

@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
                                                            UMat x,
                                                            @ByVal
                                                            UMat y,
                                                            @ByVal
                                                            UMat magnitude,
                                                            @ByVal
                                                            UMat angle)

cartToPolar

@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
                                                            GpuMat x,
                                                            @ByVal
                                                            GpuMat y,
                                                            @ByVal
                                                            GpuMat magnitude,
                                                            @ByVal
                                                            GpuMat angle,
                                                            @Cast(value="bool")
                                                            boolean angleInDegrees,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

cartToPolar

@Namespace(value="cv::cuda")
public static void cartToPolar(@ByVal
                                                            GpuMat x,
                                                            @ByVal
                                                            GpuMat y,
                                                            @ByVal
                                                            GpuMat magnitude,
                                                            @ByVal
                                                            GpuMat angle)

polarToCart

@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
                                                            Mat magnitude,
                                                            @ByVal
                                                            Mat angle,
                                                            @ByVal
                                                            Mat x,
                                                            @ByVal
                                                            Mat y,
                                                            @Cast(value="bool")
                                                            boolean angleInDegrees,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Converts polar coordinates into Cartesian.

Parameters:: magnitude - Source matrix containing magnitudes ( CV_32FC1 or CV_64FC1 ).; angle - Source matrix containing angles ( same type as magnitude ).; x - Destination matrix of real components ( same type as magnitude ).; y - Destination matrix of imaginary components ( same type as magnitude ).; angleInDegrees - Flag that indicates angles in degrees.; stream - Stream for the asynchronous version.

polarToCart

@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
                                                            Mat magnitude,
                                                            @ByVal
                                                            Mat angle,
                                                            @ByVal
                                                            Mat x,
                                                            @ByVal
                                                            Mat y)

polarToCart

@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
                                                            UMat magnitude,
                                                            @ByVal
                                                            UMat angle,
                                                            @ByVal
                                                            UMat x,
                                                            @ByVal
                                                            UMat y,
                                                            @Cast(value="bool")
                                                            boolean angleInDegrees,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

polarToCart

@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
                                                            UMat magnitude,
                                                            @ByVal
                                                            UMat angle,
                                                            @ByVal
                                                            UMat x,
                                                            @ByVal
                                                            UMat y)

polarToCart

@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
                                                            GpuMat magnitude,
                                                            @ByVal
                                                            GpuMat angle,
                                                            @ByVal
                                                            GpuMat x,
                                                            @ByVal
                                                            GpuMat y,
                                                            @Cast(value="bool")
                                                            boolean angleInDegrees,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

polarToCart

@Namespace(value="cv::cuda")
public static void polarToCart(@ByVal
                                                            GpuMat magnitude,
                                                            @ByVal
                                                            GpuMat angle,
                                                            @ByVal
                                                            GpuMat x,
                                                            @ByVal
                                                            GpuMat y)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const
                                                      GpuMat src,
                                                      @Cast(value="size_t")
                                                      long n,
                                                      @ByVal
                                                      Mat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

\} cudaarithm_elem

\addtogroup cudaarithm_core \{

/** \brief Makes a multi-channel matrix out of several single-channel matrices.

Parameters:: src - Array/vector of source matrices.; n - Number of source matrices.; dst - Destination matrix.; stream - Stream for the asynchronous version.
See Also:: merge

merge

@Namespace(value="cv::cuda")
public static void merge(@Const
                                                      GpuMat src,
                                                      @Cast(value="size_t")
                                                      long n,
                                                      @ByVal
                                                      Mat dst)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const
                                                      GpuMat src,
                                                      @Cast(value="size_t")
                                                      long n,
                                                      @ByVal
                                                      UMat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const
                                                      GpuMat src,
                                                      @Cast(value="size_t")
                                                      long n,
                                                      @ByVal
                                                      UMat dst)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const
                                                      GpuMat src,
                                                      @Cast(value="size_t")
                                                      long n,
                                                      @ByVal
                                                      GpuMat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const
                                                      GpuMat src,
                                                      @Cast(value="size_t")
                                                      long n,
                                                      @ByVal
                                                      GpuMat dst)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
                                                      GpuMatVector src,
                                                      @ByVal
                                                      Mat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

\overload

merge

@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
                                                      GpuMatVector src,
                                                      @ByVal
                                                      Mat dst)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
                                                      GpuMatVector src,
                                                      @ByVal
                                                      UMat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
                                                      GpuMatVector src,
                                                      @ByVal
                                                      UMat dst)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
                                                      GpuMatVector src,
                                                      @ByVal
                                                      GpuMat dst,
                                                      @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                      Stream stream)

merge

@Namespace(value="cv::cuda")
public static void merge(@Const @ByRef
                                                      GpuMatVector src,
                                                      @ByVal
                                                      GpuMat dst)

split

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

\brief Copies each plane of a multi-channel matrix into an array.

Parameters:: src - Source matrix.; dst - Destination array/vector of single-channel matrices.; stream - Stream for the asynchronous version.
See Also:: split

split

@Namespace(value="cv::cuda")
public static void split(@ByVal
                                                      Mat src,
                                                      GpuMat dst)

split

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

split

@Namespace(value="cv::cuda")
public static void split(@ByVal
                                                      UMat src,
                                                      GpuMat dst)

split

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

split

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

split

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

\overload

split

@Namespace(value="cv::cuda")
public static void split(@ByVal
                                                      Mat src,
                                                      @ByRef
                                                      GpuMatVector dst)

split

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

split

@Namespace(value="cv::cuda")
public static void split(@ByVal
                                                      UMat src,
                                                      @ByRef
                                                      GpuMatVector dst)

split

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

split

@Namespace(value="cv::cuda")
public static void split(@ByVal
                                                      GpuMat src,
                                                      @ByRef
                                                      GpuMatVector dst)

transpose

@Namespace(value="cv::cuda")
public static void transpose(@ByVal
                                                          Mat src1,
                                                          @ByVal
                                                          Mat dst,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\brief Transposes a matrix.

Parameters:: src1 - Source matrix. 1-, 4-, 8-byte element sizes are supported for now.; dst - Destination matrix.; stream - Stream for the asynchronous version.
See Also:: transpose

transpose

@Namespace(value="cv::cuda")
public static void transpose(@ByVal
                                                          Mat src1,
                                                          @ByVal
                                                          Mat dst)

transpose

@Namespace(value="cv::cuda")
public static void transpose(@ByVal
                                                          UMat src1,
                                                          @ByVal
                                                          UMat dst,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

transpose

@Namespace(value="cv::cuda")
public static void transpose(@ByVal
                                                          UMat src1,
                                                          @ByVal
                                                          UMat dst)

transpose

@Namespace(value="cv::cuda")
public static void transpose(@ByVal
                                                          GpuMat src1,
                                                          @ByVal
                                                          GpuMat dst,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

transpose

@Namespace(value="cv::cuda")
public static void transpose(@ByVal
                                                          GpuMat src1,
                                                          @ByVal
                                                          GpuMat dst)

flip

@Namespace(value="cv::cuda")
public static void flip(@ByVal
                                                     Mat src,
                                                     @ByVal
                                                     Mat dst,
                                                     int flipCode,
                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                     Stream stream)

\brief Flips a 2D matrix around vertical, horizontal, or both axes.

Parameters:: 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.
See Also:: flip

flip

@Namespace(value="cv::cuda")
public static void flip(@ByVal
                                                     Mat src,
                                                     @ByVal
                                                     Mat dst,
                                                     int flipCode)

flip

@Namespace(value="cv::cuda")
public static void flip(@ByVal
                                                     UMat src,
                                                     @ByVal
                                                     UMat dst,
                                                     int flipCode,
                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                     Stream stream)

flip

@Namespace(value="cv::cuda")
public static void flip(@ByVal
                                                     UMat src,
                                                     @ByVal
                                                     UMat dst,
                                                     int flipCode)

flip

@Namespace(value="cv::cuda")
public static void flip(@ByVal
                                                     GpuMat src,
                                                     @ByVal
                                                     GpuMat dst,
                                                     int flipCode,
                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                     Stream stream)

flip

@Namespace(value="cv::cuda")
public static void flip(@ByVal
                                                     GpuMat src,
                                                     @ByVal
                                                     GpuMat dst,
                                                     int flipCode)

createLookUpTable

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static LookUpTable createLookUpTable(@ByVal
                                                                                           Mat lut)

\brief Creates implementation for cuda::LookUpTable .

Parameters:: lut - Look-up table of 256 elements. It is a continuous CV_8U matrix.

createLookUpTable

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static LookUpTable createLookUpTable(@ByVal
                                                                                           UMat lut)

createLookUpTable

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static LookUpTable createLookUpTable(@ByVal
                                                                                           GpuMat lut)

copyMakeBorder

@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst,
                                                               int top,
                                                               int bottom,
                                                               int left,
                                                               int right,
                                                               int borderType,
                                                               @ByVal(nullValue="cv::Scalar()")
                                                               Scalar value,
                                                               @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                               Stream stream)

\brief Forms a border around an image.

Parameters:: 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 - Number of top pixels; bottom - Number of bottom pixels; left - Number of left pixels; 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.

copyMakeBorder

@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst,
                                                               int top,
                                                               int bottom,
                                                               int left,
                                                               int right,
                                                               int borderType)

copyMakeBorder

@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
                                                               UMat src,
                                                               @ByVal
                                                               UMat dst,
                                                               int top,
                                                               int bottom,
                                                               int left,
                                                               int right,
                                                               int borderType,
                                                               @ByVal(nullValue="cv::Scalar()")
                                                               Scalar value,
                                                               @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                               Stream stream)

copyMakeBorder

@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
                                                               UMat src,
                                                               @ByVal
                                                               UMat dst,
                                                               int top,
                                                               int bottom,
                                                               int left,
                                                               int right,
                                                               int borderType)

copyMakeBorder

@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
                                                               GpuMat src,
                                                               @ByVal
                                                               GpuMat dst,
                                                               int top,
                                                               int bottom,
                                                               int left,
                                                               int right,
                                                               int borderType,
                                                               @ByVal(nullValue="cv::Scalar()")
                                                               Scalar value,
                                                               @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                               Stream stream)

copyMakeBorder

@Namespace(value="cv::cuda")
public static void copyMakeBorder(@ByVal
                                                               GpuMat src,
                                                               @ByVal
                                                               GpuMat dst,
                                                               int top,
                                                               int bottom,
                                                               int left,
                                                               int right,
                                                               int borderType)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       Mat src1,
                                                       int normType,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       Mat mask)

\} cudaarithm_core

\addtogroup cudaarithm_reduce \{

/** \brief Returns the norm of a matrix (or difference of two matrices).

Parameters:: 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.
See Also:: norm

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       Mat src1,
                                                       int normType)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       UMat src1,
                                                       int normType,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       UMat mask)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       UMat src1,
                                                       int normType)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       GpuMat src1,
                                                       int normType,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       GpuMat mask)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       GpuMat src1,
                                                       int normType)

calcNorm

@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         Mat dst,
                                                         int normType,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         Mat mask,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

\overload

calcNorm

@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         Mat dst,
                                                         int normType)

calcNorm

@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat dst,
                                                         int normType,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         UMat mask,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

calcNorm

@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat dst,
                                                         int normType)

calcNorm

@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat dst,
                                                         int normType,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         GpuMat mask,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

calcNorm

@Namespace(value="cv::cuda")
public static void calcNorm(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat dst,
                                                         int normType)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       Mat src1,
                                                       @ByVal
                                                       Mat src2,
                                                       int normType)

\brief Returns the difference of two matrices.

Parameters:: 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.
See Also:: norm

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       Mat src1,
                                                       @ByVal
                                                       Mat src2)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       UMat src1,
                                                       @ByVal
                                                       UMat src2,
                                                       int normType)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       UMat src1,
                                                       @ByVal
                                                       UMat src2)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       GpuMat src1,
                                                       @ByVal
                                                       GpuMat src2,
                                                       int normType)

norm

@Namespace(value="cv::cuda")
public static double norm(@ByVal
                                                       GpuMat src1,
                                                       @ByVal
                                                       GpuMat src2)

calcNormDiff

@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
                                                             Mat src1,
                                                             @ByVal
                                                             Mat src2,
                                                             @ByVal
                                                             Mat dst,
                                                             int normType,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

\overload

calcNormDiff

@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
                                                             Mat src1,
                                                             @ByVal
                                                             Mat src2,
                                                             @ByVal
                                                             Mat dst)

calcNormDiff

@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
                                                             UMat src1,
                                                             @ByVal
                                                             UMat src2,
                                                             @ByVal
                                                             UMat dst,
                                                             int normType,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

calcNormDiff

@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
                                                             UMat src1,
                                                             @ByVal
                                                             UMat src2,
                                                             @ByVal
                                                             UMat dst)

calcNormDiff

@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
                                                             GpuMat src1,
                                                             @ByVal
                                                             GpuMat src2,
                                                             @ByVal
                                                             GpuMat dst,
                                                             int normType,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

calcNormDiff

@Namespace(value="cv::cuda")
public static void calcNormDiff(@ByVal
                                                             GpuMat src1,
                                                             @ByVal
                                                             GpuMat src2,
                                                             @ByVal
                                                             GpuMat dst)

sum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sum(@ByVal
                                                              Mat src,
                                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                              Mat mask)

\brief Returns the sum of matrix elements.

Parameters:: 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.
See Also:: sum

sum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sum(@ByVal
                                                              Mat src)

sum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sum(@ByVal
                                                              UMat src,
                                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                              UMat mask)

sum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sum(@ByVal
                                                              UMat src)

sum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sum(@ByVal
                                                              GpuMat src,
                                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                              GpuMat mask)

sum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sum(@ByVal
                                                              GpuMat src)

calcSum

@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
                                                        Mat src,
                                                        @ByVal
                                                        Mat dst,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        Mat mask,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

\overload

calcSum

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

calcSum

@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
                                                        UMat src,
                                                        @ByVal
                                                        UMat dst,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        UMat mask,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

calcSum

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

calcSum

@Namespace(value="cv::cuda")
public static void calcSum(@ByVal
                                                        GpuMat src,
                                                        @ByVal
                                                        GpuMat dst,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        GpuMat mask,
                                                        @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                        Stream stream)

calcSum

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

absSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar absSum(@ByVal
                                                                 Mat src,
                                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                 Mat mask)

\brief Returns the sum of absolute values for matrix elements.

Parameters:: 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.

absSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar absSum(@ByVal
                                                                 Mat src)

absSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar absSum(@ByVal
                                                                 UMat src,
                                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                 UMat mask)

absSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar absSum(@ByVal
                                                                 UMat src)

absSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar absSum(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                 GpuMat mask)

absSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar absSum(@ByVal
                                                                 GpuMat src)

calcAbsSum

@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           Mat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\overload

calcAbsSum

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

calcAbsSum

@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           UMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

calcAbsSum

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

calcAbsSum

@Namespace(value="cv::cuda")
public static void calcAbsSum(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           GpuMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

calcAbsSum

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

sqrSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sqrSum(@ByVal
                                                                 Mat src,
                                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                 Mat mask)

\brief Returns the squared sum of matrix elements.

Parameters:: 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.

sqrSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sqrSum(@ByVal
                                                                 Mat src)

sqrSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sqrSum(@ByVal
                                                                 UMat src,
                                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                 UMat mask)

sqrSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sqrSum(@ByVal
                                                                 UMat src)

sqrSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sqrSum(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                 GpuMat mask)

sqrSum

@Namespace(value="cv::cuda")
 @ByVal
public static Scalar sqrSum(@ByVal
                                                                 GpuMat src)

calcSqrSum

@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           Mat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\overload

calcSqrSum

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

calcSqrSum

@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           UMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

calcSqrSum

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

calcSqrSum

@Namespace(value="cv::cuda")
public static void calcSqrSum(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           GpuMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

calcSqrSum

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

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       Mat src,
                                                       DoublePointer minVal,
                                                       DoublePointer maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       Mat mask)

\brief Finds global minimum and maximum matrix elements and returns their values.

Parameters:

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.

See Also:

minMaxLoc

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       Mat src,
                                                       DoublePointer minVal,
                                                       DoublePointer maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       Mat src,
                                                       DoubleBuffer minVal,
                                                       DoubleBuffer maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       Mat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       Mat src,
                                                       DoubleBuffer minVal,
                                                       DoubleBuffer maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       Mat src,
                                                       double[] minVal,
                                                       double[] maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       Mat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       Mat src,
                                                       double[] minVal,
                                                       double[] maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       UMat src,
                                                       DoublePointer minVal,
                                                       DoublePointer maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       UMat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       UMat src,
                                                       DoublePointer minVal,
                                                       DoublePointer maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       UMat src,
                                                       DoubleBuffer minVal,
                                                       DoubleBuffer maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       UMat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       UMat src,
                                                       DoubleBuffer minVal,
                                                       DoubleBuffer maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       UMat src,
                                                       double[] minVal,
                                                       double[] maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       UMat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       UMat src,
                                                       double[] minVal,
                                                       double[] maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       GpuMat src,
                                                       DoublePointer minVal,
                                                       DoublePointer maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       GpuMat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       GpuMat src,
                                                       DoublePointer minVal,
                                                       DoublePointer maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       GpuMat src,
                                                       DoubleBuffer minVal,
                                                       DoubleBuffer maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       GpuMat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       GpuMat src,
                                                       DoubleBuffer minVal,
                                                       DoubleBuffer maxVal)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       GpuMat src,
                                                       double[] minVal,
                                                       double[] maxVal,
                                                       @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                       GpuMat mask)

minMax

@Namespace(value="cv::cuda")
public static void minMax(@ByVal
                                                       GpuMat src,
                                                       double[] minVal,
                                                       double[] maxVal)

findMinMax

@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           Mat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\overload

findMinMax

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

findMinMax

@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           UMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

findMinMax

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

findMinMax

@Namespace(value="cv::cuda")
public static void findMinMax(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                           GpuMat mask,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

findMinMax

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

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          Mat src,
                                                          DoublePointer minVal,
                                                          DoublePointer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          Mat mask)

\brief Finds global minimum and maximum matrix elements and returns their values with locations.

Parameters:

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.

See Also:

minMaxLoc

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          Mat src,
                                                          DoublePointer minVal,
                                                          DoublePointer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          Mat src,
                                                          DoubleBuffer minVal,
                                                          DoubleBuffer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          Mat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          Mat src,
                                                          DoubleBuffer minVal,
                                                          DoubleBuffer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          Mat src,
                                                          double[] minVal,
                                                          double[] maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          Mat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          Mat src,
                                                          double[] minVal,
                                                          double[] maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          UMat src,
                                                          DoublePointer minVal,
                                                          DoublePointer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          UMat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          UMat src,
                                                          DoublePointer minVal,
                                                          DoublePointer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          UMat src,
                                                          DoubleBuffer minVal,
                                                          DoubleBuffer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          UMat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          UMat src,
                                                          DoubleBuffer minVal,
                                                          DoubleBuffer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          UMat src,
                                                          double[] minVal,
                                                          double[] maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          UMat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          UMat src,
                                                          double[] minVal,
                                                          double[] maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          GpuMat src,
                                                          DoublePointer minVal,
                                                          DoublePointer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          GpuMat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          GpuMat src,
                                                          DoublePointer minVal,
                                                          DoublePointer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          GpuMat src,
                                                          DoubleBuffer minVal,
                                                          DoubleBuffer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          GpuMat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          GpuMat src,
                                                          DoubleBuffer minVal,
                                                          DoubleBuffer maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          GpuMat src,
                                                          double[] minVal,
                                                          double[] maxVal,
                                                          Point minLoc,
                                                          Point maxLoc,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          GpuMat mask)

minMaxLoc

@Namespace(value="cv::cuda")
public static void minMaxLoc(@ByVal
                                                          GpuMat src,
                                                          double[] minVal,
                                                          double[] maxVal,
                                                          Point minLoc,
                                                          Point maxLoc)

findMinMaxLoc

@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat minMaxVals,
                                                              @ByVal
                                                              Mat loc,
                                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                              Mat mask,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

\overload

findMinMaxLoc

@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat minMaxVals,
                                                              @ByVal
                                                              Mat loc)

findMinMaxLoc

@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat minMaxVals,
                                                              @ByVal
                                                              UMat loc,
                                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                              UMat mask,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

findMinMaxLoc

@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat minMaxVals,
                                                              @ByVal
                                                              UMat loc)

findMinMaxLoc

@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat minMaxVals,
                                                              @ByVal
                                                              GpuMat loc,
                                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                              GpuMat mask,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

findMinMaxLoc

@Namespace(value="cv::cuda")
public static void findMinMaxLoc(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat minMaxVals,
                                                              @ByVal
                                                              GpuMat loc)

countNonZero
```
@Namespace(value="cv::cuda")
public static int countNonZero(@ByVal
                                                            Mat src)
```
\brief Counts non-zero matrix elements.

Parameters:

src - Single-channel source image.
The function does not work with CV_64F images on GPUs with the compute capability \< 1.3.

See Also:

countNonZero

countNonZero

@Namespace(value="cv::cuda")
public static int countNonZero(@ByVal
                                                            UMat src)

countNonZero

@Namespace(value="cv::cuda")
public static int countNonZero(@ByVal
                                                            GpuMat src)

countNonZero

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

\overload

countNonZero

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

countNonZero

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

countNonZero

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

countNonZero

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

countNonZero

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

reduce
```
@Namespace(value="cv::cuda")
public static void reduce(@ByVal
                                                       Mat mtx,
                                                       @ByVal
                                                       Mat vec,
                                                       int dim,
                                                       int reduceOp,
                                                       int dtype,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)
```
\brief Reduces a matrix to a vector.

Parameters:

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.

See Also:

reduce

reduce

@Namespace(value="cv::cuda")
public static void reduce(@ByVal
                                                       Mat mtx,
                                                       @ByVal
                                                       Mat vec,
                                                       int dim,
                                                       int reduceOp)

reduce

@Namespace(value="cv::cuda")
public static void reduce(@ByVal
                                                       UMat mtx,
                                                       @ByVal
                                                       UMat vec,
                                                       int dim,
                                                       int reduceOp,
                                                       int dtype,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

reduce

@Namespace(value="cv::cuda")
public static void reduce(@ByVal
                                                       UMat mtx,
                                                       @ByVal
                                                       UMat vec,
                                                       int dim,
                                                       int reduceOp)

reduce

@Namespace(value="cv::cuda")
public static void reduce(@ByVal
                                                       GpuMat mtx,
                                                       @ByVal
                                                       GpuMat vec,
                                                       int dim,
                                                       int reduceOp,
                                                       int dtype,
                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                       Stream stream)

reduce

@Namespace(value="cv::cuda")
public static void reduce(@ByVal
                                                       GpuMat mtx,
                                                       @ByVal
                                                       GpuMat vec,
                                                       int dim,
                                                       int reduceOp)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           Mat mtx,
                                                           @ByRef
                                                           Scalar mean,
                                                           @ByRef
                                                           Scalar stddev)

\brief Computes a mean value and a standard deviation of matrix elements.

Parameters:: mtx - Source matrix. CV_8UC1 matrices are supported for now.; mean - Mean value.; stddev - Standard deviation value.
See Also:: meanStdDev

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           UMat mtx,
                                                           @ByRef
                                                           Scalar mean,
                                                           @ByRef
                                                           Scalar stddev)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           GpuMat mtx,
                                                           @ByRef
                                                           Scalar mean,
                                                           @ByRef
                                                           Scalar stddev)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           Mat mtx,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\overload

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           Mat mtx,
                                                           @ByVal
                                                           Mat dst)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           UMat mtx,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           UMat mtx,
                                                           @ByVal
                                                           UMat dst)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           GpuMat mtx,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

meanStdDev

@Namespace(value="cv::cuda")
public static void meanStdDev(@ByVal
                                                           GpuMat mtx,
                                                           @ByVal
                                                           GpuMat dst)

rectStdDev

@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat sqr,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByVal
                                                           Rect rect,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\brief Computes a standard deviation of integral images.

Parameters:: 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.

rectStdDev

@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat sqr,
                                                           @ByVal
                                                           Mat dst,
                                                           @ByVal
                                                           Rect rect)

rectStdDev

@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat sqr,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByVal
                                                           Rect rect,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

rectStdDev

@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat sqr,
                                                           @ByVal
                                                           UMat dst,
                                                           @ByVal
                                                           Rect rect)

rectStdDev

@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat sqr,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByVal
                                                           Rect rect,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

rectStdDev

@Namespace(value="cv::cuda")
public static void rectStdDev(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat sqr,
                                                           @ByVal
                                                           GpuMat dst,
                                                           @ByVal
                                                           Rect rect)

normalize

@Namespace(value="cv::cuda")
public static void normalize(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat dst,
                                                          double alpha,
                                                          double beta,
                                                          int norm_type,
                                                          int dtype,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          Mat mask,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\brief Normalizes the norm or value range of an array.

Parameters:: 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.
See Also:: normalize

normalize

@Namespace(value="cv::cuda")
public static void normalize(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat dst,
                                                          double alpha,
                                                          double beta,
                                                          int norm_type,
                                                          int dtype)

normalize

@Namespace(value="cv::cuda")
public static void normalize(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat dst,
                                                          double alpha,
                                                          double beta,
                                                          int norm_type,
                                                          int dtype,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          UMat mask,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

normalize

@Namespace(value="cv::cuda")
public static void normalize(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat dst,
                                                          double alpha,
                                                          double beta,
                                                          int norm_type,
                                                          int dtype)

normalize

@Namespace(value="cv::cuda")
public static void normalize(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat dst,
                                                          double alpha,
                                                          double beta,
                                                          int norm_type,
                                                          int dtype,
                                                          @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                          GpuMat mask,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

normalize

@Namespace(value="cv::cuda")
public static void normalize(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat dst,
                                                          double alpha,
                                                          double beta,
                                                          int norm_type,
                                                          int dtype)

integral

@Namespace(value="cv::cuda")
public static void integral(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         Mat sum,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

\brief Computes an integral image.

Parameters:: 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.
See Also:: integral

integral

@Namespace(value="cv::cuda")
public static void integral(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         Mat sum)

integral

@Namespace(value="cv::cuda")
public static void integral(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat sum,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

integral

@Namespace(value="cv::cuda")
public static void integral(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat sum)

integral

@Namespace(value="cv::cuda")
public static void integral(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat sum,
                                                         @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                         Stream stream)

integral

@Namespace(value="cv::cuda")
public static void integral(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat sum)

sqrIntegral

@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat sqsum,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Computes a squared integral image.

Parameters:: 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.

sqrIntegral

@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat sqsum)

sqrIntegral

@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
                                                            UMat src,
                                                            @ByVal
                                                            UMat sqsum,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

sqrIntegral

@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
                                                            UMat src,
                                                            @ByVal
                                                            UMat sqsum)

sqrIntegral

@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
                                                            GpuMat src,
                                                            @ByVal
                                                            GpuMat sqsum,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

sqrIntegral

@Namespace(value="cv::cuda")
public static void sqrIntegral(@ByVal
                                                            GpuMat src,
                                                            @ByVal
                                                            GpuMat sqsum)

gemm

@Namespace(value="cv::cuda")
public static void gemm(@ByVal
                                                     Mat src1,
                                                     @ByVal
                                                     Mat src2,
                                                     double alpha,
                                                     @ByVal
                                                     Mat src3,
                                                     double beta,
                                                     @ByVal
                                                     Mat dst,
                                                     int flags,
                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                     Stream stream)

\} cudaarithm_reduce

\addtogroup cudaarithm_arithm \{

/** \brief Performs generalized matrix multiplication.

Parameters:

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 src3

stream - 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

 \[\texttt{dst} =  \texttt{alpha} \cdot \texttt{src1} ^T  \cdot \texttt{src2} +  \texttt{beta} \cdot \texttt{src3} ^T\]

\note Transposition operation doesn't support CV_64FC2 input type.

See Also:

gemm

gemm

@Namespace(value="cv::cuda")
public static void gemm(@ByVal
                                                     Mat src1,
                                                     @ByVal
                                                     Mat src2,
                                                     double alpha,
                                                     @ByVal
                                                     Mat src3,
                                                     double beta,
                                                     @ByVal
                                                     Mat dst)

gemm

@Namespace(value="cv::cuda")
public static void gemm(@ByVal
                                                     UMat src1,
                                                     @ByVal
                                                     UMat src2,
                                                     double alpha,
                                                     @ByVal
                                                     UMat src3,
                                                     double beta,
                                                     @ByVal
                                                     UMat dst,
                                                     int flags,
                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                     Stream stream)

gemm

@Namespace(value="cv::cuda")
public static void gemm(@ByVal
                                                     UMat src1,
                                                     @ByVal
                                                     UMat src2,
                                                     double alpha,
                                                     @ByVal
                                                     UMat src3,
                                                     double beta,
                                                     @ByVal
                                                     UMat dst)

gemm

@Namespace(value="cv::cuda")
public static void gemm(@ByVal
                                                     GpuMat src1,
                                                     @ByVal
                                                     GpuMat src2,
                                                     double alpha,
                                                     @ByVal
                                                     GpuMat src3,
                                                     double beta,
                                                     @ByVal
                                                     GpuMat dst,
                                                     int flags,
                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                     Stream stream)

gemm

@Namespace(value="cv::cuda")
public static void gemm(@ByVal
                                                     GpuMat src1,
                                                     @ByVal
                                                     GpuMat src2,
                                                     double alpha,
                                                     @ByVal
                                                     GpuMat src3,
                                                     double beta,
                                                     @ByVal
                                                     GpuMat dst)

mulSpectrums

@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
                                                             Mat src1,
                                                             @ByVal
                                                             Mat src2,
                                                             @ByVal
                                                             Mat dst,
                                                             int flags,
                                                             @Cast(value="bool")
                                                             boolean conjB,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

\brief Performs a per-element multiplication of two Fourier spectrums.

Parameters:

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.

See Also:

mulSpectrums

mulSpectrums

@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
                                                             Mat src1,
                                                             @ByVal
                                                             Mat src2,
                                                             @ByVal
                                                             Mat dst,
                                                             int flags)

mulSpectrums

@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
                                                             UMat src1,
                                                             @ByVal
                                                             UMat src2,
                                                             @ByVal
                                                             UMat dst,
                                                             int flags,
                                                             @Cast(value="bool")
                                                             boolean conjB,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

mulSpectrums

@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
                                                             UMat src1,
                                                             @ByVal
                                                             UMat src2,
                                                             @ByVal
                                                             UMat dst,
                                                             int flags)

mulSpectrums

@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
                                                             GpuMat src1,
                                                             @ByVal
                                                             GpuMat src2,
                                                             @ByVal
                                                             GpuMat dst,
                                                             int flags,
                                                             @Cast(value="bool")
                                                             boolean conjB,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

mulSpectrums

@Namespace(value="cv::cuda")
public static void mulSpectrums(@ByVal
                                                             GpuMat src1,
                                                             @ByVal
                                                             GpuMat src2,
                                                             @ByVal
                                                             GpuMat dst,
                                                             int flags)

mulAndScaleSpectrums

@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
                                                                     Mat src1,
                                                                     @ByVal
                                                                     Mat src2,
                                                                     @ByVal
                                                                     Mat dst,
                                                                     int flags,
                                                                     float scale,
                                                                     @Cast(value="bool")
                                                                     boolean conjB,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     Stream stream)

\brief Performs a per-element multiplication of two Fourier spectrums and scales the result.

Parameters:

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.

See Also:

mulSpectrums

mulAndScaleSpectrums

@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
                                                                     Mat src1,
                                                                     @ByVal
                                                                     Mat src2,
                                                                     @ByVal
                                                                     Mat dst,
                                                                     int flags,
                                                                     float scale)

mulAndScaleSpectrums

@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
                                                                     UMat src1,
                                                                     @ByVal
                                                                     UMat src2,
                                                                     @ByVal
                                                                     UMat dst,
                                                                     int flags,
                                                                     float scale,
                                                                     @Cast(value="bool")
                                                                     boolean conjB,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     Stream stream)

mulAndScaleSpectrums

@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
                                                                     UMat src1,
                                                                     @ByVal
                                                                     UMat src2,
                                                                     @ByVal
                                                                     UMat dst,
                                                                     int flags,
                                                                     float scale)

mulAndScaleSpectrums

@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
                                                                     GpuMat src1,
                                                                     @ByVal
                                                                     GpuMat src2,
                                                                     @ByVal
                                                                     GpuMat dst,
                                                                     int flags,
                                                                     float scale,
                                                                     @Cast(value="bool")
                                                                     boolean conjB,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     Stream stream)

mulAndScaleSpectrums

@Namespace(value="cv::cuda")
public static void mulAndScaleSpectrums(@ByVal
                                                                     GpuMat src1,
                                                                     @ByVal
                                                                     GpuMat src2,
                                                                     @ByVal
                                                                     GpuMat dst,
                                                                     int flags,
                                                                     float scale)

dft
```
@Namespace(value="cv::cuda")
public static void dft(@ByVal
                                                    Mat src,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByVal
                                                    Size dft_size,
                                                    int flags,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)
```
\brief Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.

Parameters:

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.

See Also:

dft

dft

@Namespace(value="cv::cuda")
public static void dft(@ByVal
                                                    Mat src,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByVal
                                                    Size dft_size)

dft

@Namespace(value="cv::cuda")
public static void dft(@ByVal
                                                    UMat src,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByVal
                                                    Size dft_size,
                                                    int flags,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

dft

@Namespace(value="cv::cuda")
public static void dft(@ByVal
                                                    UMat src,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByVal
                                                    Size dft_size)

dft

@Namespace(value="cv::cuda")
public static void dft(@ByVal
                                                    GpuMat src,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByVal
                                                    Size dft_size,
                                                    int flags,
                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                    Stream stream)

dft

@Namespace(value="cv::cuda")
public static void dft(@ByVal
                                                    GpuMat src,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByVal
                                                    Size dft_size)

createDFT
```
@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static DFT createDFT(@ByVal
                                                                           Size dft_size,
                                                                           int flags)
```
\brief Creates implementation for cuda::DFT.

Parameters:

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.

createConvolution

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static Convolution createConvolution(@ByVal(nullValue="cv::Size()")
                                                                                           Size user_block_size)

\brief Creates implementation for cuda::Convolution .

Parameters:: 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.

createConvolution

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static Convolution createConvolution()

Class opencv_cudaarithm

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.opencv.presets.opencv_cudaarithm

Methods inherited from class java.lang.Object

Constructor Detail

opencv_cudaarithm

Method Detail

add

add

add

add

add

add

subtract

subtract

subtract

subtract

subtract

subtract

multiply

multiply

multiply

multiply

multiply

multiply

divide

divide

divide

divide

divide

divide

absdiff

absdiff

absdiff

absdiff

absdiff

absdiff

abs

abs

abs

abs

abs

abs

sqr

sqr

sqr

sqr

sqr

sqr

sqrt

sqrt

sqrt

sqrt

sqrt

sqrt

exp

exp

exp

exp

exp

exp

log

log

log

log

log

log

pow

pow

pow

pow

pow

pow

compare

compare

compare

compare

compare

compare