Matrix expression representation. More...

#include <opencv2/core/mat.hpp>

Collaboration diagram for cv::MatExpr:

[legend]

Public Member Functions
	MatExpr ()

	MatExpr (const Mat &m)

	MatExpr (const MatOp *_op, int _flags, const Mat &_a=Mat(), const Mat &_b=Mat(), const Mat &_c=Mat(), double _alpha=1, double _beta=1, const Scalar &_s=Scalar())

MatExpr	col (int x) const

Mat	cross (const Mat &m) const

MatExpr	diag (int d=0) const

double	dot (const Mat &m) const

MatExpr	inv (int method=DECOMP_LU) const

MatExpr	mul (const MatExpr &e, double scale=1) const

MatExpr	mul (const Mat &m, double scale=1) const

	operator Mat () const

template<typename _Tp >
	operator Mat_< _Tp > () const

MatExpr	operator() (const Range &rowRange, const Range &colRange) const

MatExpr	operator() (const Rect &roi) const

MatExpr	row (int y) const

Size	size () const

MatExpr	t () const

int	type () const

Public Attributes
Mat	a

double	alpha

Mat	b

double	beta

Mat	c

int	flags

const MatOp *	op

Scalar	s

Related Functions
(Note that these are not member functions.)

MatExpr	operator+ (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const Mat &a, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const Scalar &s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const MatExpr &e, const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const Mat &m, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const MatExpr &e, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const Scalar &s, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator+ (const MatExpr &e1, const MatExpr &e2)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator+ (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator+ (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const Mat &a, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const Scalar &s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const MatExpr &e, const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const Mat &m, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const MatExpr &e, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const Scalar &s, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const MatExpr &e1, const MatExpr &e2)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator- (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator- (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator- (const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (const MatExpr &e, const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (const Mat &m, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (const MatExpr &e, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (double s, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator* (const MatExpr &e1, const MatExpr &e2)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator* (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator* (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (const MatExpr &e, const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (const Mat &m, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (const MatExpr &e, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (double s, const MatExpr &e)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator/ (const MatExpr &e1, const MatExpr &e2)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator/ (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator/ (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator< (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator< (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator< (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator< (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator< (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator<= (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator<= (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator<= (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator<= (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator<= (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator== (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator== (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator== (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator== (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator== (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator!= (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator!= (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator!= (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator!= (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator!= (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator>= (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator>= (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator>= (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator>= (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator>= (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator> (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator> (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator> (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator> (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator> (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator & (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator & (const Mat &a, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator & (const Scalar &s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator & (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator & (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator\| (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator\| (const Mat &a, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator\| (const Scalar &s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator\| (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator\| (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator^ (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator^ (const Mat &a, const Scalar &s)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator^ (const Scalar &s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator^ (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	operator^ (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	operator~ (const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	min (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	min (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	min (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	min (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	min (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	max (const Mat &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	max (const Mat &a, double s)
	Calculates an absolute value of each matrix element. More...

MatExpr	max (double s, const Mat &a)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	max (const Mat &a, const Matx< _Tp, m, n > &b)
	Calculates an absolute value of each matrix element. More...

template<typename _Tp , int m, int n>
static MatExpr	max (const Matx< _Tp, m, n > &a, const Mat &b)
	Calculates an absolute value of each matrix element. More...

MatExpr	abs (const Mat &m)
	Calculates an absolute value of each matrix element. More...

MatExpr	abs (const MatExpr &e)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

Detailed Description

Matrix expression representation.

This is a list of implemented matrix operations that can be combined in arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double )):

Addition, subtraction, negation: A+B, A-B, A+s, A-s, s+A, s-A, -A
Scaling: A*alpha
Per-element multiplication and division: A.mul(B), A/B, alpha/A
Matrix multiplication: A*B
Transposition: A.t() (means A^T)
Matrix inversion and pseudo-inversion, solving linear systems and least-squares problems: A.inv([method]) (~ A<sup>-1</sup>), A.inv([method])*B (~ X: AX=B)
Comparison: A cmpop B, A cmpop alpha, alpha cmpop A, where cmpop is one of >, >=, ==, !=, <=, <. The result of comparison is an 8-bit single channel mask whose elements are set to 255 (if the particular element or pair of elements satisfy the condition) or 0.
Bitwise logical operations: A logicop B, A logicop s, s logicop A, ~A, where logicop is one of &, |, ^.
Element-wise minimum and maximum: min(A, B), min(A, alpha), max(A, B), max(A, alpha)
Element-wise absolute value: abs(A)
Cross-product, dot-product: A.cross(B), A.dot(B)
Any function of matrix or matrices and scalars that returns a matrix or a scalar, such as norm, mean, sum, countNonZero, trace, determinant, repeat, and others.
Matrix initializers ( Mat::eye(), Mat::zeros(), Mat::ones() ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see Mat description).
Mat_<destination_type>() constructors to cast the result to the proper type.
Note
Comma-separated initializers and probably some other operations may require additional explicit Mat() or Mat_<T>() constructor calls to resolve a possible ambiguity.
Here are examples of matrix expressions:
// compute pseudo-inverse of A, equivalent to A.inv(DECOMP_SVD)
SVD svd(A);
Mat pinvA = svd.vt.t()*Mat::diag(1./svd.w)*svd.u.t();
// compute the new vector of parameters in the Levenberg-Marquardt algorithm
x -= (A.t()*A + lambda*Mat::eye(A.cols,A.cols,A.type())).inv(DECOMP_CHOLESKY)*(A.t()*err);
// sharpen image using "unsharp mask" algorithm
Mat blurred; double sigma = 1, threshold = 5, amount = 1;
GaussianBlur(img, blurred, Size(), sigma, sigma);
Mat lowContrastMask = abs(img - blurred) < threshold;
Mat sharpened = img*(1+amount) + blurred*(-amount);
img.copyTo(sharpened, lowContrastMask);

Constructor & Destructor Documentation

◆ MatExpr() [1/3]

cv::MatExpr::MatExpr ( )

◆ MatExpr() [2/3]

cv::MatExpr::MatExpr ( const Mat & m )

explicit

◆ MatExpr() [3/3]

cv::MatExpr::MatExpr	(	const MatOp *	_op,
		int	_flags,
		const Mat &	_a = `Mat()`,
		const Mat &	_b = `Mat()`,
		const Mat &	_c = `Mat()`,
		double	_alpha = `1`,
		double	_beta = `1`,
		const Scalar &	_s = `Scalar()`
	)

Member Function Documentation

◆ col()

MatExpr cv::MatExpr::col ( int x ) const

◆ cross()

Mat cv::MatExpr::cross ( const Mat & m ) const

◆ diag()

MatExpr cv::MatExpr::diag ( int d = 0 ) const

◆ dot()

double cv::MatExpr::dot ( const Mat & m ) const

◆ inv()

MatExpr cv::MatExpr::inv ( int method = DECOMP_LU ) const

◆ mul() [1/2]

MatExpr cv::MatExpr::mul	(	const MatExpr &	e,
		double	scale = `1`
	)		const

◆ mul() [2/2]

MatExpr cv::MatExpr::mul	(	const Mat &	m,
		double	scale = `1`
	)		const

◆ operator Mat()

cv::MatExpr::operator Mat ( ) const

◆ operator Mat_< _Tp >()

template<typename _Tp >

cv::MatExpr::operator Mat_< _Tp > ( ) const

◆ operator()() [1/2]

MatExpr cv::MatExpr::operator()	(	const Range &	rowRange,
		const Range &	colRange
	)		const

◆ operator()() [2/2]

MatExpr cv::MatExpr::operator() ( const Rect & roi ) const

◆ row()

MatExpr cv::MatExpr::row ( int y ) const

◆ size()

Size cv::MatExpr::size ( ) const

◆ t()

MatExpr cv::MatExpr::t ( ) const

Examples:: samples/cpp/tutorial_code/features2D/Homography/decompose_homography.cpp.

◆ type()

int cv::MatExpr::type ( ) const

Friends And Related Function Documentation

◆ abs() [1/2]

MatExpr abs ( const Mat & m )

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ abs() [2/2]

MatExpr abs ( const MatExpr & e )

Parameters

e	matrix expression.

◆ max() [1/5]

MatExpr max	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ max() [2/5]

MatExpr max	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ max() [3/5]

MatExpr max	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ max() [4/5]

template<typename _Tp , int m, int n>

static MatExpr max	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References max().

Referenced by max().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ max() [5/5]

template<typename _Tp , int m, int n>

static MatExpr max	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::abs(), and max().

Referenced by max().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ min() [1/5]

MatExpr min	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ min() [2/5]

MatExpr min	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ min() [3/5]

MatExpr min	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ min() [4/5]

template<typename _Tp , int m, int n>

static MatExpr min	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References min().

Referenced by min().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ min() [5/5]

template<typename _Tp , int m, int n>

static MatExpr min	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::max(), and min().

Referenced by min().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator &() [1/5]

MatExpr operator&	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator &() [2/5]

MatExpr operator&	(	const Mat &	a,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator &() [3/5]

MatExpr operator&	(	const Scalar &	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator &() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator&	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator &() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator&	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator|().

Here is the call graph for this function:

◆ operator!=() [1/5]

MatExpr operator!=	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator!=() [2/5]

MatExpr operator!=	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator!=() [3/5]

MatExpr operator!=	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator!=() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator!=	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator!=() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator!=	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator>=().

Here is the call graph for this function:

◆ operator*() [1/10]

MatExpr operator*	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [2/10]

MatExpr operator*	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [3/10]

MatExpr operator*	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [4/10]

MatExpr operator*	(	const MatExpr &	e,
		const Mat &	m
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [5/10]

MatExpr operator*	(	const Mat &	m,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [6/10]

MatExpr operator*	(	const MatExpr &	e,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [7/10]

MatExpr operator*	(	double	s,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [8/10]

MatExpr operator*	(	const MatExpr &	e1,
		const MatExpr &	e2
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [9/10]

template<typename _Tp , int m, int n>

static MatExpr operator*	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator*() [10/10]

template<typename _Tp , int m, int n>

static MatExpr operator*	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator/().

Here is the call graph for this function:

◆ operator+() [1/10]

MatExpr operator+	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [2/10]

MatExpr operator+	(	const Mat &	a,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [3/10]

MatExpr operator+	(	const Scalar &	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [4/10]

MatExpr operator+	(	const MatExpr &	e,
		const Mat &	m
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [5/10]

MatExpr operator+	(	const Mat &	m,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [6/10]

MatExpr operator+	(	const MatExpr &	e,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [7/10]

MatExpr operator+	(	const Scalar &	s,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [8/10]

MatExpr operator+	(	const MatExpr &	e1,
		const MatExpr &	e2
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [9/10]

template<typename _Tp , int m, int n>

static MatExpr operator+	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator+() [10/10]

template<typename _Tp , int m, int n>

static MatExpr operator+	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator-().

Here is the call graph for this function:

◆ operator-() [1/12]

MatExpr operator-	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [2/12]

MatExpr operator-	(	const Mat &	a,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [3/12]

MatExpr operator-	(	const Scalar &	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [4/12]

MatExpr operator-	(	const MatExpr &	e,
		const Mat &	m
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [5/12]

MatExpr operator-	(	const Mat &	m,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [6/12]

MatExpr operator-	(	const MatExpr &	e,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [7/12]

MatExpr operator-	(	const Scalar &	s,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [8/12]

MatExpr operator-	(	const MatExpr &	e1,
		const MatExpr &	e2
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [9/12]

template<typename _Tp , int m, int n>

static MatExpr operator-	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [10/12]

template<typename _Tp , int m, int n>

static MatExpr operator-	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator*(), and cv::operator-().

Here is the call graph for this function:

◆ operator-() [11/12]

MatExpr operator- ( const Mat & m )

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator-() [12/12]

MatExpr operator- ( const MatExpr & e )

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [1/10]

MatExpr operator/	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [2/10]

MatExpr operator/	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [3/10]

MatExpr operator/	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [4/10]

MatExpr operator/	(	const MatExpr &	e,
		const Mat &	m
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [5/10]

MatExpr operator/	(	const Mat &	m,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [6/10]

MatExpr operator/	(	const MatExpr &	e,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [7/10]

MatExpr operator/	(	double	s,
		const MatExpr &	e
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [8/10]

MatExpr operator/	(	const MatExpr &	e1,
		const MatExpr &	e2
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [9/10]

template<typename _Tp , int m, int n>

static MatExpr operator/	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator/() [10/10]

template<typename _Tp , int m, int n>

static MatExpr operator/	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator<().

Here is the call graph for this function:

◆ operator<() [1/5]

MatExpr operator<	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<() [2/5]

MatExpr operator<	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<() [3/5]

MatExpr operator<	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator<	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator<	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator<=().

Here is the call graph for this function:

◆ operator<=() [1/5]

MatExpr operator<=	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<=() [2/5]

MatExpr operator<=	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<=() [3/5]

MatExpr operator<=	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<=() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator<=	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator<=() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator<=	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator==().

Here is the call graph for this function:

◆ operator==() [1/5]

MatExpr operator==	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator==() [2/5]

MatExpr operator==	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator==() [3/5]

MatExpr operator==	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator==() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator==	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator==() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator==	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator!=().

Here is the call graph for this function:

◆ operator>() [1/5]

MatExpr operator>	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>() [2/5]

MatExpr operator>	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>() [3/5]

MatExpr operator>	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator>	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator>	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator&().

Here is the call graph for this function:

◆ operator>=() [1/5]

MatExpr operator>=	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>=() [2/5]

MatExpr operator>=	(	const Mat &	a,
		double	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>=() [3/5]

MatExpr operator>=	(	double	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>=() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator>=	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator>=() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator>=	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator>().

Here is the call graph for this function:

◆ operator^() [1/5]

MatExpr operator^	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator^() [2/5]

MatExpr operator^	(	const Mat &	a,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator^() [3/5]

MatExpr operator^	(	const Scalar &	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator^() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator^	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator^() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator^	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::min(), and cv::operator~().

Here is the call graph for this function:

◆ operator|() [1/5]

MatExpr operator\|	(	const Mat &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator|() [2/5]

MatExpr operator\|	(	const Mat &	a,
		const Scalar &	s
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator|() [3/5]

MatExpr operator\|	(	const Scalar &	s,
		const Mat &	a
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator|() [4/5]

template<typename _Tp , int m, int n>

static MatExpr operator\|	(	const Mat &	a,
		const Matx< _Tp, m, n > &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

◆ operator|() [5/5]

template<typename _Tp , int m, int n>

static MatExpr operator\|	(	const Matx< _Tp, m, n > &	a,
		const Mat &	b
	)

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

References cv::operator^().

Here is the call graph for this function:

◆ operator~()

MatExpr operator~ ( const Mat & m )

abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)
C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)
C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters

m matrix.

See also: MatrixExpressions, absdiff, convertScaleAbs

Member Data Documentation

◆ a

Mat cv::MatExpr::a

◆ alpha

double cv::MatExpr::alpha

◆ b

Mat cv::MatExpr::b

◆ beta

double cv::MatExpr::beta

◆ c

Mat cv::MatExpr::c

◆ flags

int cv::MatExpr::flags

◆ op

const MatOp* cv::MatExpr::op

◆ s

Scalar cv::MatExpr::s

The documentation for this class was generated from the following file:

opencv2/core/mat.hpp

Public Member Functions

Public Attributes

Related Functions

Detailed Description

Constructor & Destructor Documentation

◆ MatExpr() [1/3]

◆ MatExpr() [2/3]

◆ MatExpr() [3/3]

Member Function Documentation

◆ col()

◆ cross()

◆ diag()

◆ dot()

◆ inv()

◆ mul() [1/2]

◆ mul() [2/2]

◆ operator Mat()

◆ operator Mat_< _Tp >()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ row()

◆ size()

◆ t()

◆ type()

Friends And Related Function Documentation

◆ abs() [1/2]

◆ abs() [2/2]

◆ max() [1/5]

◆ max() [2/5]

◆ max() [3/5]

◆ max() [4/5]

◆ max() [5/5]

◆ min() [1/5]

◆ min() [2/5]

◆ min() [3/5]

◆ min() [4/5]

◆ min() [5/5]

◆ operator &() [1/5]

◆ operator &() [2/5]

◆ operator &() [3/5]

◆ operator &() [4/5]

◆ operator &() [5/5]

◆ operator!=() [1/5]

◆ operator!=() [2/5]

◆ operator!=() [3/5]

◆ operator!=() [4/5]

◆ operator!=() [5/5]

◆ operator*() [1/10]

◆ operator*() [2/10]

◆ operator*() [3/10]

◆ operator*() [4/10]

◆ operator*() [5/10]

◆ operator*() [6/10]

◆ operator*() [7/10]

◆ operator*() [8/10]

◆ operator*() [9/10]

◆ operator*() [10/10]

◆ operator+() [1/10]

◆ operator+() [2/10]

◆ operator+() [3/10]

◆ operator+() [4/10]

◆ operator+() [5/10]

◆ operator+() [6/10]

◆ operator+() [7/10]

◆ operator+() [8/10]

◆ operator+() [9/10]

◆ operator+() [10/10]

◆ operator-() [1/12]

◆ operator-() [2/12]

◆ operator-() [3/12]

◆ operator-() [4/12]

◆ operator-() [5/12]

◆ operator-() [6/12]

◆ operator-() [7/12]

◆ operator-() [8/12]

◆ operator-() [9/12]

◆ operator-() [10/12]

◆ operator-() [11/12]

◆ operator-() [12/12]

◆ operator/() [1/10]