Operations on Matrices

gpu::gemm

Performs generalized matrix multiplication.

C++: void gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags=0, Stream& stream=Stream::Null())
Parameters:
  • src1 – First multiplied input matrix that should have CV_32FC1 , CV_64FC1 , CV_32FC2 , or CV_64FC2 type.
  • src2 – Second multiplied input matrix of the same type as src1 .
  • alpha – Weight of the matrix product.
  • src3 – Third optional delta matrix added to the matrix product. It should have the same type as src1 and src2 .
  • beta – Weight of src3 .
  • dst – Destination matrix. It has the proper size and the same type as input matrices.
  • flags

    Operation flags:

    • GEMM_1_T transpose src1
    • GEMM_2_T transpose src2
    • GEMM_3_T transpose src3
  • stream – Stream for the asynchronous version.

The function performs generalized matrix multiplication similar to the gemm functions in BLAS level 3. For example, gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) corresponds to

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

Note

Transposition operation doesn’t support CV_64FC2 input type.

See also

gemm()

gpu::transpose

Transposes a matrix.

C++: void gpu::transpose(const GpuMat& src1, GpuMat& dst, Stream& stream=Stream::Null() )
Parameters:
  • src1 – Source matrix. 1-, 4-, 8-byte element sizes are supported for now (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc).
  • dst – Destination matrix.
  • stream – Stream for the asynchronous version.

See also

transpose()

gpu::flip

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

C++: void gpu::flip(const GpuMat& a, GpuMat& b, int flipCode, Stream& stream=Stream::Null() )
Parameters:
  • a – Source matrix. Supports 1, 3 and 4 channels images with CV_8U, CV_16U, CV_32S or CV_32F depth.
  • b – Destination matrix.
  • flipCode

    Flip mode for the source:

    • 0 Flips around x-axis.
    • >0 Flips around y-axis.
    • <0 Flips around both axes.
  • stream – Stream for the asynchronous version.

See also

flip()

gpu::LUT

Transforms the source matrix into the destination matrix using the given look-up table: dst(I) = lut(src(I))

C++: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream=Stream::Null())
Parameters:
  • src – Source matrix. CV_8UC1 and CV_8UC3 matrices are supported for now.
  • lut – Look-up table of 256 elements. It is a continuous CV_8U matrix.
  • dst – Destination matrix with the same depth as lut and the same number of channels as src .
  • stream – Stream for the asynchronous version.

See also

LUT()

gpu::merge

Makes a multi-channel matrix out of several single-channel matrices.

C++: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream=Stream::Null())
C++: void gpu::merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream=Stream::Null())
Parameters:
  • src – Array/vector of source matrices.
  • n – Number of source matrices.
  • dst – Destination matrix.
  • stream – Stream for the asynchronous version.

See also

merge()

gpu::split

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

C++: void gpu::split(const GpuMat& src, GpuMat* dst, Stream& stream=Stream::Null())
C++: void gpu::split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream=Stream::Null())
Parameters:
  • src – Source matrix.
  • dst – Destination array/vector of single-channel matrices.
  • stream – Stream for the asynchronous version.

See also

split()

gpu::magnitude

Computes magnitudes of complex matrix elements.

C++: void gpu::magnitude(const GpuMat& xy, GpuMat& magnitude, Stream& stream=Stream::Null() )
C++: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream=Stream::Null())
Parameters:
  • xy – Source complex matrix in the interleaved format ( CV_32FC2 ).
  • 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.

See also

magnitude()

gpu::magnitudeSqr

Computes squared magnitudes of complex matrix elements.

C++: void gpu::magnitudeSqr(const GpuMat& xy, GpuMat& magnitude, Stream& stream=Stream::Null() )
C++: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream=Stream::Null())
Parameters:
  • xy – Source complex matrix in the interleaved format ( CV_32FC2 ).
  • 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.

gpu::phase

Computes polar angles of complex matrix elements.

C++: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false, Stream& stream=Stream::Null())
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()

gpu::cartToPolar

Converts Cartesian coordinates into polar.

C++: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false, Stream& stream=Stream::Null())
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()

gpu::polarToCart

Converts polar coordinates into Cartesian.

C++: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false, Stream& stream=Stream::Null())
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.

See also

polarToCart()

gpu::normalize

Normalizes the norm or value range of an array.

C++: void gpu::normalize(const GpuMat& src, GpuMat& dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, const GpuMat& mask=GpuMat())
C++: void gpu::normalize(const GpuMat& src, GpuMat& dst, double a, double b, int norm_type, int dtype, const GpuMat& mask, GpuMat& norm_buf, GpuMat& cvt_buf)
Parameters:
  • src – input array.
  • dst – output array of the same size as src .
  • alpha – norm value to normalize to or the lower range boundary in case of the range normalization.
  • beta – upper range boundary in case of the range normalization; it is not used for the norm normalization.
  • normType – normalization type (see the details below).
  • dtype – when negative, the output array has the same type as src; otherwise, it has the same number of channels as src and the depth =CV_MAT_DEPTH(dtype).
  • mask – optional operation mask.
  • norm_buf – Optional buffer to avoid extra memory allocations. It is resized automatically.
  • cvt_buf – Optional buffer to avoid extra memory allocations. It is resized automatically.

See also

normalize()