public class opencv_cudaarithm extends opencv_cudaarithm
Constructor and Description |
---|
opencv_cudaarithm() |
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 |
inRange(GpuMat src,
Scalar lowerb,
Scalar upperb,
GpuMat dst) |
static void |
inRange(GpuMat src,
Scalar lowerb,
Scalar upperb,
GpuMat dst,
Stream stream) |
static void |
inRange(Mat src,
Scalar lowerb,
Scalar upperb,
Mat dst) |
static void |
inRange(Mat src,
Scalar lowerb,
Scalar upperb,
Mat dst,
Stream stream)
\brief Checks if array elements lie between two scalars.
|
static void |
inRange(UMat src,
Scalar lowerb,
Scalar upperb,
UMat dst) |
static void |
inRange(UMat src,
Scalar lowerb,
Scalar upperb,
UMat dst,
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 src,
GpuMat dst,
GpuMat mask) |
static void |
meanStdDev(GpuMat src,
GpuMat dst,
GpuMat mask,
Stream stream) |
static void |
meanStdDev(GpuMat mtx,
GpuMat dst,
Stream stream) |
static void |
meanStdDev(GpuMat mtx,
Scalar mean,
Scalar stddev) |
static void |
meanStdDev(GpuMat src,
Scalar mean,
Scalar stddev,
GpuMat mask) |
static void |
meanStdDev(Mat mtx,
Mat dst) |
static void |
meanStdDev(Mat src,
Mat dst,
Mat mask) |
static void |
meanStdDev(Mat src,
Mat dst,
Mat mask,
Stream stream)
\brief Computes a mean value and a standard deviation of matrix elements.
|
static void |
meanStdDev(Mat mtx,
Mat dst,
Stream stream)
\overload
|
static void |
meanStdDev(Mat mtx,
Scalar mean,
Scalar stddev)
\overload
|
static void |
meanStdDev(Mat src,
Scalar mean,
Scalar stddev,
Mat mask)
\overload
|
static void |
meanStdDev(UMat mtx,
Scalar mean,
Scalar stddev) |
static void |
meanStdDev(UMat src,
Scalar mean,
Scalar stddev,
UMat mask) |
static void |
meanStdDev(UMat mtx,
UMat dst) |
static void |
meanStdDev(UMat mtx,
UMat dst,
Stream stream) |
static void |
meanStdDev(UMat src,
UMat dst,
UMat mask) |
static void |
meanStdDev(UMat src,
UMat dst,
UMat mask,
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) |
map
@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_elem \{
/** \brief Computes a matrix-matrix or matrix-scalar sum.
src1
- First source matrix or scalar.src2
- Second source matrix or scalar. Matrix should have the same size and type as src1 .dst
- Destination matrix that has the same size and number of channels as the input array(s).
The depth is defined by dtype or src1 depth.mask
- Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.dtype
- Optional depth of the output array.stream
- Stream for the asynchronous version.
add
@Namespace(value="cv::cuda") public static void add(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void add(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void add(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
subtract
@Namespace(value="cv::cuda") public static void subtract(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void subtract(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void subtract(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
multiply
@Namespace(value="cv::cuda") public static void multiply(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void multiply(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void multiply(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
divide
@Namespace(value="cv::cuda") public static void divide(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void divide(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void divide(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
absdiff
@Namespace(value="cv::cuda") public static void absdiff(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void absdiff(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void absdiff(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") public static void abs(@ByVal Mat src, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.
abs
@Namespace(value="cv::cuda") public static void abs(@ByVal UMat src, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void abs(@ByVal GpuMat src, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void sqr(@ByVal Mat src, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void sqr(@ByVal UMat src, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void sqr(@ByVal GpuMat src, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void sqrt(@ByVal Mat src, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.
sqrt
@Namespace(value="cv::cuda") public static void sqrt(@ByVal UMat src, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void sqrt(@ByVal GpuMat src, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void exp(@ByVal Mat src, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.
exp
@Namespace(value="cv::cuda") public static void exp(@ByVal UMat src, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void exp(@ByVal GpuMat src, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void log(@ByVal Mat src, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.
log
@Namespace(value="cv::cuda") public static void log(@ByVal UMat src, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void log(@ByVal GpuMat src, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void pow(@ByVal Mat src, double power, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.power
- Exponent of power.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.
The function pow raises every element of the input matrix to power :
\[\texttt{dst} (I) = \fork{\texttt{src}(I)^power}{if \texttt{power} is integer}{|\texttt{src}(I)|^power}{otherwise}\]
pow
@Namespace(value="cv::cuda") public static void pow(@ByVal Mat src, double power, @ByVal Mat dst)
@Namespace(value="cv::cuda") public static void pow(@ByVal UMat src, double power, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void pow(@ByVal UMat src, double power, @ByVal UMat dst)
@Namespace(value="cv::cuda") public static void pow(@ByVal GpuMat src, double power, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void pow(@ByVal GpuMat src, double power, @ByVal GpuMat dst)
@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)
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.
compare
@Namespace(value="cv::cuda") public static void compare(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst, int cmpop)
@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)
@Namespace(value="cv::cuda") public static void compare(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst, int cmpop)
@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)
@Namespace(value="cv::cuda") public static void compare(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst, int cmpop)
@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)
src
- Source matrix.dst
- Destination matrix with the same size and type as src .mask
- Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void bitwise_not(@ByVal Mat src, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_not(@ByVal UMat src, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_not(@ByVal GpuMat src, @ByVal GpuMat dst)
@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)
src1
- First source matrix or scalar.src2
- Second source matrix or scalar.dst
- Destination matrix that has the same size and type as the input array(s).mask
- Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void bitwise_or(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_or(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_or(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
src1
- First source matrix or scalar.src2
- Second source matrix or scalar.dst
- Destination matrix that has the same size and type as the input array(s).mask
- Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void bitwise_and(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_and(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_and(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
src1
- First source matrix or scalar.src2
- Second source matrix or scalar.dst
- Destination matrix that has the same size and type as the input array(s).mask
- Optional operation mask, 8-bit single channel array, that specifies elements of the
destination array to be changed. The mask can be used only with single channel images.stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void bitwise_xor(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_xor(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void bitwise_xor(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
src
- Source matrix. Supports 1, 3 and 4 channels images with integers elements.val
- Constant values, one per channel.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void rshift(@ByVal Mat src, @ByVal Scalar4i val, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void rshift(@ByVal UMat src, @ByVal Scalar4i val, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void rshift(@ByVal GpuMat src, @ByVal Scalar4i val, @ByVal GpuMat dst)
@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)
@Namespace(value="cv::cuda") public static void rshift(@ByVal Mat src, @ByVal Scalar val, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void rshift(@ByVal UMat src, @ByVal Scalar val, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void rshift(@ByVal GpuMat src, @ByVal Scalar val, @ByVal GpuMat dst)
@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)
src
- Source matrix. Supports 1, 3 and 4 channels images with CV_8U , CV_16U or CV_32S
depth.val
- Constant values, one per channel.dst
- Destination matrix with the same size and type as src .stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void lshift(@ByVal Mat src, @ByVal Scalar4i val, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void lshift(@ByVal UMat src, @ByVal Scalar4i val, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void lshift(@ByVal GpuMat src, @ByVal Scalar4i val, @ByVal GpuMat dst)
@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)
@Namespace(value="cv::cuda") public static void lshift(@ByVal Mat src, @ByVal Scalar val, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void lshift(@ByVal UMat src, @ByVal Scalar val, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void lshift(@ByVal GpuMat src, @ByVal Scalar val, @ByVal GpuMat dst)
@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)
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.
min
@Namespace(value="cv::cuda") public static void min(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void min(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void min(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
max
@Namespace(value="cv::cuda") public static void max(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void max(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void max(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
addWeighted
@Namespace(value="cv::cuda") public static void addWeighted(@ByVal Mat src1, double alpha, @ByVal Mat src2, double beta, double gamma, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void addWeighted(@ByVal UMat src1, double alpha, @ByVal UMat src2, double beta, double gamma, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void addWeighted(@ByVal GpuMat src1, double alpha, @ByVal GpuMat src2, double beta, double gamma, @ByVal GpuMat dst)
@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)
@Namespace(value="cv::cuda") public static void scaleAdd(@ByVal Mat src1, double alpha, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void scaleAdd(@ByVal UMat src1, double alpha, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void scaleAdd(@ByVal GpuMat src1, double alpha, @ByVal GpuMat src2, @ByVal GpuMat dst)
@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)
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.
threshold
@Namespace(value="cv::cuda") public static double threshold(@ByVal Mat src, @ByVal Mat dst, double thresh, double maxval, int type)
@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)
@Namespace(value="cv::cuda") public static double threshold(@ByVal UMat src, @ByVal UMat dst, double thresh, double maxval, int type)
@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)
@Namespace(value="cv::cuda") public static double threshold(@ByVal GpuMat src, @ByVal GpuMat dst, double thresh, double maxval, int type)
@Namespace(value="cv::cuda") public static void inRange(@ByVal Mat src, @Const @ByRef Scalar lowerb, @Const @ByRef Scalar upperb, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
The function checks the range as follows: - For every element of a single-channel input array:
\[\texttt{dst} (I)= \texttt{lowerb}_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb}_0\]
- For two-channel arrays:
\[\texttt{dst} (I)= \texttt{lowerb}_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb}_0 \land \texttt{lowerb}_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb}_1\]
- and so forth.
That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the specified 1D, 2D, 3D, ... box and 0 otherwise.
Note that unlike the CPU inRange, this does NOT accept an array for lowerb or upperb, only a cv::Scalar.
src
- first input array.lowerb
- inclusive lower boundary cv::Scalar.upperb
- inclusive upper boundary cv::Scalar.dst
- output array of the same size as src and CV_8U type.stream
- Stream for the asynchronous version.
cv::inRange
@Namespace(value="cv::cuda") public static void inRange(@ByVal Mat src, @Const @ByRef Scalar lowerb, @Const @ByRef Scalar upperb, @ByVal Mat dst)
@Namespace(value="cv::cuda") public static void inRange(@ByVal UMat src, @Const @ByRef Scalar lowerb, @Const @ByRef Scalar upperb, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void inRange(@ByVal UMat src, @Const @ByRef Scalar lowerb, @Const @ByRef Scalar upperb, @ByVal UMat dst)
@Namespace(value="cv::cuda") public static void inRange(@ByVal GpuMat src, @Const @ByRef Scalar lowerb, @Const @ByRef Scalar upperb, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void inRange(@ByVal GpuMat src, @Const @ByRef Scalar lowerb, @Const @ByRef Scalar upperb, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal Mat xy, @ByVal Mat magnitude, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
xy
- Source complex matrix in the interleaved format ( CV_32FC2 ).magnitude
- Destination matrix of float magnitudes ( CV_32FC1 ).stream
- Stream for the asynchronous version.
magnitude
@Namespace(value="cv::cuda") public static void magnitude(@ByVal Mat xy, @ByVal Mat magnitude)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal UMat xy, @ByVal UMat magnitude, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal UMat xy, @ByVal UMat magnitude)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal GpuMat xy, @ByVal GpuMat magnitude, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal GpuMat xy, @ByVal GpuMat magnitude)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal Mat xy, @ByVal Mat magnitude, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
xy
- Source complex matrix in the interleaved format ( CV_32FC2 ).magnitude
- Destination matrix of float magnitude squares ( CV_32FC1 ).stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal Mat xy, @ByVal Mat magnitude)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal UMat xy, @ByVal UMat magnitude, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal UMat xy, @ByVal UMat magnitude)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal GpuMat xy, @ByVal GpuMat magnitude, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal GpuMat xy, @ByVal GpuMat 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)
x
- Source matrix containing real components ( CV_32FC1 ).y
- Source matrix containing imaginary components ( CV_32FC1 ).magnitude
- Destination matrix of float magnitudes ( CV_32FC1 ).stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void magnitude(@ByVal Mat x, @ByVal Mat y, @ByVal Mat 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)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal UMat x, @ByVal UMat y, @ByVal UMat 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)
@Namespace(value="cv::cuda") public static void magnitude(@ByVal GpuMat x, @ByVal GpuMat y, @ByVal GpuMat magnitude)
@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)
x
- Source matrix containing real components ( CV_32FC1 ).y
- Source matrix containing imaginary components ( CV_32FC1 ).magnitude
- Destination matrix of float magnitude squares ( CV_32FC1 ).stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal Mat x, @ByVal Mat y, @ByVal Mat magnitude)
@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)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal UMat x, @ByVal UMat y, @ByVal UMat magnitude)
@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)
@Namespace(value="cv::cuda") public static void magnitudeSqr(@ByVal GpuMat x, @ByVal GpuMat y, @ByVal GpuMat magnitude)
@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)
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.
phase
@Namespace(value="cv::cuda") public static void phase(@ByVal Mat x, @ByVal Mat y, @ByVal Mat angle)
@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)
@Namespace(value="cv::cuda") public static void phase(@ByVal UMat x, @ByVal UMat y, @ByVal UMat angle)
@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)
@Namespace(value="cv::cuda") public static void phase(@ByVal GpuMat x, @ByVal GpuMat y, @ByVal GpuMat angle)
@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)
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.
cartToPolar
@Namespace(value="cv::cuda") public static void cartToPolar(@ByVal Mat x, @ByVal Mat y, @ByVal Mat magnitude, @ByVal Mat angle)
@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)
@Namespace(value="cv::cuda") public static void cartToPolar(@ByVal UMat x, @ByVal UMat y, @ByVal UMat magnitude, @ByVal UMat angle)
@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)
@Namespace(value="cv::cuda") public static void cartToPolar(@ByVal GpuMat x, @ByVal GpuMat y, @ByVal GpuMat magnitude, @ByVal GpuMat angle)
@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)
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.@Namespace(value="cv::cuda") public static void polarToCart(@ByVal Mat magnitude, @ByVal Mat angle, @ByVal Mat x, @ByVal Mat y)
@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)
@Namespace(value="cv::cuda") public static void polarToCart(@ByVal UMat magnitude, @ByVal UMat angle, @ByVal UMat x, @ByVal UMat y)
@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)
@Namespace(value="cv::cuda") public static void polarToCart(@ByVal GpuMat magnitude, @ByVal GpuMat angle, @ByVal GpuMat x, @ByVal GpuMat y)
@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)
\addtogroup cudaarithm_core \{
/** \brief Makes a multi-channel matrix out of several single-channel matrices.
src
- Array/vector of source matrices.n
- Number of source matrices.dst
- Destination matrix.stream
- Stream for the asynchronous version.
merge
@Namespace(value="cv::cuda") public static void merge(@Const GpuMat src, @Cast(value="size_t") long n, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void merge(@Const GpuMat src, @Cast(value="size_t") long n, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void merge(@Const GpuMat src, @Cast(value="size_t") long n, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") public static void merge(@Const @ByRef GpuMatVector src, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void merge(@Const @ByRef GpuMatVector src, @ByVal Mat dst)
@Namespace(value="cv::cuda") public static void merge(@Const @ByRef GpuMatVector src, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void merge(@Const @ByRef GpuMatVector src, @ByVal UMat dst)
@Namespace(value="cv::cuda") public static void merge(@Const @ByRef GpuMatVector src, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void merge(@Const @ByRef GpuMatVector src, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") public static void split(@ByVal Mat src, GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix.dst
- Destination array/vector of single-channel matrices.stream
- Stream for the asynchronous version.
split
@Namespace(value="cv::cuda") public static void split(@ByVal Mat src, GpuMat dst)
@Namespace(value="cv::cuda") public static void split(@ByVal UMat src, GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void split(@ByVal UMat src, GpuMat dst)
@Namespace(value="cv::cuda") public static void split(@ByVal GpuMat src, GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void split(@ByVal GpuMat src, GpuMat dst)
@Namespace(value="cv::cuda") public static void split(@ByVal Mat src, @ByRef GpuMatVector dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void split(@ByVal Mat src, @ByRef GpuMatVector dst)
@Namespace(value="cv::cuda") public static void split(@ByVal UMat src, @ByRef GpuMatVector dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void split(@ByVal UMat src, @ByRef GpuMatVector dst)
@Namespace(value="cv::cuda") public static void split(@ByVal GpuMat src, @ByRef GpuMatVector dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void split(@ByVal GpuMat src, @ByRef GpuMatVector dst)
@Namespace(value="cv::cuda") public static void transpose(@ByVal Mat src1, @ByVal Mat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src1
- Source matrix. 1-, 4-, 8-byte element sizes are supported for now.dst
- Destination matrix.stream
- Stream for the asynchronous version.
transpose
@Namespace(value="cv::cuda") public static void transpose(@ByVal Mat src1, @ByVal Mat dst)
@Namespace(value="cv::cuda") public static void transpose(@ByVal UMat src1, @ByVal UMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void transpose(@ByVal UMat src1, @ByVal UMat dst)
@Namespace(value="cv::cuda") public static void transpose(@ByVal GpuMat src1, @ByVal GpuMat dst, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void transpose(@ByVal GpuMat src1, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") public static void flip(@ByVal Mat src, @ByVal Mat dst, int flipCode, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
src
- Source matrix. Supports 1, 3 and 4 channels images with CV_8U, CV_16U, CV_32S or
CV_32F depth.dst
- Destination matrix.flipCode
- Flip mode for the source:
- 0 Flips around x-axis.
- \> 0 Flips around y-axis.
- \< 0 Flips around both axes.stream
- Stream for the asynchronous version.
flip
@Namespace(value="cv::cuda") public static void flip(@ByVal Mat src, @ByVal Mat dst, int flipCode)
@Namespace(value="cv::cuda") public static void flip(@ByVal UMat src, @ByVal UMat dst, int flipCode, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void flip(@ByVal UMat src, @ByVal UMat dst, int flipCode)
@Namespace(value="cv::cuda") public static void flip(@ByVal GpuMat src, @ByVal GpuMat dst, int flipCode, @ByRef(nullValue="cv::cuda::Stream::Null()") Stream stream)
@Namespace(value="cv::cuda") public static void flip(@ByVal GpuMat src, @ByVal GpuMat dst, int flipCode)
@Namespace(value="cv::cuda") @opencv_core.Ptr public static LookUpTable createLookUpTable(@ByVal Mat lut)
lut
- Look-up table of 256 elements. It is a continuous CV_8U matrix.@Namespace(value="cv::cuda") @opencv_core.Ptr public static LookUpTable createLookUpTable(@ByVal UMat lut)
@Namespace(value="cv::cuda") @opencv_core.Ptr public static LookUpTable createLookUpTable(@ByVal GpuMat lut)
@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)
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 pixelsbottom
- Number of bottom pixelsleft
- Number of left pixelsright
- Number of pixels in each direction from the source image rectangle to extrapolate.
For example: top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs to be built.borderType
- Border type. See borderInterpolate for details. BORDER_REFLECT101 ,
BORDER_REPLICATE , BORDER_CONSTANT , BORDER_REFLECT and BORDER_WRAP are supported for now.value
- Border value.stream
- Stream for the asynchronous version.@Namespace(value="cv::cuda") public static void copyMakeBorder(@ByVal Mat src, @ByVal Mat dst, int top, int bottom, int left, int right, int borderType)
@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)
@Namespace(value="cv::cuda") public static void copyMakeBorder(@ByVal UMat src, @ByVal UMat dst, int top, int bottom, int left, int right, int borderType)
@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)
@Namespace(value="cv::cuda") public static void copyMakeBorder(@ByVal GpuMat src, @ByVal GpuMat dst, int top, int bottom, int left, int right, int borderType)
@Namespace(value="cv::cuda") public static double norm(@ByVal Mat src1, int normType, @ByVal(nullValue="cv::InputArray(cv::noArray())") Mat mask)
\addtogroup cudaarithm_reduce \{
/** \brief Returns the norm of a matrix (or difference of two matrices).
src1
- Source matrix. Any matrices except 64F are supported.normType
- Norm type. NORM_L1 , NORM_L2 , and NORM_INF are supported for now.mask
- optional operation mask; it must have the same size as src1 and CV_8UC1 type.
norm
@Namespace(value="cv::cuda") public static double norm(@ByVal Mat src1, int normType)
@Namespace(value="cv::cuda") public static double norm(@ByVal UMat src1, int normType, @ByVal(nullValue="cv::InputArray(cv::noArray())") UMat mask)
@Namespace(value="cv::cuda") public static double norm(@ByVal UMat src1, int normType)
@Namespace(value="cv::cuda") public static double norm(@ByVal GpuMat src1, int normType, @ByVal(nullValue="cv::InputArray(cv::noArray())") GpuMat mask)
@Namespace(value="cv::cuda") public static double norm(@ByVal GpuMat src1, int normType)
@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)
@Namespace(value="cv::cuda") public static void calcNorm(@ByVal Mat src, @ByVal Mat dst, int normType)
@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)
@Namespace(value="cv::cuda") public static void calcNorm(@ByVal UMat src, @ByVal UMat dst, int normType)
@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)
@Namespace(value="cv::cuda") public static void calcNorm(@ByVal GpuMat src, @ByVal GpuMat dst, int normType)
@Namespace(value="cv::cuda") public static double norm(@ByVal Mat src1, @ByVal Mat src2, int normType)
src1
- Source matrix. Any matrices except 64F are supported.src2
- Second source matrix (if any) with the same size and type as src1.normType
- Norm type. NORM_L1 , NORM_L2 , and NORM_INF are supported for now.
norm
@Namespace(value="cv::cuda") public static double norm(@ByVal UMat src1, @ByVal UMat src2, int normType)
@Namespace(value="cv::cuda") public static double norm(@ByVal GpuMat src1, @ByVal GpuMat src2, int normType)
@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)
@Namespace(value="cv::cuda") public static void calcNormDiff(@ByVal Mat src1, @ByVal Mat src2, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void calcNormDiff(@ByVal UMat src1, @ByVal UMat src2, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void calcNormDiff(@ByVal GpuMat src1, @ByVal GpuMat src2, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") @ByVal public static Scalar sum(@ByVal Mat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") Mat mask)
src
- Source image of any depth except for CV_64F .mask
- optional operation mask; it must have the same size as src1 and CV_8UC1 type.
sum
@Namespace(value="cv::cuda") @ByVal public static Scalar sum(@ByVal UMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") UMat mask)
@Namespace(value="cv::cuda") @ByVal public static Scalar sum(@ByVal GpuMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") GpuMat mask)
@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)
@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)
@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)
@Namespace(value="cv::cuda") public static void calcSum(@ByVal GpuMat src, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") @ByVal public static Scalar absSum(@ByVal Mat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") Mat mask)
src
- Source image of any depth except for CV_64F .mask
- optional operation mask; it must have the same size as src1 and CV_8UC1 type.@Namespace(value="cv::cuda") @ByVal public static Scalar absSum(@ByVal UMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") UMat mask)
@Namespace(value="cv::cuda") @ByVal public static Scalar absSum(@ByVal GpuMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") GpuMat mask)
@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)
@Namespace(value="cv::cuda") public static void calcAbsSum(@ByVal Mat src, @ByVal Mat dst)
@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)
@Namespace(value="cv::cuda") public static void calcAbsSum(@ByVal UMat src, @ByVal UMat dst)
@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)
@Namespace(value="cv::cuda") public static void calcAbsSum(@ByVal GpuMat src, @ByVal GpuMat dst)
@Namespace(value="cv::cuda") @ByVal public static Scalar sqrSum(@ByVal Mat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") Mat mask)
src
- Source image of any depth except for CV_64F .mask
- optional operation mask; it must have the same size as src1 and CV_8UC1 type.@Namespace(value="cv::cuda") @ByVal public static Scalar sqrSum(@ByVal UMat src, @ByVal(nullValue="cv::InputArray(cv::noArray())") UMat mask)