Per-element Operations

Overview

// global functions

void
cv::cuda::abs(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::absdiff(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::add(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    int dtype = -1,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::addWeighted(
    InputArray src1,
    double alpha,
    InputArray src2,
    double beta,
    double gamma,
    OutputArray dst,
    int dtype = -1,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::bitwise_and(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    );

void
cv::cuda::bitwise_not(
    InputArray src,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    );

void
cv::cuda::bitwise_or(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    );

void
cv::cuda::bitwise_xor(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    );

void
cv::cuda::cartToPolar(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    OutputArray angle,
    bool angleInDegrees = false,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::compare(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    int cmpop,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::divide(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    double scale = 1,
    int dtype = -1,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::exp(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::log(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::lshift(
    InputArray src,
    Scalar_<int> val,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::magnitude(
    InputArray xy,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::magnitude(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::magnitudeSqr(
    InputArray xy,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::magnitudeSqr(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::max(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::min(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::multiply(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    double scale = 1,
    int dtype = -1,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::phase(
    InputArray x,
    InputArray y,
    OutputArray angle,
    bool angleInDegrees = false,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::polarToCart(
    InputArray magnitude,
    InputArray angle,
    OutputArray x,
    OutputArray y,
    bool angleInDegrees = false,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::pow(
    InputArray src,
    double power,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::rshift(
    InputArray src,
    Scalar_<int> val,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

static
void
cv::cuda::scaleAdd(
    InputArray src1,
    double alpha,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::sqr(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::sqrt(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    );

void
cv::cuda::subtract(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    int dtype = -1,
    Stream& stream = Stream::Null()
    );

double
cv::cuda::threshold(
    InputArray src,
    OutputArray dst,
    double thresh,
    double maxval,
    int type,
    Stream& stream = Stream::Null()
    );

Detailed Documentation

Global Functions

void
cv::cuda::abs(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::absdiff(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::add(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    int dtype = -1,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::addWeighted(
    InputArray src1,
    double alpha,
    InputArray src2,
    double beta,
    double gamma,
    OutputArray dst,
    int dtype = -1,
    Stream& stream = Stream::Null()
    )

Computes the weighted sum of two arrays.

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.

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.

See also:

addWeighted

void
cv::cuda::bitwise_and(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::bitwise_not(
    InputArray src,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::bitwise_or(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::bitwise_xor(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::cartToPolar(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    OutputArray angle,
    bool angleInDegrees = false,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::compare(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    int cmpop,
    Stream& stream = Stream::Null()
    )

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 and type as the input array(s).
cmpop	Flag specifying the relation between the elements to be checked: CMP_EQ: a(.) == b(.) CMP_GT: a(.) > b(.) CMP_GE: a(.) >= b(.) CMP_LT: a(.) < b(.) CMP_LE: a(.) <= b(.) CMP_NE: a(.) != b(.)
stream	Stream for the asynchronous version.

See also:

compare

void
cv::cuda::divide(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    double scale = 1,
    int dtype = -1,
    Stream& stream = Stream::Null()
    )

Computes a matrix-matrix or matrix-scalar division.

This function, in contrast to divide, uses a round-down rounding mode.

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.

See also:

divide

void
cv::cuda::exp(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::log(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::lshift(
    InputArray src,
    Scalar_<int> val,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::magnitude(
    InputArray xy,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::magnitude(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 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.

void
cv::cuda::magnitudeSqr(
    InputArray xy,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::magnitudeSqr(
    InputArray x,
    InputArray y,
    OutputArray magnitude,
    Stream& stream = Stream::Null()
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 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.

void
cv::cuda::max(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::min(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::multiply(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    double scale = 1,
    int dtype = -1,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::phase(
    InputArray x,
    InputArray y,
    OutputArray angle,
    bool angleInDegrees = false,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::polarToCart(
    InputArray magnitude,
    InputArray angle,
    OutputArray x,
    OutputArray y,
    bool angleInDegrees = false,
    Stream& stream = Stream::Null()
    )

Converts polar coordinates into Cartesian.

Parameters:

magnitude	Source matrix containing magnitudes ( CV_32FC1 ).
angle	Source matrix containing angles ( CV_32FC1 ).
x	Destination matrix of real components ( CV_32FC1 ).
y	Destination matrix of imaginary components ( CV_32FC1 ).
angleInDegrees	Flag that indicates angles in degrees.
stream	Stream for the asynchronous version.

void
cv::cuda::pow(
    InputArray src,
    double power,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

Raises every matrix element to a power.

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}\]

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.

See also:

pow

void
cv::cuda::rshift(
    InputArray src,
    Scalar_<int> val,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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.

static
void
cv::cuda::scaleAdd(
    InputArray src1,
    double alpha,
    InputArray src2,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::sqr(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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.

void
cv::cuda::sqrt(
    InputArray src,
    OutputArray dst,
    Stream& stream = Stream::Null()
    )

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

void
cv::cuda::subtract(
    InputArray src1,
    InputArray src2,
    OutputArray dst,
    InputArray mask = noArray(),
    int dtype = -1,
    Stream& stream = Stream::Null()
    )

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

double
cv::cuda::threshold(
    InputArray src,
    OutputArray dst,
    double thresh,
    double maxval,
    int type,
    Stream& stream = Stream::Null()
    )

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