Struct opencv::core::MatExpr

source ·

pub struct MatExpr { /* private fields */ }

Expand description

Matrix expression representation @anchor MatrixExpressions 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-1), 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

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

Struct opencv::core::MatExpr

Implementations

impl MatExpr

pub fn default() -> Result<MatExpr>

pub fn from_mat(m: &Mat) -> Result<MatExpr>

pub fn new( _op: &dyn MatOp, _flags: i32, _a: &Mat, _b: &Mat, _c: &Mat, _alpha: f64, _beta: f64, _s: Scalar) -> Result<MatExpr>

C++ default parameters

Trait Implementations

impl Add<&Mat> for &MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &Mat) -> Self::Output

impl Add<&Mat> for MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &Mat) -> Self::Output

impl Add<&MatExpr> for &Mat

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for &MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for &Scalar

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for Mat

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExprResult<&MatExpr>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExprResult<&Scalar>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExprResult<Mat>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExprResult<MatExpr>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for MatExprResult<Scalar>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&MatExpr> for Scalar

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &MatExpr) -> Self::Output

impl Add<&VecN<f64, 4>> for &MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &Scalar) -> Self::Output

impl Add<&VecN<f64, 4>> for MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: &Scalar) -> Self::Output

impl Add<Mat> for &MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: Mat) -> Self::Output

impl Add<Mat> for MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: Mat) -> Self::Output

impl Add<MatExpr> for &Mat

type Output = MatExprResult<MatExpr>

fn add(self, rhs: MatExpr) -> Self::Output

impl Add<MatExpr> for &MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: MatExpr) -> Self::Output

impl Add<MatExpr> for &Scalar

type Output = MatExprResult<MatExpr>

fn add(self, rhs: MatExpr) -> Self::Output

impl Add<MatExpr> for Mat

type Output = MatExprResult<MatExpr>

fn add(self, rhs: MatExpr) -> Self::Output

impl Add<MatExpr> for MatExpr

type Output = MatExprResult<MatExpr>

fn add(self, rhs: MatExpr) -> Self::Output

impl Add<MatExpr> for MatExprResult<&Mat>

type Output = MatExprResult<MatExpr>

fn add(self, rhs: MatExpr) -> Self::Output

pub fn new(
_op: &dyn MatOp,
_flags: i32,
_a: &Mat,
_b: &Mat,
_c: &Mat,
_alpha: f64,
_beta: f64,
_s: Scalar
) -> Result<MatExpr>