2018-02-06 00:16:33 +08:00
|
|
|
// This file is part of OpenCV project.
|
|
|
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
|
|
|
// of this distribution and at http://opencv.org/license.html
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
|
|
|
|
/* ////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Mat basic operations: Copy, Set
|
|
|
|
//
|
|
|
|
// */
|
|
|
|
|
|
|
|
#include "precomp.hpp"
|
|
|
|
|
|
|
|
namespace cv
|
|
|
|
{
|
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_Identity CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_Identity() {}
|
|
|
|
virtual ~MatOp_Identity() {}
|
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return true; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
static void makeExpr(MatExpr& res, const Mat& m);
|
|
|
|
};
|
|
|
|
|
|
|
|
static MatOp_Identity g_MatOp_Identity;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_AddEx CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_AddEx() {}
|
|
|
|
virtual ~MatOp_AddEx() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return true; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void add(const MatExpr& e1, const Scalar& s, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void multiply(const MatExpr& e1, double s, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void divide(double s, const MatExpr& e, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void transpose(const MatExpr& e1, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void abs(const MatExpr& expr, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_Bin CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_Bin() {}
|
|
|
|
virtual ~MatOp_Bin() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return true; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void multiply(const MatExpr& e1, double s, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void divide(double s, const MatExpr& e, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_Cmp CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_Cmp() {}
|
|
|
|
virtual ~MatOp_Cmp() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return true; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
};
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
static MatOp_Cmp g_MatOp_Cmp;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_GEMM CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_GEMM() {}
|
|
|
|
virtual ~MatOp_GEMM() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return false; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void multiply(const MatExpr& e, double s, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void transpose(const MatExpr& expr, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_Invert CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_Invert() {}
|
|
|
|
virtual ~MatOp_Invert() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return false; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
static void makeExpr(MatExpr& res, int method, const Mat& m);
|
2012-06-09 23:00:04 +08:00
|
|
|
};
|
2010-09-21 23:15:44 +08:00
|
|
|
|
|
|
|
static MatOp_Invert g_MatOp_Invert;
|
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_T CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_T() {}
|
|
|
|
virtual ~MatOp_T() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return false; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void multiply(const MatExpr& e1, double s, MatExpr& res) const CV_OVERRIDE;
|
|
|
|
void transpose(const MatExpr& expr, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
static void makeExpr(MatExpr& res, const Mat& a, double alpha=1);
|
|
|
|
};
|
|
|
|
|
|
|
|
static MatOp_T g_MatOp_T;
|
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_Solve CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_Solve() {}
|
|
|
|
virtual ~MatOp_Solve() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return false; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
static void makeExpr(MatExpr& res, int method, const Mat& a, const Mat& b);
|
|
|
|
};
|
|
|
|
|
|
|
|
static MatOp_Solve g_MatOp_Solve;
|
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
class MatOp_Initializer CV_FINAL : public MatOp
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
MatOp_Initializer() {}
|
|
|
|
virtual ~MatOp_Initializer() {}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
bool elementWise(const MatExpr& /*expr*/) const CV_OVERRIDE { return false; }
|
|
|
|
void assign(const MatExpr& expr, Mat& m, int type=-1) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-03-15 21:16:50 +08:00
|
|
|
void multiply(const MatExpr& e, double s, MatExpr& res) const CV_OVERRIDE;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
static void makeExpr(MatExpr& res, int method, Size sz, int type, double alpha=1);
|
2013-03-01 13:18:44 +08:00
|
|
|
static void makeExpr(MatExpr& res, int method, int ndims, const int* sizes, int type, double alpha=1);
|
2010-09-21 23:15:44 +08:00
|
|
|
};
|
|
|
|
|
2014-04-02 09:00:44 +08:00
|
|
|
static MatOp_Initializer* getGlobalMatOpInitializer()
|
|
|
|
{
|
2015-06-23 19:31:01 +08:00
|
|
|
CV_SINGLETON_LAZY_INIT(MatOp_Initializer, new MatOp_Initializer())
|
2014-04-02 09:00:44 +08:00
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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; }
|
2011-04-17 21:14:45 +08:00
|
|
|
static inline bool isCmp(const MatExpr& e) { return e.op == &g_MatOp_Cmp; }
|
2010-09-21 23:15:44 +08:00
|
|
|
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; }
|
2011-04-17 21:14:45 +08:00
|
|
|
static inline bool isSolve(const MatExpr& e) { return e.op == &g_MatOp_Solve; }
|
2010-09-21 23:15:44 +08:00
|
|
|
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); }
|
2014-04-02 09:00:44 +08:00
|
|
|
static inline bool isInitializer(const MatExpr& e) { return e.op == getGlobalMatOpInitializer(); }
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2013-03-30 23:03:55 +08:00
|
|
|
MatOp::MatOp() {}
|
|
|
|
MatOp::~MatOp() {}
|
|
|
|
|
|
|
|
|
2010-09-28 16:45:44 +08:00
|
|
|
bool MatOp::elementWise(const MatExpr& /*expr*/) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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());
|
|
|
|
}
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignAdd(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
|
|
|
m += temp;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignSubtract(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
|
|
|
m -= temp;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignMultiply(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
|
|
|
m *= temp;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignDivide(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
|
|
|
m /= temp;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignAnd(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
|
|
|
m &= temp;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignOr(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
|
|
|
m |= temp;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::augAssignXor(const MatExpr& expr, Mat& m) const
|
|
|
|
{
|
|
|
|
Mat temp;
|
|
|
|
expr.op->assign(expr, temp);
|
2013-04-01 15:16:47 +08:00
|
|
|
m ^= temp;
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
void MatOp::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( this == e2.op )
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2010-09-22 21:07:51 +08:00
|
|
|
double alpha = 1, beta = 1;
|
|
|
|
Scalar s;
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m1, m2;
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isAddEx(e1) && (!e1.b.data || e1.beta == 0) )
|
|
|
|
{
|
|
|
|
m1 = e1.a;
|
|
|
|
alpha = e1.alpha;
|
|
|
|
s = e1.s;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e1.op->assign(e1, m1);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isAddEx(e2) && (!e2.b.data || e2.beta == 0) )
|
|
|
|
{
|
|
|
|
m2 = e2.a;
|
|
|
|
beta = e2.alpha;
|
|
|
|
s += e2.s;
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
2010-09-22 21:07:51 +08:00
|
|
|
else
|
|
|
|
e2.op->assign(e2, m2);
|
|
|
|
MatOp_AddEx::makeExpr(res, m1, m2, alpha, beta, s);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
else
|
2010-09-22 21:07:51 +08:00
|
|
|
e2.op->add(e1, e2, res);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m1;
|
|
|
|
expr1.op->assign(expr1, m1);
|
|
|
|
MatOp_AddEx::makeExpr(res, m1, Mat(), 1, 0, s);
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
void MatOp::subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( this == e2.op )
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2010-09-22 21:07:51 +08:00
|
|
|
double alpha = 1, beta = -1;
|
|
|
|
Scalar s;
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m1, m2;
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isAddEx(e1) && (!e1.b.data || e1.beta == 0) )
|
|
|
|
{
|
|
|
|
m1 = e1.a;
|
|
|
|
alpha = e1.alpha;
|
|
|
|
s = e1.s;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e1.op->assign(e1, m1);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isAddEx(e2) && (!e2.b.data || e2.beta == 0) )
|
|
|
|
{
|
|
|
|
m2 = e2.a;
|
|
|
|
beta = -e2.alpha;
|
|
|
|
s -= e2.s;
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
2010-09-22 21:07:51 +08:00
|
|
|
else
|
|
|
|
e2.op->assign(e2, m2);
|
|
|
|
MatOp_AddEx::makeExpr(res, m1, m2, alpha, beta, s);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
else
|
2010-09-22 21:07:51 +08:00
|
|
|
e2.op->subtract(e1, e2, res);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m;
|
|
|
|
expr.op->assign(expr, m);
|
|
|
|
MatOp_AddEx::makeExpr(res, m, Mat(), -1, 0, s);
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
void MatOp::multiply(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( this == e2.op )
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
|
|
|
Mat m1, m2;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isReciprocal(e1) )
|
|
|
|
{
|
|
|
|
if( isScaled(e2) )
|
|
|
|
{
|
|
|
|
scale *= e2.alpha;
|
|
|
|
m2 = e2.a;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e2.op->assign(e2, m2);
|
|
|
|
|
|
|
|
MatOp_Bin::makeExpr(res, '/', m2, e1.a, scale/e1.alpha);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char op = '*';
|
|
|
|
if( isScaled(e1) )
|
|
|
|
{
|
|
|
|
m1 = e1.a;
|
|
|
|
scale *= e1.alpha;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e1.op->assign(e1, m1);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isScaled(e2) )
|
|
|
|
{
|
|
|
|
m2 = e2.a;
|
|
|
|
scale *= e2.alpha;
|
|
|
|
}
|
|
|
|
else if( isReciprocal(e2) )
|
|
|
|
{
|
|
|
|
op = '/';
|
|
|
|
m2 = e2.a;
|
2018-04-04 23:36:02 +08:00
|
|
|
scale *= e2.alpha;
|
2010-09-22 21:07:51 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
e2.op->assign(e2, m2);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
MatOp_Bin::makeExpr(res, op, m1, m2, scale);
|
|
|
|
}
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
else
|
2010-09-22 21:07:51 +08:00
|
|
|
e2.op->multiply(e1, e2, res, scale);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::multiply(const MatExpr& expr, double s, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m;
|
|
|
|
expr.op->assign(expr, m);
|
2012-06-09 23:00:04 +08:00
|
|
|
MatOp_AddEx::makeExpr(res, m, Mat(), s, 0);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
void MatOp::divide(const MatExpr& e1, const MatExpr& e2, MatExpr& res, double scale) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( this == e2.op )
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isReciprocal(e1) && isReciprocal(e2) )
|
|
|
|
MatOp_Bin::makeExpr(res, '/', e2.a, e1.a, e1.alpha/e2.alpha);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Mat m1, m2;
|
|
|
|
char op = '/';
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isScaled(e1) )
|
|
|
|
{
|
|
|
|
m1 = e1.a;
|
|
|
|
scale *= e1.alpha;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e1.op->assign(e1, m1);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isScaled(e2) )
|
|
|
|
{
|
|
|
|
m2 = e2.a;
|
|
|
|
scale /= e2.alpha;
|
|
|
|
}
|
|
|
|
else if( isReciprocal(e2) )
|
|
|
|
{
|
|
|
|
m2 = e2.a;
|
|
|
|
scale /= e2.alpha;
|
|
|
|
op = '*';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e2.op->assign(e2, m2);
|
|
|
|
MatOp_Bin::makeExpr(res, op, m1, m2, scale);
|
|
|
|
}
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
else
|
2010-09-22 21:07:51 +08:00
|
|
|
e2.op->divide(e1, e2, res, scale);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::divide(double s, const MatExpr& expr, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m;
|
|
|
|
expr.op->assign(expr, m);
|
|
|
|
MatOp_Bin::makeExpr(res, '/', m, Mat(), s);
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::abs(const MatExpr& expr, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m;
|
|
|
|
expr.op->assign(expr, m);
|
|
|
|
MatOp_Bin::makeExpr(res, 'a', m, Mat());
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::transpose(const MatExpr& expr, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m;
|
|
|
|
expr.op->assign(expr, m);
|
|
|
|
MatOp_T::makeExpr(res, m, 1);
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
void MatOp::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2010-09-22 21:07:51 +08:00
|
|
|
if( this == e2.op )
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2010-09-22 21:07:51 +08:00
|
|
|
double scale = 1;
|
|
|
|
int flags = 0;
|
2010-09-21 23:15:44 +08:00
|
|
|
Mat m1, m2;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isT(e1) )
|
|
|
|
{
|
|
|
|
flags = CV_GEMM_A_T;
|
|
|
|
scale = e1.alpha;
|
|
|
|
m1 = e1.a;
|
|
|
|
}
|
|
|
|
else if( isScaled(e1) )
|
|
|
|
{
|
|
|
|
scale = e1.alpha;
|
|
|
|
m1 = e1.a;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e1.op->assign(e1, m1);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( isT(e2) )
|
|
|
|
{
|
|
|
|
flags |= CV_GEMM_B_T;
|
|
|
|
scale *= e2.alpha;
|
|
|
|
m2 = e2.a;
|
|
|
|
}
|
|
|
|
else if( isScaled(e2) )
|
|
|
|
{
|
|
|
|
scale *= e2.alpha;
|
|
|
|
m2 = e2.a;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e2.op->assign(e2, m2);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
MatOp_GEMM::makeExpr(res, flags, m1, m2, scale);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
else
|
2010-09-22 21:07:51 +08:00
|
|
|
e2.op->matmul(e1, e2, res);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp::invert(const MatExpr& expr, int method, MatExpr& res) const
|
|
|
|
{
|
|
|
|
Mat m;
|
|
|
|
expr.op->assign(expr, m);
|
|
|
|
MatOp_Invert::makeExpr(res, method, m);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
|
2011-04-17 21:14:45 +08:00
|
|
|
Size MatOp::size(const MatExpr& expr) const
|
|
|
|
{
|
|
|
|
return !expr.a.empty() ? expr.a.size() : expr.b.empty() ? expr.b.size() : expr.c.size();
|
|
|
|
}
|
2010-09-21 23:15:44 +08:00
|
|
|
|
2011-04-17 21:14:45 +08:00
|
|
|
int MatOp::type(const MatExpr& expr) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2011-04-17 21:14:45 +08:00
|
|
|
return !expr.a.empty() ? expr.a.type() : expr.b.empty() ? expr.b.type() : expr.c.type();
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
MatExpr::MatExpr(const Mat& m) : op(&g_MatOp_Identity), flags(0), a(m), b(Mat()), c(Mat()), alpha(1), beta(0), s(Scalar())
|
|
|
|
{
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator + (const Mat& a, const Scalar& s)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_AddEx::makeExpr(e, a, Mat(), 1, 0, s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator + (const Scalar& s, const Mat& a)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_AddEx::makeExpr(e, a, Mat(), 1, 0, s);
|
|
|
|
return e;
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator + (const MatExpr& e, const Mat& m)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->add(e, MatExpr(m), en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator + (const Mat& m, const MatExpr& e)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->add(e, MatExpr(m), en);
|
|
|
|
return en;
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator + (const MatExpr& e, const Scalar& s)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->add(e, s, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator - (const Mat& a, const Scalar& s)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_AddEx::makeExpr(e, a, Mat(), 1, 0, -s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator - (const Scalar& s, const Mat& a)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_AddEx::makeExpr(e, a, Mat(), -1, 0, s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator - (const MatExpr& e, const Mat& m)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->subtract(e, MatExpr(m), en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator - (const Mat& m, const MatExpr& e)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->subtract(MatExpr(m), e, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator - (const MatExpr& e, const Scalar& s)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->add(e, -s, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator - (const Scalar& s, const MatExpr& e)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->subtract(s, e, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator / (const Mat& a, double s)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_AddEx::makeExpr(e, a, Mat(), 1./s, 0);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator / (double s, const Mat& a)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, '/', a, Mat(), s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator / (const MatExpr& e, const Mat& m)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->divide(e, MatExpr(m), en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator / (const Mat& m, const MatExpr& e)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->divide(MatExpr(m), e, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator / (const MatExpr& e, double s)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->multiply(e, 1./s, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator / (double s, const MatExpr& e)
|
|
|
|
{
|
|
|
|
MatExpr en;
|
|
|
|
e.op->divide(s, e, en);
|
|
|
|
return en;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator < (const Mat& a, double s)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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;
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr min(const Mat& a, const Mat& b)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, 'm', a, b);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr min(const Mat& a, double s)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
2014-07-10 04:35:56 +08:00
|
|
|
MatOp_Bin::makeExpr(e, 'n', a, s);
|
2010-09-21 23:15:44 +08:00
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr min(double s, const Mat& a)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
2014-07-10 04:35:56 +08:00
|
|
|
MatOp_Bin::makeExpr(e, 'n', a, s);
|
2010-09-21 23:15:44 +08:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
MatExpr max(const Mat& a, const Mat& b)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, 'M', a, b);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr max(const Mat& a, double s)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
2014-07-10 04:35:56 +08:00
|
|
|
MatOp_Bin::makeExpr(e, 'N', a, s);
|
2010-09-21 23:15:44 +08:00
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr max(double s, const Mat& a)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
2014-07-10 04:35:56 +08:00
|
|
|
MatOp_Bin::makeExpr(e, 'N', a, s);
|
2010-09-21 23:15:44 +08:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
MatExpr operator & (const Mat& a, const Mat& b)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, '&', a, b);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator & (const Mat& a, const Scalar& s)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, '&', a, s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator & (const Scalar& s, const Mat& a)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, '&', a, s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator | (const Mat& a, const Mat& b)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, '|', a, b);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr operator | (const Mat& a, const Scalar& s)
|
|
|
|
{
|
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, '|', a, s);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Bin::makeExpr(e, 'a', a, Scalar());
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
MatExpr abs(const MatExpr& e)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr en;
|
|
|
|
e.op->abs(e, en);
|
|
|
|
return en;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2011-04-17 21:14:45 +08:00
|
|
|
Size MatExpr::size() const
|
|
|
|
{
|
|
|
|
if( isT(*this) || isInv(*this) )
|
|
|
|
return Size(a.rows, a.cols);
|
|
|
|
if( isGEMM(*this) )
|
|
|
|
return Size(b.cols, a.rows);
|
|
|
|
if( isSolve(*this) )
|
|
|
|
return Size(b.cols, a.cols);
|
|
|
|
if( isInitializer(*this) )
|
|
|
|
return a.size();
|
|
|
|
return op ? op->size(*this) : Size();
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
|
2011-04-17 21:14:45 +08:00
|
|
|
int MatExpr::type() const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2011-04-17 21:14:45 +08:00
|
|
|
if( isInitializer(*this) )
|
|
|
|
return a.type();
|
|
|
|
if( isCmp(*this) )
|
|
|
|
return CV_8U;
|
|
|
|
return op ? op->type(*this) : -1;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_Identity::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
if( _type == -1 || _type == e.a.type() )
|
2010-09-21 23:15:44 +08:00
|
|
|
m = e.a;
|
|
|
|
else
|
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
CV_Assert( CV_MAT_CN(_type) == e.a.channels() );
|
|
|
|
e.a.convertTo(m, _type);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
inline void MatOp_Identity::makeExpr(MatExpr& res, const Mat& m)
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2010-09-22 21:07:51 +08:00
|
|
|
res = MatExpr(&g_MatOp_Identity, 0, m, Mat(), Mat(), 1, 0);
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int _type) const
|
|
|
|
{
|
|
|
|
Mat temp, &dst = _type == -1 || e.a.type() == _type ? m : temp;
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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))
|
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
e.a.convertTo(m, _type, e.alpha, e.s[0]);
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( dst.data != m.data )
|
|
|
|
dst.convertTo(m, m.type());
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_AddEx::add(const MatExpr& e, const Scalar& s, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
|
|
|
res.s += s;
|
|
|
|
}
|
|
|
|
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_AddEx::subtract(const Scalar& s, const MatExpr& e, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
|
|
|
res.alpha = -res.alpha;
|
|
|
|
res.beta = -res.beta;
|
|
|
|
res.s = s - res.s;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_AddEx::multiply(const MatExpr& e, double s, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
|
|
|
res.alpha *= s;
|
|
|
|
res.beta *= s;
|
|
|
|
res.s *= s;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_AddEx::divide(double s, const MatExpr& e, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( isScaled(e) )
|
|
|
|
MatOp_T::makeExpr(res, e.a, e.alpha);
|
|
|
|
else
|
|
|
|
MatOp::transpose(e, res);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_AddEx::abs(const MatExpr& e, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_Bin::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
Mat temp, &dst = _type == -1 || e.a.type() == _type ? m : temp;
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
2014-07-10 04:35:56 +08:00
|
|
|
else if( e.flags == 'm' )
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::min(e.a, e.b, dst);
|
2014-07-10 04:35:56 +08:00
|
|
|
else if( e.flags == 'n' )
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::min(e.a, e.s[0], dst);
|
2014-07-10 04:35:56 +08:00
|
|
|
else if( e.flags == 'M' )
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::max(e.a, e.b, dst);
|
2014-07-10 04:35:56 +08:00
|
|
|
else if( e.flags == 'N' )
|
2010-09-21 23:15:44 +08:00
|
|
|
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");
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( dst.data != m.data )
|
2012-06-09 23:00:04 +08:00
|
|
|
dst.convertTo(m, _type);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MatOp_Bin::multiply(const MatExpr& e, double s, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( e.flags == '*' || e.flags == '/' )
|
|
|
|
{
|
|
|
|
res = e;
|
|
|
|
res.alpha *= s;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
MatOp::multiply(e, s, res);
|
|
|
|
}
|
|
|
|
|
|
|
|
void MatOp_Bin::divide(double s, const MatExpr& e, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-22 21:07:51 +08:00
|
|
|
if( e.flags == '/' && (!e.b.data || e.beta == 0) )
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
Mat temp, &dst = _type == -1 || _type == CV_8U ? m : temp;
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( e.b.data )
|
|
|
|
cv::compare(e.a, e.b, dst, e.flags);
|
|
|
|
else
|
|
|
|
cv::compare(e.a, e.alpha, dst, e.flags);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( dst.data != m.data )
|
2012-06-09 23:00:04 +08:00
|
|
|
dst.convertTo(m, _type);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_T::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::transpose(e.a, dst);
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( dst.data != m.data || e.alpha != 1 )
|
2012-06-09 23:00:04 +08:00
|
|
|
dst.convertTo(m, _type, e.alpha);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MatOp_T::multiply(const MatExpr& e, double s, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
|
|
|
res.alpha *= s;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_T::transpose(const MatExpr& e, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
if( e.alpha == 1 )
|
|
|
|
MatOp_Identity::makeExpr(res, e.a);
|
|
|
|
else
|
|
|
|
MatOp_AddEx::makeExpr(res, e.a, Mat(), e.alpha, 0);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
inline void MatOp_T::makeExpr(MatExpr& res, const Mat& a, double alpha)
|
|
|
|
{
|
|
|
|
res = MatExpr(&g_MatOp_T, 0, a, Mat(), Mat(), alpha, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_GEMM::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::gemm(e.a, e.b, e.alpha, e.c, e.beta, dst, e.flags);
|
|
|
|
if( dst.data != m.data )
|
2012-06-09 23:00:04 +08:00
|
|
|
dst.convertTo(m, _type);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MatOp_GEMM::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
|
|
|
|
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_GEMM::subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
bool i1 = isIdentity(e1), i2 = isIdentity(e2);
|
|
|
|
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
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
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
|
|
|
res.alpha *= s;
|
|
|
|
res.beta *= s;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
void MatOp_GEMM::transpose(const MatExpr& e, MatExpr& res) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
2012-06-28 04:51:48 +08:00
|
|
|
res.flags = (!(e.flags & CV_GEMM_A_T) ? CV_GEMM_B_T : 0) |
|
|
|
|
(!(e.flags & CV_GEMM_B_T) ? CV_GEMM_A_T : 0) |
|
|
|
|
(!(e.flags & CV_GEMM_C_T) ? CV_GEMM_C_T : 0);
|
2010-09-21 23:15:44 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_Invert::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::invert(e.a, dst, e.flags);
|
|
|
|
if( dst.data != m.data )
|
2012-06-09 23:00:04 +08:00
|
|
|
dst.convertTo(m, _type);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_Solve::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
cv::solve(e.a, e.b, dst, e.flags);
|
|
|
|
if( dst.data != m.data )
|
2012-06-09 23:00:04 +08:00
|
|
|
dst.convertTo(m, _type);
|
2010-09-21 23:15:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////
|
2012-06-09 23:00:04 +08:00
|
|
|
|
|
|
|
void MatOp_Initializer::assign(const MatExpr& e, Mat& m, int _type) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2012-06-09 23:00:04 +08:00
|
|
|
if( _type == -1 )
|
|
|
|
_type = e.a.type();
|
2013-03-01 13:18:44 +08:00
|
|
|
|
|
|
|
if( e.a.dims <= 2 )
|
|
|
|
m.create(e.a.size(), _type);
|
|
|
|
else
|
|
|
|
m.create(e.a.dims, e.a.size, _type);
|
|
|
|
|
|
|
|
if( e.flags == 'I' && e.a.dims <= 2 )
|
2010-09-21 23:15:44 +08:00
|
|
|
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
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
res = e;
|
|
|
|
res.alpha *= s;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
inline void MatOp_Initializer::makeExpr(MatExpr& res, int method, Size sz, int type, double alpha)
|
|
|
|
{
|
2015-10-16 22:10:00 +08:00
|
|
|
res = MatExpr(getGlobalMatOpInitializer(), method, Mat(sz, type, (void*)(size_t)0xEEEEEEEE), Mat(), Mat(), alpha, 0);
|
2012-06-09 23:00:04 +08:00
|
|
|
}
|
|
|
|
|
2013-03-01 13:18:44 +08:00
|
|
|
inline void MatOp_Initializer::makeExpr(MatExpr& res, int method, int ndims, const int* sizes, int type, double alpha)
|
|
|
|
{
|
2015-10-16 22:10:00 +08:00
|
|
|
res = MatExpr(getGlobalMatOpInitializer(), method, Mat(ndims, sizes, type, (void*)(size_t)0xEEEEEEEE), Mat(), Mat(), alpha, 0);
|
2013-03-01 13:18:44 +08:00
|
|
|
}
|
2010-09-21 23:15:44 +08:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
MatExpr Mat::t() const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_T::makeExpr(e, *this);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr Mat::inv(int method) const
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Invert::makeExpr(e, method, *this);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
|
2011-06-06 22:51:27 +08:00
|
|
|
MatExpr Mat::mul(InputArray m, double scale) const
|
2010-09-21 23:15:44 +08:00
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
2011-06-09 05:35:19 +08:00
|
|
|
if(m.kind() == _InputArray::EXPR)
|
|
|
|
{
|
2013-10-22 18:05:15 +08:00
|
|
|
const MatExpr& me = *(const MatExpr*)m.getObj();
|
2011-06-09 05:35:19 +08:00
|
|
|
me.op->multiply(MatExpr(*this), me, e, scale);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
MatOp_Bin::makeExpr(e, '*', *this, m.getMat(), scale);
|
2010-09-21 23:15:44 +08:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
MatExpr Mat::zeros(int rows, int cols, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, '0', Size(cols, rows), type);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr Mat::zeros(Size size, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, '0', size, type);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2013-03-01 13:18:44 +08:00
|
|
|
MatExpr Mat::zeros(int ndims, const int* sizes, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2013-03-01 13:18:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, '0', ndims, sizes, type);
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr Mat::ones(int rows, int cols, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, '1', Size(cols, rows), type);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr Mat::ones(Size size, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, '1', size, type);
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2013-03-01 13:18:44 +08:00
|
|
|
MatExpr Mat::ones(int ndims, const int* sizes, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2013-03-01 13:18:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, '1', ndims, sizes, type);
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr Mat::eye(int rows, int cols, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, 'I', Size(cols, rows), type);
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
MatExpr Mat::eye(Size size, int type)
|
|
|
|
{
|
2016-08-18 14:53:00 +08:00
|
|
|
CV_INSTRUMENT_REGION()
|
|
|
|
|
2010-09-21 23:15:44 +08:00
|
|
|
MatExpr e;
|
|
|
|
MatOp_Initializer::makeExpr(e, 'I', size, type);
|
|
|
|
return e;
|
|
|
|
}
|
2012-06-09 23:00:04 +08:00
|
|
|
|
2018-02-06 00:16:33 +08:00
|
|
|
} // cv::
|