Skip to content

O
opencv
Commit ec314cf2 authored by Vadim Pisarevsky's avatar Vadim Pisarevsky
Browse files
Options

moved the matrix expressions from mat.hpp to matop.cpp. That should improve build times

parent 50450f5e
Hide whitespace changes
Inline Side-by-side
Showing with 1751 additions and 71 deletions
modules/core/include/opencv2/core/core.hpp
View file @ ec314cf2
......@@ -86,23 +86,8 @@ typedef std::basic_string<wchar_t> WString;
class Mat;
class MatND;
template<typename M> class CV_EXPORTS MatExpr_Base_;
typedef MatExpr_Base_<Mat> MatExpr_Base;
template<typename E, typename M> class MatExpr_;
template<typename A1, typename M, typename Op> class MatExpr_Op1_;
template<typename A1, typename A2, typename M, typename Op> class MatExpr_Op2_;
template<typename A1, typename A2, typename A3, typename M, typename Op> class MatExpr_Op3_;
template<typename A1, typename A2, typename A3, typename A4,
typename M, typename Op> class MatExpr_Op4_;
template<typename A1, typename A2, typename A3, typename A4,
typename A5, typename M, typename Op> class MatExpr_Op5_;
template<typename M> class CV_EXPORTS MatOp_DivRS_;
template<typename M> class CV_EXPORTS MatOp_Inv_;
template<typename M> class CV_EXPORTS MatOp_MulDiv_;
template<typename M> class CV_EXPORTS MatOp_Repeat_;
template<typename M> class CV_EXPORTS MatOp_Set_;
template<typename M> class CV_EXPORTS MatOp_Scale_;
template<typename M> class CV_EXPORTS MatOp_T_;
class CV_EXPORTS MatExpr;
class CV_EXPORTS MatOp_Base;
template<typename _Tp> class CV_EXPORTS MatIterator_;
template<typename _Tp> class CV_EXPORTS MatConstIterator_;
......@@ -928,7 +913,11 @@ public:
//! another helper conversion method. \see cvScalarToRawData
template<typename T2> void convertTo(T2* buf, int channels, int unroll_to=0) const;
// returns (v0, -v1, -v2, -v3)
Scalar_<_Tp> conj() const;
// returns true iff v1 == v2 == v3 == 0
bool isReal() const;
};
typedef Scalar_<double> Scalar;
......@@ -1244,9 +1233,6 @@ protected:
//////////////////////////////// Mat ////////////////////////////////
typedef MatExpr_<MatExpr_Op4_<Size, int, Scalar,
int, Mat, MatOp_Set_<Mat> >, Mat> MatExpr_Initializer;
enum { MAGIC_MASK=0xFFFF0000, TYPE_MASK=0x00000FFF, DEPTH_MASK=7 };
static inline size_t getElemSize(int type) { return CV_ELEM_SIZE(type); }
......@@ -1500,15 +1486,11 @@ public:
template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt);
//! builds matrix from comma initializer
template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
//! helper constructor to compile matrix expressions
Mat(const MatExpr_Base& expr);
//! destructor - calls release()
~Mat();
//! assignment operators
Mat& operator = (const Mat& m);
Mat& operator = (const MatExpr_Base& expr);
operator MatExpr_<Mat, Mat>() const;
Mat& operator = (const MatExpr& expr);
//! returns a new matrix header for the specified row
Mat row(int y) const;
......@@ -1549,18 +1531,12 @@ public:
Mat reshape(int _cn, int _rows=0) const;
//! matrix transposition by means of matrix expressions
MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_T_<Mat> >, Mat>
t() const;
MatExpr t() const;
//! matrix inversion by means of matrix expressions
MatExpr_<MatExpr_Op2_<Mat, int, Mat, MatOp_Inv_<Mat> >, Mat>
inv(int method=DECOMP_LU) const;
MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
MatExpr inv(int method=DECOMP_LU) const;
//! per-element matrix multiplication by means of matrix expressions
mul(const Mat& m, double scale=1) const;
MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
mul(const MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_Scale_<Mat> >, Mat>& m, double scale=1) const;
MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
mul(const MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_DivRS_<Mat> >, Mat>& m, double scale=1) const;
MatExpr mul(const Mat& m, double scale=1) const;
MatExpr mul(const MatExpr& m, double scale=1) const;
//! computes cross-product of 2 3D vectors
Mat cross(const Mat& m) const;
......@@ -1568,12 +1544,12 @@ public:
double dot(const Mat& m) const;
//! Matlab-style matrix initialization
static MatExpr_Initializer zeros(int rows, int cols, int type);
static MatExpr_Initializer zeros(Size size, int type);
static MatExpr_Initializer ones(int rows, int cols, int type);
static MatExpr_Initializer ones(Size size, int type);
static MatExpr_Initializer eye(int rows, int cols, int type);
static MatExpr_Initializer eye(Size size, int type);
static MatExpr zeros(int rows, int cols, int type);
static MatExpr zeros(Size size, int type);
static MatExpr ones(int rows, int cols, int type);
static MatExpr ones(Size size, int type);
static MatExpr eye(int rows, int cols, int type);
static MatExpr eye(Size size, int type);
//! allocates new matrix data unless the matrix already has specified size and type.
// previous data is unreferenced if needed.
......@@ -2301,8 +2277,6 @@ public:
Mat_(const Mat_& m, const Range& rowRange, const Range& colRange);
//! selects a submatrix
Mat_(const Mat_& m, const Rect& roi);
//! to support complex matrix expressions
Mat_(const MatExpr_Base& expr);
//! makes a matrix out of Vec, std::vector, Point_ or Point3_. The matrix will have a single column
explicit Mat_(const vector<_Tp>& vec, bool copyData=false);
template<int n> explicit Mat_(const Vec<_Tp, n>& vec, bool copyData=true);
......@@ -2329,7 +2303,7 @@ public:
//! cross-product
Mat_ cross(const Mat_& m) const;
//! to support complex matrix expressions
Mat_& operator = (const MatExpr_Base& expr);
Mat_& operator = (const MatExpr& expr);
//! data type conversion
template<typename T2> operator Mat_<T2>() const;
//! overridden forms of Mat::row() etc.
......@@ -2338,19 +2312,6 @@ public:
Mat_ diag(int d=0) const;
Mat_ clone() const;
//! transposition, inversion, per-element multiplication
MatExpr_<MatExpr_Op2_<Mat, double, Mat, MatOp_T_<Mat> >, Mat> t() const;
MatExpr_<MatExpr_Op2_<Mat, int, Mat, MatOp_Inv_<Mat> >, Mat> inv(int method=DECOMP_LU) const;
MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
mul(const Mat_& m, double scale=1) const;
MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
mul(const MatExpr_<MatExpr_Op2_<Mat, double, Mat,
MatOp_Scale_<Mat> >, Mat>& m, double scale=1) const;
MatExpr_<MatExpr_Op4_<Mat, Mat, double, char, Mat, MatOp_MulDiv_<Mat> >, Mat>
mul(const MatExpr_<MatExpr_Op2_<Mat, double, Mat,
MatOp_DivRS_<Mat> >, Mat>& m, double scale=1) const;
//! overridden forms of Mat::elemSize() etc.
size_t elemSize() const;
size_t elemSize1() const;
......@@ -2362,12 +2323,12 @@ public:
size_t stepT() const;
//! overridden forms of Mat::zeros() etc. Data type is omitted, of course
static MatExpr_Initializer zeros(int rows, int cols);
static MatExpr_Initializer zeros(Size size);
static MatExpr_Initializer ones(int rows, int cols);
static MatExpr_Initializer ones(Size size);
static MatExpr_Initializer eye(int rows, int cols);
static MatExpr_Initializer eye(Size size);
static MatExpr zeros(int rows, int cols);
static MatExpr zeros(Size size);
static MatExpr ones(int rows, int cols);
static MatExpr ones(Size size);
static MatExpr eye(int rows, int cols);
static MatExpr eye(Size size);
//! some more overriden methods
Mat_ reshape(int _rows) const;
......@@ -2386,9 +2347,6 @@ public:
_Tp& operator ()(int i);
const _Tp& operator ()(int i) const;
//! to support matrix expressions
operator MatExpr_<Mat, Mat>() const;
//! conversion to vector.
operator vector<_Tp>() const;
//! conversion to Vec
......@@ -2541,8 +2499,7 @@ template<typename _Tp> class CV_EXPORTS MatOp_Iter_;
Mat R = (Mat_<double>(2,2) << a, -b, b, a);
\endcode
*/
template<typename _Tp> class CV_EXPORTS MatCommaInitializer_ :
public MatExpr_<MatExpr_Op1_<MatIterator_<_Tp>, Mat_<_Tp>, MatOp_Iter_<_Tp> >, Mat_<_Tp> >
template<typename _Tp> class CV_EXPORTS MatCommaInitializer_
{
public:
//! the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
......@@ -2553,7 +2510,10 @@ public:
//operator Mat_<_Tp>() const;
//! another form of conversion operator
Mat_<_Tp> operator *() const;
void assignTo(Mat& m, int type=-1) const;
operator Mat_<_Tp>() const;
virtual void assignTo(Mat& m, int type=-1) const;
protected:
MatIterator_<_Tp> it;
};
......
modules/core/include/opencv2/core/mat.hpp
View file @ ec314cf2
This source diff could not be displayed because it is too large. You can view the blob instead.
modules/core/include/opencv2/core/operations.hpp
View file @ ec314cf2
......@@ -1996,6 +1996,11 @@ template<typename _Tp> inline Scalar_<_Tp> Scalar_<_Tp>::conj() const
saturate_cast<_Tp>(-this->val[3]));
}
template<typename _Tp> inline bool Scalar_<_Tp>::isReal() const
{
return this->val[1] == 0 && this->val[2] == 0 && this->val[3] == 0;
}
template<typename _Tp> static inline
Scalar_<_Tp> operator / (const Scalar_<_Tp>& a, _Tp alpha)
{
......
modules/core/src/matop.cpp 0 → 100644
View file @ ec314cf2
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
/* ////////////////////////////////////////////////////////////////////
//
// Mat basic operations: Copy, Set
//
// */
#include "precomp.hpp"
namespace cv
{
class MatOp_Identity : public MatOp
{
public:
MatOp_Identity() {}
virtual ~MatOp_Identity() {}
bool elementWise(const MatExpr& expr) const { return true; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const;
void add(const MatExpr& e1, const Scalar& s, MatExpr& res) const;
void subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const;
void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
void multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale=1) const;
void multiply(const MatExpr& e1, double s, MatExpr& res) const;
void divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale=1) const;
void divide(double s, const MatExpr& e, MatExpr& res) const;
void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
static void makeExpr(MatExpr& res, const Mat& m);
};
static MatOp_Identity g_MatOp_Identity;
class MatOp_AddEx : public MatOp
{
public:
MatOp_AddEx() {}
virtual ~MatOp_AddEx() {}
bool elementWise(const MatExpr& expr) const { return true; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const;
void add(const MatExpr& e1, const Scalar& s, MatExpr& res) const;
void subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const;
void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
void multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale=1) const;
void multiply(const MatExpr& e1, double s, MatExpr& res) const;
void divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale=1) const;
void divide(double s, const MatExpr& e, MatExpr& res) const;
void transpose(const MatExpr& e1, MatExpr& res) const;
void abs(const MatExpr& expr, MatExpr& res) const;
void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
static void makeExpr(MatExpr& res, const Mat& a, const Mat& b, double alpha, double beta, const Scalar& s=Scalar());
};
static MatOp_AddEx g_MatOp_AddEx;
class MatOp_Bin : public MatOp
{
public:
MatOp_Bin() {}
virtual ~MatOp_Bin() {}
bool elementWise(const MatExpr& expr) const { return true; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale=1) const;
void multiply(const MatExpr& e1, double s, MatExpr& res) const;
void divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale=1) const;
void divide(double s, const MatExpr& e, MatExpr& res) const;
static void makeExpr(MatExpr& res, char op, const Mat& a, const Mat& b, double scale=1);
static void makeExpr(MatExpr& res, char op, const Mat& a, const Scalar& s);
};
static MatOp_Bin g_MatOp_Bin;
class MatOp_Cmp : public MatOp
{
public:
MatOp_Cmp() {}
virtual ~MatOp_Cmp() {}
bool elementWise(const MatExpr& expr) const { return true; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
static void makeExpr(MatExpr& res, int cmpop, const Mat& a, const Mat& b);
static void makeExpr(MatExpr& res, int cmpop, const Mat& a, double alpha);
};
static MatOp_Cmp g_MatOp_Cmp;
class MatOp_GEMM : public MatOp
{
public:
MatOp_GEMM() {}
virtual ~MatOp_GEMM() {}
bool elementWise(const MatExpr& expr) const { return false; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const;
void subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const;
void multiply(const MatExpr& e, double s, MatExpr& res) const;
void transpose(const MatExpr& expr, MatExpr& res) const;
static void makeExpr(MatExpr& res, int flags, const Mat& a, const Mat& b,
double alpha=1, const Mat& c=Mat(), double beta=1);
};
static MatOp_GEMM g_MatOp_GEMM;
class MatOp_Invert : public MatOp
{
public:
MatOp_Invert() {}
virtual ~MatOp_Invert() {}
bool elementWise(const MatExpr& expr) const { return false; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
static void makeExpr(MatExpr& res, int method, const Mat& m);
};
static MatOp_Invert g_MatOp_Invert;
class MatOp_T : public MatOp
{
public:
MatOp_T() {}
virtual ~MatOp_T() {}
bool elementWise(const MatExpr& expr) const { return false; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void multiply(const MatExpr& e1, double s, MatExpr& res) const;
void transpose(const MatExpr& expr, MatExpr& res) const;
void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
static void makeExpr(MatExpr& res, const Mat& a, double alpha=1);
};
static MatOp_T g_MatOp_T;
class MatOp_Solve : public MatOp
{
public:
MatOp_Solve() {}
virtual ~MatOp_Solve() {}
bool elementWise(const MatExpr& expr) const { return false; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
static void makeExpr(MatExpr& res, int method, const Mat& a, const Mat& b);
};
static MatOp_Solve g_MatOp_Solve;
class MatOp_Initializer : public MatOp
{
public:
MatOp_Initializer() {}
virtual ~MatOp_Initializer() {}
bool elementWise(const MatExpr& expr) const { return false; }
void assign(const MatExpr& expr, Mat& m, int type=-1) const;
void multiply(const MatExpr& e, double s, MatExpr& res) const;
static void makeExpr(MatExpr& res, int method, Size sz, int type, double alpha=1);
};
static MatOp_Initializer g_MatOp_Initializer;
static inline bool isIdentity(const MatExpr& e) { return e.op == &g_MatOp_Identity; }
static inline bool isAddEx(const MatExpr& e) { return e.op == &g_MatOp_AddEx; }
static inline bool isScaled(const MatExpr& e) { return isAddEx(e) && (!e.b.data || e.beta == 0) && e.s == Scalar(); }
static inline bool isBin(const MatExpr& e, char c) { return e.op == &g_MatOp_Bin && e.flags == c; }
static inline bool isReciprocal(const MatExpr& e) { return isBin(e,'/') && (!e.b.data || e.beta == 0); }
static inline bool isT(const MatExpr& e) { return e.op == &g_MatOp_T; }
static inline bool isInv(const MatExpr& e) { return e.op == &g_MatOp_Invert; }
static inline bool isGEMM(const MatExpr& e) { return e.op == &g_MatOp_GEMM; }
static inline bool isMatProd(const MatExpr& e) { return e.op == &g_MatOp_GEMM && (!e.c.data || e.beta == 0); }
static inline bool isInitializer(const MatExpr& e) { return e.op == &g_MatOp_Initializer; }
/////////////////////////////////////////////////////////////////////////////////////////////////////
bool MatOp::elementWise(const MatExpr& expr) const
{
return false;
}
void MatOp::roi(const MatExpr& expr, const Range& rowRange, const Range& colRange, MatExpr& e) const
{
if( elementWise(expr) )
{
e = MatExpr(expr.op, expr.flags, Mat(), Mat(), Mat(),
expr.alpha, expr.beta, expr.s);
if(expr.a.data)
e.a = expr.a(rowRange, colRange);
if(expr.b.data)
e.b = expr.b(rowRange, colRange);
if(expr.c.data)
e.c = expr.c(rowRange, colRange);
}
else
{
Mat m;
expr.op->assign(expr, m);
e = MatExpr(&g_MatOp_Identity, 0, m(rowRange, colRange), Mat(), Mat());
}
}
void MatOp::diag(const MatExpr& expr, int d, MatExpr& e) const
{
if( elementWise(expr) )
{
e = MatExpr(expr.op, expr.flags, Mat(), Mat(), Mat(),
expr.alpha, expr.beta, expr.s);
if(expr.a.data)
e.a = expr.a.diag(d);
if(expr.b.data)
e.b = expr.b.diag(d);
if(expr.c.data)
e.c = expr.c.diag(d);
}
else
{
Mat m;
expr.op->assign(expr, m);
e = MatExpr(&g_MatOp_Identity, 0, m.diag(d), Mat(), Mat());
}
}
void MatOp::augAssignAdd(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m += temp;
}
void MatOp::augAssignSubtract(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m -= temp;
}
void MatOp::augAssignMultiply(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m *= temp;
}
void MatOp::augAssignDivide(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m /= temp;
}
void MatOp::augAssignAnd(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m &= temp;
}
void MatOp::augAssignOr(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m |= temp;
}
void MatOp::augAssignXor(const MatExpr& expr, Mat& m) const
{
Mat temp;
expr.op->assign(expr, temp);
m /= temp;
}
void MatOp::add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const
{
if( this == expr2.op )
{
Mat m1, m2;
expr1.op->assign(expr1, m1);
expr2.op->assign(expr2, m2);
MatOp_AddEx::makeExpr(res, m1, m2, 1, 1);
}
else
expr2.op->add(expr1, expr2, res);
}
void MatOp::add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const
{
Mat m1;
expr1.op->assign(expr1, m1);
MatOp_AddEx::makeExpr(res, m1, Mat(), 1, 0, s);
}
void MatOp::subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const
{
if( this == expr2.op )
{
Mat m1, m2;
expr1.op->assign(expr1, m1);
expr2.op->assign(expr2, m2);
MatOp_AddEx::makeExpr(res, m1, m2, 1, -1);
}
else
expr2.op->subtract(expr1, expr2, res);
}
void MatOp::subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const
{
Mat m;
expr.op->assign(expr, m);
MatOp_AddEx::makeExpr(res, m, Mat(), -1, 0, s);
}
void MatOp::multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale) const
{
if( this == expr2.op )
{
Mat m1, m2;
expr1.op->assign(expr1, m1);
expr2.op->assign(expr2, m2);
MatOp_Bin::makeExpr(res, '*', m1, m2, scale);
}
else
expr2.op->multiply(expr1, expr2, res, scale);
}
void MatOp::multiply(const MatExpr& expr, double s, MatExpr& res) const
{
Mat m;
expr.op->assign(expr, m);
MatOp_AddEx::makeExpr(res, m, Mat(), s, 0);
}
void MatOp::divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale) const
{
if( this == expr2.op )
{
Mat m1, m2;
expr1.op->assign(expr1, m1);
expr2.op->assign(expr2, m2);
MatOp_Bin::makeExpr(res, '/', m1, m2, scale);
}
else
expr2.op->divide(expr1, expr2, res, scale);
}
void MatOp::divide(double s, const MatExpr& expr, MatExpr& res) const
{
Mat m;
expr.op->assign(expr, m);
MatOp_Bin::makeExpr(res, '/', m, Mat(), s);
}
void MatOp::abs(const MatExpr& expr, MatExpr& res) const
{
Mat m;
expr.op->assign(expr, m);
MatOp_Bin::makeExpr(res, 'a', m, Mat());
}
void MatOp::transpose(const MatExpr& expr, MatExpr& res) const
{
Mat m;
expr.op->assign(expr, m);
MatOp_T::makeExpr(res, m, 1);
}
void MatOp::matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const
{
if( this == expr2.op )
{
Mat m1, m2;
expr1.op->assign(expr1, m1);
expr2.op->assign(expr2, m2);
MatOp_GEMM::makeExpr(res, 0, m1, m2);
}
else
expr2.op->matmul(expr1, expr2, res);
}
void MatOp::invert(const MatExpr& expr, int method, MatExpr& res) const
{
Mat m;
expr.op->assign(expr, m);
MatOp_Invert::makeExpr(res, method, m);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
MatExpr::MatExpr(const Mat& m) : op(&g_MatOp_Identity), flags(0), a(m), b(Mat()), c(Mat()), alpha(1), beta(0), s(Scalar())
{
}
MatExpr MatExpr::row(int y) const
{
MatExpr e;
op->roi(*this, Range(y, y+1), Range::all(), e);
return e;
}
MatExpr MatExpr::col(int x) const
{
MatExpr e;
op->roi(*this, Range::all(), Range(x, x+1), e);
return e;
}
MatExpr MatExpr::diag(int d) const
{
MatExpr e;
op->diag(*this, d, e);
return e;
}
MatExpr MatExpr::operator()( const Range& rowRange, const Range& colRange ) const
{
MatExpr e;
op->roi(*this, rowRange, colRange, e);
return e;
}
MatExpr MatExpr::operator()( const Rect& roi ) const
{
MatExpr e;
op->roi(*this, Range(roi.y, roi.y + roi.height), Range(roi.x, roi.x + roi.width), e);
return e;
}
Mat MatExpr::cross(const Mat& m) const
{
return ((Mat)*this).cross(m);
}
double MatExpr::dot(const Mat& m) const
{
return ((Mat)*this).dot(m);
}
MatExpr MatExpr::t() const
{
MatExpr e;
op->transpose(*this, e);
return e;
}
MatExpr MatExpr::inv(int method) const
{
MatExpr e;
op->invert(*this, method, e);
return e;
}
MatExpr MatExpr::mul(const MatExpr& e, double scale) const
{
MatExpr en;
op->multiply(*this, e, en, scale);
return en;
}
MatExpr MatExpr::mul(const Mat& m, double scale) const
{
MatExpr e;
op->multiply(*this, MatExpr(m), e, scale);
return e;
}
MatExpr operator + (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, b, 1, 1);
return e;
}
MatExpr operator + (const Mat& a, const Scalar& s)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), 1, 0, s);
return e;
}
MatExpr operator + (const Scalar& s, const Mat& a)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), 1, 0, s);
return e;
}
MatExpr operator + (const MatExpr& e, const Mat& m)
{
MatExpr en;
e.op->add(e, MatExpr(m), en);
return en;
}
MatExpr operator + (const Mat& m, const MatExpr& e)
{
MatExpr en;
e.op->add(e, MatExpr(m), en);
return en;
}
MatExpr operator + (const MatExpr& e, const Scalar& s)
{
MatExpr en;
e.op->add(e, s, en);
return en;
}
MatExpr operator + (const Scalar& s, const MatExpr& e)
{
MatExpr en;
e.op->add(e, s, en);
return en;
}
MatExpr operator + (const MatExpr& e1, const MatExpr& e2)
{
MatExpr en;
e1.op->add(e1, e2, en);
return en;
}
MatExpr operator - (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, b, 1, -1);
return e;
}
MatExpr operator - (const Mat& a, const Scalar& s)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), 1, 0, -s);
return e;
}
MatExpr operator - (const Scalar& s, const Mat& a)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), -1, 0, s);
return e;
}
MatExpr operator - (const MatExpr& e, const Mat& m)
{
MatExpr en;
e.op->subtract(e, MatExpr(m), en);
return en;
}
MatExpr operator - (const Mat& m, const MatExpr& e)
{
MatExpr en;
e.op->subtract(MatExpr(m), e, en);
return en;
}
MatExpr operator - (const MatExpr& e, const Scalar& s)
{
MatExpr en;
e.op->add(e, -s, en);
return en;
}
MatExpr operator - (const Scalar& s, const MatExpr& e)
{
MatExpr en;
e.op->subtract(s, e, en);
return en;
}
MatExpr operator - (const MatExpr& e1, const MatExpr& e2)
{
MatExpr en;
e1.op->subtract(e1, e2, en);
return en;
}
MatExpr operator - (const Mat& m)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, m, Mat(), -1, 0);
return e;
}
MatExpr operator - (const MatExpr& e)
{
MatExpr en;
e.op->subtract(Scalar(0), e, en);
return en;
}
MatExpr operator * (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_GEMM::makeExpr(e, 0, a, b);
return e;
}
MatExpr operator * (const Mat& a, double s)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), s, 0);
return e;
}
MatExpr operator * (double s, const Mat& a)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), s, 0);
return e;
}
MatExpr operator * (const MatExpr& e, const Mat& m)
{
MatExpr en;
e.op->matmul(e, MatExpr(m), en);
return en;
}
MatExpr operator * (const Mat& m, const MatExpr& e)
{
MatExpr en;
e.op->matmul(MatExpr(m), e, en);
return en;
}
MatExpr operator * (const MatExpr& e, double s)
{
MatExpr en;
e.op->multiply(e, s, en);
return en;
}
MatExpr operator * (double s, const MatExpr& e)
{
MatExpr en;
e.op->multiply(e, s, en);
return en;
}
MatExpr operator * (const MatExpr& e1, const MatExpr& e2)
{
MatExpr en;
e1.op->matmul(e1, e2, en);
return en;
}
MatExpr operator / (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '/', a, b);
return e;
}
MatExpr operator / (const Mat& a, double s)
{
MatExpr e;
MatOp_AddEx::makeExpr(e, a, Mat(), 1./s, 0);
return e;
}
MatExpr operator / (double s, const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '/', a, Mat(), s);
return e;
}
MatExpr operator / (const MatExpr& e, const Mat& m)
{
MatExpr en;
e.op->divide(e, MatExpr(m), en);
return en;
}
MatExpr operator / (const Mat& m, const MatExpr& e)
{
MatExpr en;
e.op->divide(MatExpr(m), e, en);
return en;
}
MatExpr operator / (const MatExpr& e, double s)
{
MatExpr en;
e.op->multiply(e, 1./s, en);
return en;
}
MatExpr operator / (double s, const MatExpr& e)
{
MatExpr en;
e.op->divide(s, e, en);
return en;
}
MatExpr operator / (const MatExpr& e1, const MatExpr& e2)
{
MatExpr en;
e1.op->divide(e1, e2, en);
return en;
}
MatExpr operator < (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, b);
return e;
}
MatExpr operator < (const Mat& a, double s)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, s);
return e;
}
MatExpr operator < (double s, const Mat& a)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GT, a, s);
return e;
}
MatExpr operator <= (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LE, a, b);
return e;
}
MatExpr operator <= (const Mat& a, double s)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LE, a, s);
return e;
}
MatExpr operator <= (double s, const Mat& a)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GE, a, s);
return e;
}
MatExpr operator == (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_EQ, a, b);
return e;
}
MatExpr operator == (const Mat& a, double s)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_EQ, a, s);
return e;
}
MatExpr operator == (double s, const Mat& a)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_EQ, a, s);
return e;
}
MatExpr operator != (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_NE, a, b);
return e;
}
MatExpr operator != (const Mat& a, double s)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_NE, a, s);
return e;
}
MatExpr operator != (double s, const Mat& a)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_NE, a, s);
return e;
}
MatExpr operator >= (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GE, a, b);
return e;
}
MatExpr operator >= (const Mat& a, double s)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GE, a, s);
return e;
}
MatExpr operator >= (double s, const Mat& a)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LE, a, s);
return e;
}
MatExpr operator > (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GT, a, b);
return e;
}
MatExpr operator > (const Mat& a, double s)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GT, a, s);
return e;
}
MatExpr operator > (double s, const Mat& a)
{
MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, s);
return e;
}
MatExpr min(const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'm', a, b);
return e;
}
MatExpr min(const Mat& a, double s)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'm', a, s);
return e;
}
MatExpr min(double s, const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'm', a, s);
return e;
}
MatExpr max(const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'M', a, b);
return e;
}
MatExpr max(const Mat& a, double s)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'M', a, s);
return e;
}
MatExpr max(double s, const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'M', a, s);
return e;
}
MatExpr operator & (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '&', a, b);
return e;
}
MatExpr operator & (const Mat& a, const Scalar& s)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '&', a, s);
return e;
}
MatExpr operator & (const Scalar& s, const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '&', a, s);
return e;
}
MatExpr operator | (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '|', a, b);
return e;
}
MatExpr operator | (const Mat& a, const Scalar& s)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '|', a, s);
return e;
}
MatExpr operator | (const Scalar& s, const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '|', a, s);
return e;
}
MatExpr operator ^ (const Mat& a, const Mat& b)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '^', a, b);
return e;
}
MatExpr operator ^ (const Mat& a, const Scalar& s)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '^', a, s);
return e;
}
MatExpr operator ^ (const Scalar& s, const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '^', a, s);
return e;
}
MatExpr operator ~(const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, '~', a, Scalar());
return e;
}
MatExpr abs(const Mat& a)
{
MatExpr e;
MatOp_Bin::makeExpr(e, 'a', a, Scalar());
return e;
}
MatExpr abs(const MatExpr& e)
{
MatExpr en;
e.op->abs(e, en);
return en;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
inline void MatOp_Identity::makeExpr(MatExpr& res, const Mat& m)
{
res = MatExpr(&g_MatOp_Identity, 0, m, Mat(), Mat(), 1, 0);
}
void MatOp_Identity::assign(const MatExpr& e, Mat& m, int type) const
{
if( type == -1 || type == e.a.type() )
m = e.a;
else
{
CV_Assert( CV_MAT_CN(type) == e.a.channels() );
e.a.convertTo(m, type);
}
}
void MatOp_Identity::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
if( isIdentity(e2) )
{
if( isIdentity(e1) )
MatOp_AddEx::makeExpr(res, e1.a, e2.a, 1, 1);
else
MatOp::add(e1, e2, res);
}
else
e2.op->add(e1, e2, res);
}
void MatOp_Identity::add(const MatExpr& e, const Scalar& s, MatExpr& res) const
{
MatOp_AddEx::makeExpr(res, e.a, Mat(), 1, 0, s);
}
void MatOp_Identity::subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
if( isIdentity(e2) )
{
if( isIdentity(e1) )
MatOp_AddEx::makeExpr(res, e1.a, e2.a, 1, -1);
else
MatOp::subtract(e1, e2, res);
}
else
e2.op->subtract(e1, e2, res);
}
void MatOp_Identity::subtract(const Scalar& s, const MatExpr& e, MatExpr& res) const
{
MatOp_AddEx::makeExpr(res, e.a, Mat(), -1, 0, s);
}
void MatOp_Identity::multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
{
if( isIdentity(e2) )
{
if( isIdentity(e1) )
MatOp_Bin::makeExpr(res, '*', e1.a, e2.a, scale);
else
MatOp::multiply(e1, e2, res, scale);
}
else
e2.op->multiply(e1, e2, res, scale);
}
void MatOp_Identity::multiply(const MatExpr& e, double s, MatExpr& res) const
{
MatOp_AddEx::makeExpr(res, e.a, Mat(), s, 0);
}
void MatOp_Identity::divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
{
if( isIdentity(e2) )
{
if( isIdentity(e1) )
MatOp_Bin::makeExpr(res, '/', e1.a, e2.a, scale);
else
MatOp::divide(e1, e2, res, scale);
}
else
e2.op->divide(e1, e2, res, scale);
}
void MatOp_Identity::divide(double s, const MatExpr& e, MatExpr& res) const
{
MatOp_Bin::makeExpr(res, '/', e.a, Mat(), s);
}
void MatOp_Identity::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
if( isIdentity(e2) )
{
if( isIdentity(e1) )
MatOp_GEMM::makeExpr(res, 0, e1.a, e2.a);
else
MatOp::matmul(e1, e2, res);
}
else
e2.op->matmul(e1, e2, res);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || e.a.type() == type ? m : temp;
if( e.b.data )
{
if( e.s == Scalar() || !e.s.isReal() )
{
if( e.alpha == 1 )
{
if( e.beta == 1 )
cv::add(e.a, e.b, dst);
else if( e.beta == -1 )
cv::subtract(e.a, e.b, dst);
else
cv::scaleAdd(e.b, e.beta, e.a, dst);
}
else if( e.beta == 1 )
{
if( e.alpha == -1 )
cv::subtract(e.b, e.a, dst);
else
cv::scaleAdd(e.a, e.alpha, e.b, dst);
}
else
cv::addWeighted(e.a, e.alpha, e.b, e.beta, 0, dst);
if( !e.s.isReal() )
cv::add(dst, e.s, dst);
}
else
cv::addWeighted(e.a, e.alpha, e.b, e.beta, e.s[0], dst);
}
else if( e.s.isReal() && (dst.data != m.data || fabs(e.alpha) != 1))
{
e.a.convertTo(m, type, e.alpha, e.s[0]);
return;
}
else if( e.alpha == 1 )
cv::add(e.a, e.s, dst);
else if( e.alpha == -1 )
cv::subtract(e.s, e.a, dst);
else
{
e.a.convertTo(dst, e.a.type(), e.alpha);
cv::add(dst, e.s, dst);
}
if( dst.data != m.data )
dst.convertTo(m, m.type());
}
void MatOp_AddEx::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
if( ((isAddEx(e2) && !e2.b.data) || i2) && ((isAddEx(e1) && !e1.b.data) || i1) )
MatOp_AddEx::makeExpr(res, e1.a, e2.a, i1 ? 1 : e1.alpha, i2 ? 1 : e2.alpha,
(i1 ? Scalar() : e1.s) + (i2 ? Scalar() : e2.s));
else if( e2.op == this )
MatOp::add(e1, e2, res);
else
e2.op->add(e1, e2, res);
}
void MatOp_AddEx::add(const MatExpr& e, const Scalar& s, MatExpr& res) const
{
res = e;
res.s += s;
}
void MatOp_AddEx::subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
if( ((isAddEx(e2) && !e2.b.data) || i2) && ((isAddEx(e1) && !e1.b.data) || i1) )
MatOp_AddEx::makeExpr(res, e1.a, e2.a, i1 ? 1 : e1.alpha, i2 ? -1 : -e2.alpha,
(i1 ? Scalar() : e1.s) - (i2 ? Scalar() : e2.s));
else if( e2.op == this )
MatOp::subtract(e1, e2, res);
else
e2.op->subtract(e1, e2, res);
}
void MatOp_AddEx::subtract(const Scalar& s, const MatExpr& e, MatExpr& res) const
{
res = e;
res.alpha = -res.alpha;
res.beta = -res.beta;
res.s = s - res.s;
}
void MatOp_AddEx::multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
if( (isScaled(e1) || i1) && (isScaled(e2) || i2) )
MatOp_Bin::makeExpr(res, '*', e1.a, e2.a, scale*(i1 ? 1 : e1.alpha)*(i2 ? 1 : e2.alpha));
else if( this == e2.op )
MatOp::multiply(e1, e2, res, scale);
else
e2.op->multiply(e1, e2, res, scale);
}
void MatOp_AddEx::multiply(const MatExpr& e, double s, MatExpr& res) const
{
res = e;
res.alpha *= s;
res.beta *= s;
res.s *= s;
}
void MatOp_AddEx::divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
if( (isScaled(e1) || i1) && (isScaled(e2) || i2) )
MatOp_Bin::makeExpr(res, '/', e1.a, e2.a, scale*(i1 ? 1 : e1.alpha)*(i2 ? 1 : 1./e2.alpha));
else if( this == e2.op )
MatOp::divide(e1, e2, res, scale);
else
e2.op->divide(e1, e2, res, scale);
}
void MatOp_AddEx::divide(double s, const MatExpr& e, MatExpr& res) const
{
if( isScaled(e) )
MatOp_Bin::makeExpr(res, '/', e.a, Mat(), s/e.alpha);
else
MatOp::divide(s, e, res);
}
void MatOp_AddEx::transpose(const MatExpr& e, MatExpr& res) const
{
if( isScaled(e) )
MatOp_T::makeExpr(res, e.a, e.alpha);
else
MatOp::transpose(e, res);
}
void MatOp_AddEx::abs(const MatExpr& e, MatExpr& res) const
{
if( (!e.b.data || e.beta == 0) && fabs(e.alpha) == 1 )
MatOp_Bin::makeExpr(res, 'a', e.a, -e.s*e.alpha);
else if( e.b.data && e.alpha + e.beta == 0 && e.alpha*e.beta == -1 )
MatOp_Bin::makeExpr(res, 'a', e.a, e.b);
else
MatOp::abs(e, res);
}
void MatOp_AddEx::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
if( (isScaled(e1) || i1) && (isScaled(e2) || i2) )
MatOp_GEMM::makeExpr(res, 0, e1.a, e2.a, alpha1*alpha2);
else if( this == e2.op )
MatOp::matmul(e1, e2, res);
else
e2.op->matmul(e1, e2, res);
}
inline void MatOp_AddEx::makeExpr(MatExpr& res, const Mat& a, const Mat& b, double alpha, double beta, const Scalar& s)
{
res = MatExpr(&g_MatOp_AddEx, 0, a, b, Mat(), alpha, beta, s);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Bin::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || e.a.type() == type ? m : temp;
if( e.flags == '*' )
cv::multiply(e.a, e.b, dst, e.alpha);
else if( e.flags == '/' && e.b.data )
cv::divide(e.a, e.b, dst, e.alpha);
else if( e.flags == '/' && !e.b.data )
cv::divide(e.alpha, e.a, dst );
else if( e.flags == '&' && e.b.data )
bitwise_and(e.a, e.b, dst);
else if( e.flags == '&' && !e.b.data )
bitwise_and(e.a, e.s, dst);
else if( e.flags == '|' && e.b.data )
bitwise_or(e.a, e.b, dst);
else if( e.flags == '|' && !e.b.data )
bitwise_or(e.a, e.s, dst);
else if( e.flags == '^' && e.b.data )
bitwise_xor(e.a, e.b, dst);
else if( e.flags == '^' && !e.b.data )
bitwise_xor(e.a, e.s, dst);
else if( e.flags == '~' && !e.b.data )
bitwise_not(e.a, dst);
else if( e.flags == 'm' && e.b.data )
cv::min(e.a, e.b, dst);
else if( e.flags == 'm' && !e.b.data )
cv::min(e.a, e.s[0], dst);
else if( e.flags == 'M' && e.b.data )
cv::max(e.a, e.b, dst);
else if( e.flags == 'M' && !e.b.data )
cv::max(e.a, e.s[0], dst);
else if( e.flags == 'a' && e.b.data )
cv::absdiff(e.a, e.b, dst);
else if( e.flags == 'a' && !e.b.data )
cv::absdiff(e.a, e.s, dst);
else
CV_Error(CV_StsError, "Unknown operation");
if( dst.data != m.data )
dst.convertTo(m, type);
}
void MatOp_Bin::multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
{
if( isReciprocal(e1) && (isIdentity(e2) || isScaled(e2)) )
MatOp_Bin::makeExpr(res, '/', e2.a, e1.a, e1.alpha*(isIdentity(e2) ? 1 : e2.alpha)*scale);
else if( isReciprocal(e2) && (isIdentity(e1) || isScaled(e1)) )
MatOp_Bin::makeExpr(res, '/', e1.a, e2.a, (isIdentity(e1) ? 1 : e1.alpha)*e2.alpha*scale);
else if( e2.op == this )
MatOp::multiply(e1, e2, res, scale);
else
e2.op->multiply(e1, e2, res, scale);
}
void MatOp_Bin::multiply(const MatExpr& e, double s, MatExpr& res) const
{
if( e.flags == '*' || e.flags == '/' )
{
res = e;
res.alpha *= s;
}
else
MatOp::multiply(e, s, res);
}
void MatOp_Bin::divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
{
if( isReciprocal(e2) )
{
if( isIdentity(e1) || isScaled(e1) )
{
MatOp_Bin::makeExpr(res, '*', e1.a, e2.a, (isIdentity(e1) ? 1 : e1.alpha)*scale/e2.alpha);
return;
}
if( isReciprocal(e1) )
{
MatOp_Bin::makeExpr(res, '/', e2.a, e1.a, e1.alpha*scale/e2.alpha);
return;
}
}
if( e2.op == this )
MatOp::divide(e1, e2, res, scale);
else
e2.op->divide(e1, e2, res, scale);
}
void MatOp_Bin::divide(double s, const MatExpr& e, MatExpr& res) const
{
if( e.flags == '/' && !e.b.data )
MatOp_AddEx::makeExpr(res, e.a, Mat(), s/e.alpha, 0);
else
MatOp::divide(s, e, res);
}
inline void MatOp_Bin::makeExpr(MatExpr& res, char op, const Mat& a, const Mat& b, double scale)
{
res = MatExpr(&g_MatOp_Bin, op, a, b, Mat(), scale, b.data ? 1 : 0);
}
inline void MatOp_Bin::makeExpr(MatExpr& res, char op, const Mat& a, const Scalar& s)
{
res = MatExpr(&g_MatOp_Bin, op, a, Mat(), Mat(), 1, 0, s);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || type == CV_8U ? m : temp;
if( e.b.data )
cv::compare(e.a, e.b, dst, e.flags);
else
cv::compare(e.a, e.alpha, dst, e.flags);
if( dst.data != m.data )
dst.convertTo(m, type);
}
inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, const Mat& b)
{
res = MatExpr(&g_MatOp_Cmp, cmpop, a, b, Mat(), 1, 1);
}
inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, double alpha)
{
res = MatExpr(&g_MatOp_Cmp, cmpop, a, Mat(), Mat(), alpha, 1);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_T::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
cv::transpose(e.a, dst);
if( dst.data != m.data || e.alpha != 1 )
dst.convertTo(m, type, e.alpha);
}
void MatOp_T::multiply(const MatExpr& e, double s, MatExpr& res) const
{
res = e;
res.alpha *= s;
}
void MatOp_T::transpose(const MatExpr& e, MatExpr& res) const
{
if( e.alpha == 1 )
MatOp_Identity::makeExpr(res, e.a);
else
MatOp_AddEx::makeExpr(res, e.a, Mat(), e.alpha, 0);
}
void MatOp_T::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
if( isT(e1) && (isT(e2) || isScaled(e2) || i2))
MatOp_GEMM::makeExpr(res, CV_GEMM_A_T + (isT(e2) ? CV_GEMM_B_T : 0),
e1.a, e2.a, e1.alpha*alpha2);
else if( isT(e2) && (isT(e1) || isScaled(e1) || i1))
MatOp_GEMM::makeExpr(res, CV_GEMM_B_T + (isT(e1) ? CV_GEMM_A_T : 0),
e1.a, e2.a, e2.alpha*alpha1);
else if( this == e2.op )
MatOp::matmul(e1, e2, res);
else
e2.op->matmul(e1, e2, res);
}
inline void MatOp_T::makeExpr(MatExpr& res, const Mat& a, double alpha)
{
res = MatExpr(&g_MatOp_T, 0, a, Mat(), Mat(), alpha, 0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_GEMM::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
cv::gemm(e.a, e.b, e.alpha, e.c, e.beta, dst, e.flags);
if( dst.data != m.data )
dst.convertTo(m, type);
}
void MatOp_GEMM::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
if( isMatProd(e1) && (i2 || isScaled(e2) || isT(e2)) )
MatOp_GEMM::makeExpr(res, (e1.flags & ~CV_GEMM_C_T)|(isT(e2) ? CV_GEMM_C_T : 0),
e1.a, e1.b, alpha1, e2.a, alpha2);
else if( isMatProd(e2) && (i1 || isScaled(e1) || isT(e1)) )
MatOp_GEMM::makeExpr(res, (e2.flags & ~CV_GEMM_C_T)|(isT(e1) ? CV_GEMM_C_T : 0),
e2.a, e2.b, alpha2, e1.a, alpha1);
else if( this == e2.op )
MatOp::add(e1, e2, res);
else
e2.op->add(e1, e2, res);
}
void MatOp_GEMM::subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
if( isMatProd(e1) && (i2 || isScaled(e2) || isT(e2)) )
MatOp_GEMM::makeExpr(res, (e1.flags & ~CV_GEMM_C_T)|(isT(e2) ? CV_GEMM_C_T : 0),
e1.a, e1.b, alpha1, e2.a, -alpha2);
else if( isMatProd(e2) && (i1 || isScaled(e1) || isT(e1)) )
MatOp_GEMM::makeExpr(res, (e2.flags & ~CV_GEMM_C_T)|(isT(e1) ? CV_GEMM_C_T : 0),
e2.a, e2.b, -alpha2, e1.a, alpha1);
else if( this == e2.op )
MatOp::subtract(e1, e2, res);
else
e2.op->subtract(e1, e2, res);
}
void MatOp_GEMM::multiply(const MatExpr& e, double s, MatExpr& res) const
{
res = e;
res.alpha *= s;
res.beta *= s;
}
void MatOp_GEMM::transpose(const MatExpr& e, MatExpr& res) const
{
res = e;
res.flags ^= CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T;
swap(res.a, res.b);
}
inline void MatOp_GEMM::makeExpr(MatExpr& res, int flags, const Mat& a, const Mat& b,
double alpha, const Mat& c, double beta)
{
res = MatExpr(&g_MatOp_GEMM, flags, a, b, c, alpha, beta);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Invert::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
cv::invert(e.a, dst, e.flags);
if( dst.data != m.data )
dst.convertTo(m, type);
}
void MatOp_Invert::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
{
if( isInv(e1) && isIdentity(e2) )
MatOp_Solve::makeExpr(res, e1.flags, e1.a, e2.a);
else if( this == e2.op )
MatOp::matmul(e1, e2, res);
else
e2.op->matmul(e1, e2, res);
}
inline void MatOp_Invert::makeExpr(MatExpr& res, int method, const Mat& m)
{
res = MatExpr(&g_MatOp_Invert, method, m, Mat(), Mat(), 1, 0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Solve::assign(const MatExpr& e, Mat& m, int type) const
{
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp;
cv::solve(e.a, e.b, dst, e.flags);
if( dst.data != m.data )
dst.convertTo(m, type);
}
inline void MatOp_Solve::makeExpr(MatExpr& res, int method, const Mat& a, const Mat& b)
{
res = MatExpr(&g_MatOp_Solve, method, a, b, Mat(), 1, 1);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Initializer::assign(const MatExpr& e, Mat& m, int type) const
{
if( type == -1 )
type = e.a.type();
m.create(e.a.size(), type);
if( e.flags == 'I' )
setIdentity(m, Scalar(e.alpha));
else if( e.flags == '0' )
m = Scalar();
else if( e.flags == '1' )
m = Scalar(e.alpha);
else
CV_Error(CV_StsError, "Invalid matrix initializer type");
}
void MatOp_Initializer::multiply(const MatExpr& e, double s, MatExpr& res) const
{
res = e;
res.alpha *= s;
}
inline void MatOp_Initializer::makeExpr(MatExpr& res, int method, Size sz, int type, double alpha)
{
res = MatExpr(&g_MatOp_Initializer, method, Mat(sz, type, (void*)0), Mat(), Mat(), alpha, 0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
MatExpr Mat::t() const
{
MatExpr e;
MatOp_T::makeExpr(e, *this);
return e;
}
MatExpr Mat::inv(int method) const
{
MatExpr e;
MatOp_Invert::makeExpr(e, method, *this);
return e;
}
MatExpr Mat::mul(const Mat& m, double scale) const
{
MatExpr e;
MatOp_Bin::makeExpr(e, '*', *this, m, scale);
return e;
}
MatExpr Mat::mul(const MatExpr& m, double scale) const
{
MatExpr e;
m.op->multiply(MatExpr(*this), m, e, scale);
return e;
}
MatExpr Mat::zeros(int rows, int cols, int type)
{
MatExpr e;
MatOp_Initializer::makeExpr(e, '0', Size(cols, rows), type);
return e;
}
MatExpr Mat::zeros(Size size, int type)
{
MatExpr e;
MatOp_Initializer::makeExpr(e, '0', size, type);
return e;
}
MatExpr Mat::ones(int rows, int cols, int type)
{
MatExpr e;
MatOp_Initializer::makeExpr(e, '1', Size(cols, rows), type);
return e;
}
MatExpr Mat::ones(Size size, int type)
{
MatExpr e;
MatOp_Initializer::makeExpr(e, '1', size, type);
return e;
}
MatExpr Mat::eye(int rows, int cols, int type)
{
MatExpr e;
MatOp_Initializer::makeExpr(e, 'I', Size(cols, rows), type);
return e;
}
MatExpr Mat::eye(Size size, int type)
{
MatExpr e;
MatOp_Initializer::makeExpr(e, 'I', size, type);
return e;
}
}
/* End of file. */
tests/cv/src/operations.cpp
View file @ ec314cf2
......@@ -342,7 +342,7 @@ bool CV_OperationsTest::TestMat()
m = mi.clone(); m+=(3.0 * mi * mt + d1); CHECK_DIFF_FLT(m, mi + d1 * 4);
m = mi.clone(); m-=(3.0 * mi * mt + d1); CHECK_DIFF_FLT(m, mi - d1 * 4);
m = mi.clone(); m*=(mt * 1.0); CHECK_DIFF_FLT(m, d1);
m = mi.clone(); m*=(mt * 1.0 + 1.0); CHECK_DIFF_FLT(m, d1 + mi);
m = mi.clone(); m*=(mt * 1.0 + Mat::eye(m.size(), m.type())); CHECK_DIFF_FLT(m, d1 + mi);
m = mi.clone(); m*=mt_tr.t(); CHECK_DIFF_FLT(m, d1);
CHECK_DIFF_FLT( (mi * 2) * mt, d2);
......@@ -611,7 +611,7 @@ bool CV_OperationsTest::TestTemplateMat()
if (Mat_<Point3f>(1, 1).channels() != 3) throw test_excep();
if (Mat_<Point3d>(1, 1).channels() != 3) throw test_excep();
Mat_<uchar> eye = Mat_<uchar>::zeros(2, 2); CHECK_DIFF(Mat_<uchar>::zeros(Size(2, 2)), eye);
Mat_<uchar> eye = Mat_<uchar>::zeros(2, 2); CHECK_DIFF(Mat_<uchar>::zeros(Size(2, 2)), eye);
eye.at<uchar>(Point(0,0)) = 1; eye.at<uchar>(1, 1) = 1;
CHECK_DIFF(Mat_<uchar>::eye(2, 2), eye);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment