OpenCV源码阅读(2)---matx.h---函数的内联实现

最新推荐文章于 2022-04-01 21:47:45 发布
最新推荐文章于 2022-04-01 21:47:45 发布
阅读量269 收藏
点赞数
文章标签： 人工智能 c/c++

外部矩阵计算函数

namespace internal
{

template<typename _Tp, int m> struct Matx_DetOp
{
    double operator ()(const Matx<_Tp, m, m>& a) const
    {
        Matx<_Tp, m, m> temp = a;
        double p = LU(temp.val, m*sizeof(_Tp), m, 0, 0, 0);
        if( p == 0 )
            return p;
        for( int i = 0; i < m; i++ )
            p *= temp(i, i);
        return 1./p;
    }
};

template<typename _Tp> struct Matx_DetOp<_Tp, 1>
{
    double operator ()(const Matx<_Tp, 1, 1>& a) const
    {
        return a(0,0);
    }
};

template<typename _Tp> struct Matx_DetOp<_Tp, 2>
{
    double operator ()(const Matx<_Tp, 2, 2>& a) const
    {
        return a(0,0)*a(1,1) - a(0,1)*a(1,0);
    }
};

template<typename _Tp> struct Matx_DetOp<_Tp, 3>
{
    double operator ()(const Matx<_Tp, 3, 3>& a) const
    {
        return a(0,0)*(a(1,1)*a(2,2) - a(2,1)*a(1,2)) -
            a(0,1)*(a(1,0)*a(2,2) - a(2,0)*a(1,2)) +
            a(0,2)*(a(1,0)*a(2,1) - a(2,0)*a(1,1));
    }
};

上面的函数定义了矩阵行列式计算的计算。高于3阶的矩阵使用LU分解算法，低于3阶矩阵对Matx_DetOp进行了重载，使用直接计算行列式的方式来计算。这里使用的是在结构体里定义计算的方式。这样做的目的是什么呢？需要继续看类是如何调用这些操作的

template<typename _Tp> Vec<_Tp, 2> inline conjugate(const Vec<_Tp, 2>& v)
{
    return Vec<_Tp, 2>(v[0], -v[1]);
}

template<typename _Tp> Vec<_Tp, 4> inline conjugate(const Vec<_Tp, 4>& v)
{
    return Vec<_Tp, 4>(v[0], -v[1], -v[2], -v[3]);
}

这里使用内联的方式来实现向量共轭的计算。。。但是向量类中并没有定义共轭函数conjugate，只有一个conj。这是错误吗？

矩阵构造函数与基本运算

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx()
{
    for(int i = 0; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0)
{
    val[0] = v0;
    for(int i = 1; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1)
{
    CV_StaticAssert(channels >= 2, "Matx should have at least 2 elaments.");
    val[0] = v0; val[1] = v1;
    for(int i = 2; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2)
{
    CV_StaticAssert(channels >= 3, "Matx should have at least 3 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2;
    for(int i = 3; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3)
{
    CV_StaticAssert(channels >= 4, "Matx should have at least 4 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    for(int i = 4; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4)
{
    CV_StaticAssert(channels >= 5, "Matx should have at least 5 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3; val[4] = v4;
    for(int i = 5; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5)
{
    CV_StaticAssert(channels >= 6, "Matx should have at least 6 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5;
    for(int i = 6; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6)
{
    CV_StaticAssert(channels >= 7, "Matx should have at least 7 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5; val[6] = v6;
    for(int i = 7; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7)
{
    CV_StaticAssert(channels >= 8, "Matx should have at least 8 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
    for(int i = 8; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8)
{
    CV_StaticAssert(channels >= 9, "Matx should have at least 9 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
    val[8] = v8;
    for(int i = 9; i < channels; i++) val[i] = _Tp(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9)
{
    CV_StaticAssert(channels >= 10, "Matx should have at least 10 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
    val[8] = v8; val[9] = v9;
    for(int i = 10; i < channels; i++) val[i] = _Tp(0);
}


template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11)
{
    CV_StaticAssert(channels == 12, "Matx should have at least 12 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
    val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9, _Tp v10, _Tp v11, _Tp v12, _Tp v13, _Tp v14, _Tp v15)
{
    CV_StaticAssert(channels == 16, "Matx should have at least 16 elaments.");
    val[0] = v0; val[1] = v1; val[2] = v2; val[3] = v3;
    val[4] = v4; val[5] = v5; val[6] = v6; val[7] = v7;
    val[8] = v8; val[9] = v9; val[10] = v10; val[11] = v11;
    val[12] = v12; val[13] = v13; val[14] = v14; val[15] = v15;
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n>::Matx(const _Tp* values)
{
    for( int i = 0; i < channels; i++ ) val[i] = values[i];
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n> Matx<_Tp, m, n>::all(_Tp alpha)
{
    Matx<_Tp, m, n> M;
    for( int i = 0; i < m*n; i++ ) M.val[i] = alpha;
    return M;
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n> Matx<_Tp,m,n>::zeros()
{
    return all(0);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n> Matx<_Tp,m,n>::ones()
{
    return all(1);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n> Matx<_Tp,m,n>::eye()
{
    Matx<_Tp,m,n> M;
    for(int i = 0; i < shortdim; i++)
        M(i,i) = 1;
    return M;
}

template<typename _Tp, int m, int n> inline
_Tp Matx<_Tp, m, n>::dot(const Matx<_Tp, m, n>& M) const
{
    _Tp s = 0;
    for( int i = 0; i < channels; i++ ) s += val[i]*M.val[i];
    return s;
}

template<typename _Tp, int m, int n> inline
double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const
{
    double s = 0;
    for( int i = 0; i < channels; i++ ) s += (double)val[i]*M.val[i];
    return s;
}

/** @cond IGNORED */
template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d)
{
    Matx<_Tp,m,n> M;
    for(int i = 0; i < shortdim; i++)
        M(i,i) = d(i, 0);
    return M;
}

这一大段使用内联函数实现了矩阵的定义和加，减，点乘，点除等基础操作，使用内联的作用是提高效率。可以看出，对于低阶矩阵，opencv的做法十分粗暴，直接访问数组数据成员，然后赋值。不过在赋值和构造之前使用了CV_staticAssert来验证是否会溢出，这是c++的断言功能，不知opencv是如何重新利用的。

template<typename _Tp, int m, int n> template<typename T2>
inline Matx<_Tp, m, n>::operator Matx<T2, m, n>() const
{
    Matx<T2, m, n> M;
    for( int i = 0; i < m*n; i++ ) M.val[i] = saturate_cast<T2>(val[i]);
    return M;
}

这个函数作用是操作符的重载，重载了操作符()，作用是复制一个矩阵。其中使用了saturate_cast<T2> 模板函数，作用是防止内存溢出，但是这个函数不在这个文件中，我猜在bufferpool.h里。

template<typename _Tp, int m, int n> template<int m1, int n1> inline
Matx<_Tp, m1, n1> Matx<_Tp, m, n>::reshape() const
{
    CV_StaticAssert(m1*n1 == m*n, "Input and destnarion matrices must have the same number of elements");
    return (const Matx<_Tp, m1, n1>&)*this;
}

reshape函数，作用是将具有相同元素数目的矩阵转换形式。例如9*1–>3*3

template<typename _Tp, int m, int n>
template<int m1, int n1> inline
Matx<_Tp, m1, n1> Matx<_Tp, m, n>::get_minor(int i, int j) const
{
    CV_DbgAssert(0 <= i && i+m1 <= m && 0 <= j && j+n1 <= n);
    Matx<_Tp, m1, n1> s;
    for( int di = 0; di < m1; di++ )
        for( int dj = 0; dj < n1; dj++ )
            s(di, dj) = (*this)(i+di, j+dj);
    return s;
}

由矩阵的第i行，第j列开始，抽取一个较小的矩阵。

这里使用了this指针的方式，把this指针式只想类所定义的对象的指针，也就是说，如果定义Matx m（3，3）, m.get_minor(2,2) 那么this指针是只想m的，所以可以用(*this)的方式表示提取m中的数据。

template<typename _Tp, int m, int n> inline
Matx<_Tp, 1, n> Matx<_Tp, m, n>::row(int i) const
{
    CV_DbgAssert((unsigned)i < (unsigned)m);
    return Matx<_Tp, 1, n>(&val[i*n]);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, 1> Matx<_Tp, m, n>::col(int j) const
{
    CV_DbgAssert((unsigned)j < (unsigned)n);
    Matx<_Tp, m, 1> v;
    for( int i = 0; i < m; i++ )
        v.val[i] = val[i*n + j];
    return v;
}

提取第i行第j列的函数，对于提取行，可以直接使用val[i*n]的方式，这种方式表达的是，因为val[m*n] 是一个m*n的数组，是一个一维数组。如果是一个行矩阵的话，可以用这个数组的首地址进行初始化，将母矩阵该行首地址作为子矩阵数据首地址即可。并且这些函数都是const类型，保护了原本矩阵的数据。

template<typename _Tp, int m, int n> inline
typename Matx<_Tp, m, n>::diag_type Matx<_Tp, m, n>::diag() const
{
    diag_type d;
    for( int i = 0; i < shortdim; i++ )
        d.val[i] = val[i*n + i];
    return d;
}

提取对角元素。

template<typename _Tp, int m, int n> inline
const _Tp& Matx<_Tp, m, n>::operator()(int i, int j) const
{
    CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
    return this->val[i*n + j];
}

template<typename _Tp, int m, int n> inline
_Tp& Matx<_Tp, m, n>::operator ()(int i, int j)
{
    CV_DbgAssert( (unsigned)i < (unsigned)m && (unsigned)j < (unsigned)n );
    return val[i*n + j];
}

template<typename _Tp, int m, int n> inline
const _Tp& Matx<_Tp, m, n>::operator ()(int i) const
{
    CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
    CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
    return val[i];
}

template<typename _Tp, int m, int n> inline
_Tp& Matx<_Tp, m, n>::operator ()(int i)
{
    CV_StaticAssert(m == 1 || n == 1, "Single index indexation requires matrix to be a column or a row");
    CV_DbgAssert( (unsigned)i < (unsigned)(m+n-1) );
    return val[i];
}

重载操作符（）,用于访问矩阵内元素，操作符重载是c++中非常重要的操作。这里使用了_Tp & Matx<_Tp,m,n>::operator ()(int i,int j){} 是把操作符重载为成员函数的做法。其中,i是第一个操作数，j是第二个操作数。

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp)
{
    for( int i = 0; i < channels; i++ )
        val[i] = saturate_cast<_Tp>(a.val[i] + b.val[i]);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp)
{
    for( int i = 0; i < channels; i++ )
        val[i] = saturate_cast<_Tp>(a.val[i] - b.val[i]);
}

template<typename _Tp, int m, int n> template<typename _T2> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp)
{
    for( int i = 0; i < channels; i++ )
        val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp)
{
    for( int i = 0; i < channels; i++ )
        val[i] = saturate_cast<_Tp>(a.val[i] * b.val[i]);
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_DivOp)
{
    for( int i = 0; i < channels; i++ )
        val[i] = saturate_cast<_Tp>(a.val[i] / b.val[i]);
}

template<typename _Tp, int m, int n> template<int l> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp)
{
    for( int i = 0; i < m; i++ )
        for( int j = 0; j < n; j++ )
        {
            _Tp s = 0;
            for( int k = 0; k < l; k++ )
                s += a(i, k) * b(k, j);
            val[i*n + j] = s;
        }
}

template<typename _Tp, int m, int n> inline
Matx<_Tp,m,n>::Matx(const Matx<_Tp, n, m>& a, Matx_TOp)
{
    for( int i = 0; i < m; i++ )
        for( int j = 0; j < n; j++ )
            val[i*n + j] = a(j, i);
}

特殊的矩阵构造函数
定义了矩阵的基本操作，包括加减乘除缩放，这些操作作为矩阵的构造函数，可以生成一个新的矩阵，也就是支持由两个矩阵生成新的矩阵。

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n> Matx<_Tp, m, n>::mul(const Matx<_Tp, m, n>& a) const
{
    return Matx<_Tp, m, n>(*this, a, Matx_MulOp());
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n> Matx<_Tp, m, n>::div(const Matx<_Tp, m, n>& a) const
{
    return Matx<_Tp, m, n>(*this, a, Matx_DivOp());
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, n, m> Matx<_Tp, m, n>::t() const
{
    return Matx<_Tp, n, m>(*this, Matx_TOp());
    template<typename _Tp, int m, int n> inline
}
Vec<_Tp, n> Matx<_Tp, m, n>::solve(const Vec<_Tp, m>& rhs, int method) const
{
    Matx<_Tp, n, 1> x = solve((const Matx<_Tp, m, 1>&)(rhs), method);
    return (Vec<_Tp, n>&)(x);
}

template<typename _Tp, int m> static inline
double determinant(const Matx<_Tp, m, m>& a)
{
    return internal::Matx_DetOp<_Tp, m>()(a);
}

template<typename _Tp, int m, int n> static inline
double trace(const Matx<_Tp, m, n>& a)
{
    _Tp s = 0;
    for( int i = 0; i < std::min(m, n); i++ )
        s += a(i,i);
    return s;
}

template<typename _Tp, int m, int n> static inline
double norm(const Matx<_Tp, m, n>& M)
{
    return std::sqrt(normL2Sqr<_Tp, double>(M.val, m*n));
}

template<typename _Tp, int m, int n> static inline
double norm(const Matx<_Tp, m, n>& M, int normType)
{
    return normType == NORM_INF ? (double)normInf<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n) :
        normType == NORM_L1 ? (double)normL1<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n) :
        std::sqrt((double)normL2Sqr<_Tp, typename DataType<_Tp>::work_type>(M.val, m*n));
}

实现矩阵本身的乘，除，转置操作。如果已经有了一个两个矩阵，可以以成员函数的方式来生成结果。例如

Matx a(####);
Matx b(####);
Matx c;
c=a.mul(b);
Matx d(a,b,Mul_OP)

template<typename _Tp, typename _T2, int m, int n> static inline
MatxCommaInitializer<_Tp, m, n> operator << (const Matx<_Tp, m, n>& mtx, _T2 val)
{
    MatxCommaInitializer<_Tp, m, n> commaInitializer((Matx<_Tp, m, n>*)&mtx);
    return (commaInitializer, val);
}

template<typename _Tp, int m, int n> inline
MatxCommaInitializer<_Tp, m, n>::MatxCommaInitializer(Matx<_Tp, m, n>* _mtx)
    : dst(_mtx), idx(0)
{}

template<typename _Tp, int m, int n> template<typename _T2> inline
MatxCommaInitializer<_Tp, m, n>& MatxCommaInitializer<_Tp, m, n>::operator , (_T2 value)
{
    CV_DbgAssert( idx < m*n );
    dst->val[idx++] = saturate_cast<_Tp>(value);
    return *this;
}

template<typename _Tp, int m, int n> inline
Matx<_Tp, m, n> MatxCommaInitializer<_Tp, m, n>::operator *() const
{
    CV_DbgAssert( idx == n*m );
    return *dst;
}

一种往已有矩阵添加数的方法，具体情况不清楚。

/ Matx out-of-class operators 

template<typename _Tp1, typename _Tp2, int m, int n> static inline
Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
{
    for( int i = 0; i < m*n; i++ )
        a.val[i] = saturate_cast<_Tp1>(a.val[i] + b.val[i]);
    return a;
}

template<typename _Tp1, typename _Tp2, int m, int n> static inline
Matx<_Tp1, m, n>& operator -= (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b)
{
    for( int i = 0; i < m*n; i++ )
        a.val[i] = saturate_cast<_Tp1>(a.val[i] - b.val[i]);
    return a;
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator + (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
{
    return Matx<_Tp, m, n>(a, b, Matx_AddOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b)
{
    return Matx<_Tp, m, n>(a, b, Matx_SubOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, int alpha)
{
    for( int i = 0; i < m*n; i++ )
        a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
    return a;
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, float alpha)
{
    for( int i = 0; i < m*n; i++ )
        a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
    return a;
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n>& operator *= (Matx<_Tp, m, n>& a, double alpha)
{
    for( int i = 0; i < m*n; i++ )
        a.val[i] = saturate_cast<_Tp>(a.val[i] * alpha);
    return a;
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, int alpha)
{
    return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, float alpha)
{
    return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator * (const Matx<_Tp, m, n>& a, double alpha)
{
    return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator * (int alpha, const Matx<_Tp, m, n>& a)
{
    return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator * (float alpha, const Matx<_Tp, m, n>& a)
{
    return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator * (double alpha, const Matx<_Tp, m, n>& a)
{
    return Matx<_Tp, m, n>(a, alpha, Matx_ScaleOp());
}

template<typename _Tp, int m, int n> static inline
Matx<_Tp, m, n> operator - (const Matx<_Tp, m, n>& a)
{
    return Matx<_Tp, m, n>(a, -1, Matx_ScaleOp());
}

template<typename _Tp, int m, int n, int l> static inline
Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
{
    return Matx<_Tp, m, n>(a, b, Matx_MatMulOp());
}

template<typename _Tp, int m, int n> static inline
Vec<_Tp, m> operator * (const Matx<_Tp, m, n>& a, const Vec<_Tp, n>& b)
{
    Matx<_Tp, m, 1> c(a, b, Matx_MatMulOp());
    return (const Vec<_Tp, m>&)(c);
}

非成员函数的运算符重载，将重载后的操作定义在类外。

_Tp& operator *(const _Tp &a,const _Tp &b){a=a+b;return a;}
返回引用的意思是返回返回值的引用。
比如上面代码的意思就是返回a的引用
执行c=a*b那么c就是a的引用，而a又是a+b并且这个函数没有定义变量，也就是说没有额外的内存开销，所有使用的变量都是前面程序里面已经有的。这里千万不能有const 因为一旦加上数据保护，那么这个数据就不能再更改了，a就还是a 最后c返回a 的引用没有什么意义

版权声明：本文为博主原创文章，未经博主允许不得转载。

 

weixin_34390996
关注
OpenCV-Python实战（1）——OpenCV简介与图像处理基础
盼小辉丶的博客
08-10 23万+
OpenCV 是一个的跨平台计算机视觉库，可以运行在 Linux、Windows 和 Mac OS 操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时也提供了 Python 接口，实现了图像处理和计算机视觉方面的很多通用算法。在本文中，将介绍 OpenCV 库，包括它的主要模块和典型应用场景，同时使用 OpenCV-Python 实战讲解图像处理基础要点。
Conda安装opencv4.5和opencv-contrib
t18438605018的博客
01-06 7886
1.conda创建虚拟环境（可选） conda create -n pytorch python=3.8 更多细节，可参考博客 2.激活虚拟环境（可选） conda activate pytorch 3.安装opencv-python pip install opencv-python==4.5.1.18 注：不带版本号的话，默认安装最新版。带版本号的话一定要确定有此版本，否则找不到该版本。 更过细节，可看opencv-python官网 4.安装opencv-contrib-python p
OpenCV中基本数据结构(6)_Matx
weixin_42730667的博客
01-30 1823
Matx为OpenCV轻量级的矩阵，被称为fixed matrix classes，意思是每个矩阵的大小都是固定的，主要是应对矩阵数据比较小的场景，最新的版本4.0不超过6*6大小的矩阵，旧版本一般不超过5*5，它的出现主要是应对小数据场景，因为是fixed matrix,所以其占用空间大小都是在编译阶段都是已知且固定好的，因为为轻量级的，数据较小，相对Mat，其申请和释放都是非常快速的，一般比较...
OpenCV学习(3): Mat 类使用
吕爽
04-23 1853
Mat 类使用 Mat 类使用 构造 基本参数 type变量 Scalar类型 Size类型 维数与通道 Range类型 Rect类型 其他类型转化为矩阵 运算 加、减、乘 赋值 点乘、叉乘 element-wise 乘、除 特殊矩阵 拷贝 特殊操作 类型转换 ROI提取 元素访问 返回指针的函数 内存管理 其他函数 公共变量 构造 基本参数 Mat...
Opencv数据类型(三)：Matx类和Vec类
hjxu2016的博客
12-16 6176
文章目录1、cv::Matx支持的操作 cv::Matx类又称固定矩阵类，需要是维度已知，因为所有数据都是在堆栈上分配的,所以分配和清除都很快，而且在小型矩阵(22,33等)做过特别优化。cv::Matx类是opencv_c++基本类型的核心，固定向量类继承固定矩阵类。 一般情况下，当你要来处理矩阵代数的矩阵的时候，需要用到固定矩阵类；如果对象是一个图像或者大型浮点的大数组，那么推荐用cv::Ma...
C++ bug解决经验（一）
RandyOliver's House
04-01 3634
C++ bug解决经验（一） 1 error: expected initializer before ‘namespace’ 仔细检查下，头文件定义函数时未添加分号，或者函数未写完就编译了。 2 ‘typedef’ was ignored in this declaration 原因：结构体没有定义别名 解决：曲调typedef或者在结构体括号外添加别名 typedef struct Vehicle { std::string name; }Veh; // veh就是别名 3 坐标转换之
OpenCV笔记 （轻量级Matx）
weixin_30701521的博客
04-24 132
//一个轻量的数值数组，值是分配在栈上的。这个代表一个二维数组。template<typename_Tp,intm,intn>classMatx{public:typedef_Tpvalue_type;typedefMatx<_Tp,(m<n?m:n),1>diag_type;typedefMatx&lt...
opencv人脸识别--detectMultiScale函数_源码
12-31
opencv人脸识别--detectMultiScale函数
opencv-windows-x86_64.jar
06-14
opencv的驱动引用包，兼容windows的x86,x64平台
OpenCV源码阅读(1)---matx.h---mat类与vec类
锈铁工作室
05-12 3302
matx.h matx类是opencv中的一个基础类，其位于core模块中，所执行的操作时opencv矩阵和向量的运算。如果熟悉基于matlab的图像处理，那么很容易想到，所有对图像的操作归根结底都是对矩阵的操作。尽管matx类不是opencv最基础的类，但是我认为以此进入图像处理学习和熟悉c++程序是合适的。 1.头文件和基础 #ifndef __OPENCV_CORE_MATX_HPP_
OpenCv中向量模板类Vec的表示
qq_40119386的博客
03-22 2578
Vec的表示 ---- Vec2b，Vec3b，Vec2s,Vec3s//【1】Vec2b---表示每个Vec2b对象中,存储2个char(字符型)数据 typedef Vec<uchar, 2> Vec2b; 、 //【2】Vec3b---表示每一个Vec3b对象中,存储3个char(字符型)数据,比如用这样的对象,去存储RGB图像中的一个像素点 typedef Vec<uc...
Eigen的使用
u013243710的专栏
06-12 5678
１Eigen在ROS中的配置： 　　　在CMakeLists.txt中必须加上：find_package(Eigen REQUIRED) ... include_directories( ${catkin_INCLUDE_DIRS} ${Eigen_INCLUDE_DIRS} )由于ROS Indigo中出现的变化，需要依赖cmake_modules，因此可以在下面加入：find_pack
Opencv Mat的三种常用类型简介
weixin_34315665的博客
08-15 354
本系列文章由 @YhL_Leo 出品，转载请注明出处。 文章链接： http://blog.csdn.net/yhl_leo/article/details/47683127 本文主要介绍Opencv常用的三种Mat类型：Mat，Mat_，Matx。 1. Mat 1.1 创建与初始化 int rows = 3, cols = 1; cv::...
【OpenCV】关于Mat_类的一个问题
YiYueHuan的专栏
08-05 3058
// 方式一 Mat matrix1 = (Mat_<int>(2, 3) << 0, 1, 2, 3, 4, 5); // 方式二 Mat matrix2 = *(Mat_<int>(2, 3) << 0, 1, 2, 3, 4, 5); 这两种方式的关系
【opencv13】cv::Matx固定矩阵类/cv::Vec固定向量类
yuanCruise
12-22 3766
1.固定矩阵类 固定矩阵类要在编译之前知道其维度，因此叫做“固定”。因此，这些数据都是保存在栈中，且清理也相当快，有专门为小型优化实现矩阵(2×2,3×3,等等)。在OpenCV的c++接口中，固定矩阵类也是许多其他基本类型的核心。固定向量类派生自固定矩阵类，其他类要么派生自固定向量类(如cv::Scalar)，要么在许多重要操作中依赖于转换到固定向量类。像往常一样，固定矩阵类实际上是一个模板。该...
Ubuntu18.04编译ORB-SLAM3及遇到的一些问题
Robert_Q的博客
09-27 4601
Ubuntu18.04编译ORB-SLAM3遇到的一些问题1. 安装Pangolin2. 编译源代码 1. 安装Pangolin 通过源码编译安装完成后，测试十四讲中高博的示例代码，编译可以通过，但在执行时会报错：error while loading shared libraries: libpangolin.so: cannot open shared object file: No such file or directory，大概就是没有链接上动态库，需要修改一个配置文件，告诉他去/usr/loca
Ubuntu20.04配置ORB_SLAM3并简单运行
Leon的博客
10-17 4258
1.Pangolin v6（稳定版）的安装 官方下载地址： https://github.com/stevenlovegrove/Pangolin/archive/refs/tags/v0.6.zip 也可以从我的资源中下载： Pangolin-0.6.zip-Ubuntu文档类资源-CSDN下载 # 安装依赖项 sudo apt-get install libglew-dev sudo apt-get install libboost-dev libboost-thread-dev libbo
下载opencv-python *.*.*.**版本whl文件
资源摘要信息:"opencv-python-*.*.*.**-cp36-abi3-win_amd64.whl" 知识点详细说明： 1. 文件格式解释： - 文件扩展名为`.whl`，代表这是一个Python的轮子（Wheel）文件。Wheel是一种Python的分发包格式，用于简化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值