class cv::MatExpr

Overview

Matrix expression representation. More…

#include <mat.hpp>

class MatExpr
{
public:
    // fields

    Mat a;
    double alpha;
    Mat b;
    double beta;
    Mat c;
    int flags;
    const MatOp* op;
    Scalar s;

    // construction

    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()
        );

    // methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    MatExpr
    operator-(const Mat& m);

    MatExpr
    operator-(const MatExpr& e);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    MatExpr
    operator~(const Mat& m);

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

    MatExpr
    min(
        const Mat& a,
        double s
        );

    MatExpr
    min(
        double s,
        const Mat& a
        );

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

    MatExpr
    max(
        const Mat& a,
        double s
        );

    MatExpr
    max(
        double s,
        const Mat& a
        );

    MatExpr
    abs(const Mat& m);

    MatExpr
    abs(const MatExpr& e);

    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;
};

Detailed Documentation

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. 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);

Methods

MatExpr
abs(const Mat& m)

Calculates an absolute value of each matrix element.

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.