cvmat.hpp.svn-base

这是于老师移植到dsp的源码

inline void CvMAT::flipX()
{   cvFlip( this, this, 1 );    }


inline void CvMAT::flipY()
{   cvFlip( this, this, 0 );    }


inline void CvMAT::flipXY()
{   cvFlip( this, this, -1 );   }


inline _CvMATElem_ CvMAT::operator ()( int row )
{   return _CvMATElem_( CV_MAT_ELEM_PTR( *this, row, 0 ), type );   }


inline _CvMATConstElem_ CvMAT::operator ()( int row ) const
{   return _CvMATConstElem_( CV_MAT_ELEM_PTR( *this, row, 0 ), type ); }


inline _CvMATElem_ CvMAT::operator ()( int row, int col )
{   return _CvMATElem_( CV_MAT_ELEM_PTR( *this, row, col ), type ); }


inline _CvMATConstElem_ CvMAT::operator ()( int row, int col ) const
{   return _CvMATConstElem_( CV_MAT_ELEM_PTR( *this, row, col ), type ); }


inline _CvMATElemCn_ CvMAT::operator()( int row, int col, int coi )
{   return _CvMATElemCn_( CV_MAT_ELEM_PTR( *this, row, col ), type, coi );  }


inline _CvMATElemCn_ CvMAT::operator()( CvPoint pt, int coi )
{   return _CvMATElemCn_( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type, coi );  }


inline double CvMAT::operator()( int row, int col, int coi ) const
{   return get( CV_MAT_ELEM_PTR( *this, row, col ), type, coi );    }


inline _CvMATElem_ CvMAT::operator ()( CvPoint pt )
{   return _CvMATElem_( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type ); }


inline _CvMATConstElem_ CvMAT::operator ()( CvPoint pt ) const
{   return _CvMATConstElem_( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type ); }


inline double CvMAT::operator()( CvPoint pt, int coi ) const
{   return get( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type, coi );    }


inline void* CvMAT::ptr( int row )
{   return CV_MAT_ELEM_PTR( *this, row, 0 );    }


inline const void* CvMAT::ptr( int row ) const
{   return (const void*)CV_MAT_ELEM_PTR( *this, row, 0 );   }


inline void* CvMAT::ptr( int row, int col )
{   return CV_MAT_ELEM_PTR( *this, row, col );  }


inline const void* CvMAT::ptr( int row, int col ) const
{   return (const void*)CV_MAT_ELEM_PTR( *this, row, col ); }


inline void* CvMAT::ptr( CvPoint pt )
{   return CV_MAT_ELEM_PTR( *this, pt.y, pt.x );    }


inline const void* CvMAT::ptr( CvPoint pt ) const
{   return (const void*)CV_MAT_ELEM_PTR( *this, pt.y, pt.x ); }


inline _CvMAT_INV_ CvMAT::inv( int method ) const
{   return _CvMAT_INV_( this, method ); }


inline _CvMAT_T_ CvMAT::t() const
{   return _CvMAT_T_( this );   }


inline _CvMAT_COPY_ CvMAT::clone() const
{   return _CvMAT_COPY_( this ); }

inline _CvMAT_CVT_ CvMAT::cvt( int newdepth, double scale, double shift ) const
{   return _CvMAT_CVT_( this, newdepth, scale, shift ); }


inline CvMAT::CvMAT( const CvMat& mat, CvRect rect )
{   
    type = 0;
    cvGetSubArr( &mat, this, rect );
    cvIncRefData( this );
}


/* submatrix:
     k == 0 - i-th row
     k > 0 - i-th column
     k < 0 - i-th diagonal */
inline CvMAT::CvMAT( const CvMat& mat, int k, int i )
{
    type = 0;
    if( k == 0 )
        cvGetRow( &mat, this, i );
    else if( k > 0 )
        cvGetCol( &mat, this, i );
    else
        cvGetDiag( &mat, this, i );
    cvIncRefData( this );
}


inline CvMAT CvMAT::row( int r ) const
{   return CvMAT( *this, 0, r );  }


inline CvMAT CvMAT::col( int c ) const
{   return CvMAT( *this, 1, c );  }


inline CvMAT CvMAT::diag( int d ) const
{   return CvMAT( *this, -1, d );  }


inline CvMAT CvMAT::rect( CvRect rect ) const
{   return CvMAT( *this, rect );    }

inline CvMAT CvMAT::rowrange( int row1, int row2 ) const
{   
    assert( 0 <= row1 && row1 < row2 && row2 <= height );
    return CvMAT( *this, cvRect( 0, row1, width, row2 - row1 ));
}

inline CvMAT CvMAT::colrange( int col1, int col2 ) const
{   
    assert( 0 <= col1 && col1 < col2 && col2 <= width );
    return CvMAT( *this, cvRect( col1, 0, col2 - col1, height ));
}

inline _CvMAT_DOT_OP_ CvMAT::mul( const CvMAT& mat ) const
{   return _CvMAT_DOT_OP_( this, &mat, '*' );   }

inline _CvMAT_DOT_OP_ CvMAT::mul( const _CvMAT_SCALE_& mat ) const
{   return _CvMAT_DOT_OP_( this, mat.a, '*', mat.alpha );   }

inline _CvMAT_DOT_OP_ CvMAT::div( const CvMAT& mat ) const
{   return _CvMAT_DOT_OP_( this, &mat, '/' );  }

inline _CvMAT_DOT_OP_ CvMAT::div( const _CvMAT_SCALE_& mat ) const
{   return _CvMAT_DOT_OP_( this, mat.a, '/', 1./mat.alpha );    }

inline _CvMAT_DOT_OP_ CvMAT::min( const CvMAT& mat ) const
{   return _CvMAT_DOT_OP_( this, &mat, 'm' );   }

inline _CvMAT_DOT_OP_ CvMAT::max( const CvMAT& mat ) const
{   return _CvMAT_DOT_OP_( this, &mat, 'M' );   }

inline _CvMAT_DOT_OP_ CvMAT::min( double value ) const
{   return _CvMAT_DOT_OP_( this, 0, 'm', value );   }

inline _CvMAT_DOT_OP_ CvMAT::max( double value ) const
{   return _CvMAT_DOT_OP_( this, 0, 'M', value );   }

inline _CvMAT_DOT_OP_ CvMAT::abs() const
{   return _CvMAT_DOT_OP_( this, 0, 'a', 0 );   }

/****************************************************************************************\
*                               binary operations (+,-,*)                                *
\****************************************************************************************/

/*
* PART I. Scaling, shifting, addition/subtraction operations
*/

/* (mat2^t) = (mat1^t) * scalar */
inline _CvMAT_T_ operator * ( const _CvMAT_T_& a, double alpha )
{   return _CvMAT_T_( &a.a, a.alpha*alpha );  }

/* (mat2^t) = scalar * (mat1^t) */
inline _CvMAT_T_ operator * ( double alpha, const _CvMAT_T_& a )
{   return _CvMAT_T_( &a.a, a.alpha*alpha );  }

/* -(mat^t) */
inline _CvMAT_T_ operator - ( const _CvMAT_T_& a )
{   return _CvMAT_T_( &a.a, -a.alpha ); }

/* mat_scaled = mat * scalar */
inline _CvMAT_SCALE_ operator * ( const CvMAT& a, double alpha )
{   return _CvMAT_SCALE_( &a, alpha );  }

/* mat_scaled = scalar * mat */
inline _CvMAT_SCALE_ operator * ( double alpha, const CvMAT& a )
{   return _CvMAT_SCALE_( &a, alpha );  }

/* mat_scaled2 = mat_scaled1 * scalar */
inline _CvMAT_SCALE_ operator * ( const _CvMAT_SCALE_& a, double alpha )
{   return _CvMAT_SCALE_( a.a, a.alpha*alpha ); }

/* mat_scaled2 = scalar * mat_scaled1 */
inline _CvMAT_SCALE_ operator * ( double alpha, const _CvMAT_SCALE_& a )
{   return _CvMAT_SCALE_( a.a, a.alpha*alpha ); }

/* -mat_scaled */
inline _CvMAT_SCALE_ operator - ( const _CvMAT_SCALE_& a )
{   return _CvMAT_SCALE_( a.a, -a.alpha ); }


/* mat_scaled_shifted = mat + scalar */
inline _CvMAT_SCALE_SHIFT_ operator + ( const CvMAT& a, double beta )
{   return _CvMAT_SCALE_SHIFT_( &a, 1, beta );  }

/* mat_scaled_shifted = scalar + mat */
inline _CvMAT_SCALE_SHIFT_ operator + ( double beta, const CvMAT& a )
{   return _CvMAT_SCALE_SHIFT_( &a, 1, beta );  }

/* mat_scaled_shifted = mat - scalar */
inline _CvMAT_SCALE_SHIFT_ operator - ( const CvMAT& a, double beta )
{   return _CvMAT_SCALE_SHIFT_( &a, 1, -beta ); }

/* mat_scaled_shifted = scalar - mat */
inline _CvMAT_SCALE_SHIFT_ operator - ( double beta, const CvMAT& a )
{   return _CvMAT_SCALE_SHIFT_( &a, -1, beta ); }

/* mat_scaled_shifted = mat_scaled + scalar */
inline _CvMAT_SCALE_SHIFT_ operator + ( const _CvMAT_SCALE_& a, double beta )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, beta );   }

/* mat_scaled_shifted = scalar + mat_scaled */
inline _CvMAT_SCALE_SHIFT_ operator + ( double beta, const _CvMAT_SCALE_& a )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, beta );   }

/* mat_scaled_shifted = mat_scaled - scalar */
inline _CvMAT_SCALE_SHIFT_ operator - ( const _CvMAT_SCALE_& a, double beta )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, -beta );  }

/* mat_scaled_shifted = scalar - mat_scaled */
inline _CvMAT_SCALE_SHIFT_ operator - ( double beta, const _CvMAT_SCALE_& a )
{   return _CvMAT_SCALE_SHIFT_( a.a, -a.alpha, beta );  }

/* mat_scaled_shifted2 = mat_scaled_shifted1 + scalar */
inline _CvMAT_SCALE_SHIFT_ operator + ( const _CvMAT_SCALE_SHIFT_& a, double beta )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, a.beta + beta );  }

/* mat_scaled_shifted2 = scalar + mat_scaled_shifted1 */
inline _CvMAT_SCALE_SHIFT_ operator + ( double beta, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, a.beta + beta );  }

/* mat_scaled_shifted2 = mat_scaled_shifted1 - scalar */
inline _CvMAT_SCALE_SHIFT_ operator - ( const _CvMAT_SCALE_SHIFT_& a, double beta )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, a.beta - beta );  }

/* mat_scaled_shifted2 = scalar - mat_scaled_shifted1 */
inline _CvMAT_SCALE_SHIFT_ operator - ( double beta, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_SCALE_SHIFT_( a.a, -a.alpha, beta - a.beta ); }

/* mat_scaled_shifted2 = mat_scaled_shifted1 * scalar */
inline _CvMAT_SCALE_SHIFT_ operator * ( const _CvMAT_SCALE_SHIFT_& a, double alpha )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha*alpha, a.beta*alpha ); }

/* mat_scaled_shifted2 = scalar * mat_scaled_shifted1 */
inline _CvMAT_SCALE_SHIFT_ operator * ( double alpha, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha*alpha, a.beta*alpha ); }

/* -mat_scaled_shifted */
inline _CvMAT_SCALE_SHIFT_ operator - ( const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_SCALE_SHIFT_( a.a, -a.alpha, -a.beta ); }


/* -mat1 */
inline _CvMAT_SCALE_ operator - ( const CvMAT& a )
{   return _CvMAT_SCALE_( &a, -1 );   }

/* mat_add = mat1 + mat2 */
inline _CvMAT_ADD_ operator + ( const CvMAT& a, const CvMAT& b )
{   return _CvMAT_ADD_( &a, &b );   }

/* mat_add = mat1 - mat2 */
inline _CvMAT_ADD_ operator - ( const CvMAT& a, const CvMAT& b )
{   return _CvMAT_ADD_( &a, &b, -1 );    }

/* mat_add = mat_scaled1 + mat2 */
inline _CvMAT_ADD_ operator + ( const _CvMAT_SCALE_& a, const CvMAT& b )
{   return _CvMAT_ADD_( &b, a.a, a.alpha );  }

/* mat_add = mat1 + mat_scaled2 */
inline _CvMAT_ADD_ operator + ( const CvMAT& b, const _CvMAT_SCALE_& a )
{   return _CvMAT_ADD_( &b, a.a, a.alpha );  }

/* -mat_add */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_& a )
{   return _CvMAT_ADD_EX_( a.a, -1, a.b, -a.beta ); }

/* mat_add = mat_scaled1 - mat2 */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_& a, const CvMAT& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, -1 ); }

/* mat_add = mat1 - mat_scaled2 */
inline _CvMAT_ADD_ operator - ( const CvMAT& b, const _CvMAT_SCALE_& a )
{   return _CvMAT_ADD_( &b, a.a, -a.alpha ); }

/* mat_add = mat_scaled_shifted1 + mat2 */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_SHIFT_& a, const CvMAT& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, 1, a.beta ); }

/* mat_add = mat1 + mat_scaled_shifted2 */
inline _CvMAT_ADD_EX_ operator + ( const CvMAT& b, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, 1, a.beta ); }

/* mat_add = mat_scaled_shifted1 - mat2 */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_SHIFT_& a, const CvMAT& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, -1, a.beta ); }

/* mat_add = mat1 - mat_scaled_shifted2 */
inline _CvMAT_ADD_EX_ operator - ( const CvMAT& b, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_ADD_EX_( a.a, -a.alpha, &b, 1, -a.beta ); }

/* mat_add = mat_scaled_shifted1 + mat_scaled2 */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_SHIFT_& a, const _CvMAT_SCALE_& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha, a.beta ); }

/* mat_add = mat_scaled1 + mat_scaled_shifted2 */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_& b, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha, a.beta ); }

/* mat_add = mat_scaled_shifted1 - mat_scaled2 */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_SHIFT_& a, const _CvMAT_SCALE_& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, -b.alpha, a.beta ); }

/* mat_add = mat_scaled1 - mat_scaled_shifted2 */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_& b, const _CvMAT_SCALE_SHIFT_& a )
{   return _CvMAT_ADD_EX_( a.a, -a.alpha, b.a, b.alpha, -a.beta ); }

/* mat_add = mat_scaled1 + mat_scaled2 */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_& a, const _CvMAT_SCALE_& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha ); }

/* mat_add = mat_scaled1 - mat_scaled2 */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_& a, const _CvMAT_SCALE_& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, -b.alpha ); }

/* mat_add = mat_scaled_shifted1 + mat_scaled_shifted2 */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_SHIFT_& a,
                                const _CvMAT_SCALE_SHIFT_& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha, a.beta + b.beta ); }

/* mat_add = mat_scaled_shifted1 - mat_scaled_shifted2 */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_SHIFT_& a,
                                const _CvMAT_SCALE_SHIFT_& b )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, -b.alpha, a.beta - b.beta ); }

/* mat_add2 = mat_add1 + scalar */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_ADD_EX_& a, double gamma )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, a.b, a.beta, a.gamma + gamma ); }

/* mat_add2 = scalar + mat_add1 */
inline _CvMAT_ADD_EX_ operator + ( double gamma, const _CvMAT_ADD_EX_& a )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, a.b, a.beta, a.gamma + gamma ); }

/* mat_add2 = mat_add1 - scalar */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_EX_& a, double gamma )
{   return _CvMAT_ADD_EX_( a.a, a.alpha, a.b, a.beta, a.gamma - gamma ); }

/* mat_add2 = scalar - mat_add1 */
inline _CvMAT_ADD_EX_ operator - ( double gamma, const _CvMAT_ADD_EX_& a )
{   return _CvMAT_ADD_EX_( a.a, -a.alpha, a.b, -a.beta, gamma - a.gamma ); }

/* mat_add2 = mat_add1 * scalar */
inline _CvMAT_ADD_EX_ operator * ( const _CvMAT_ADD_EX_& a, double alpha )
{   return _CvMAT_ADD_EX_( a.a, a.alpha*alpha, a.b, a.beta*alpha, a.gamma*alpha ); }

/* mat_add2 = scalar * mat_add1 */
inline _CvMAT_ADD_EX_ operator * ( double alpha, const _CvMAT_ADD_EX_& a )
{   return _CvMAT_ADD_EX_( a.a, a.alpha*alpha, a.b, a.beta*alpha, a.gamma*alpha ); }

/* mat_add2 = mat_add1 + scalar */
inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_ADD_& a, double gamma )
{   return _CvMAT_ADD_EX_( a.a, 1, a.b, a.beta, gamma ); }

/* mat_add2 = scalar + mat_add1 */
inline _CvMAT_ADD_EX_ operator + ( double gamma, const _CvMAT_ADD_& a )
{   return _CvMAT_ADD_EX_( a.a, 1, a.b, a.beta, gamma ); }

/* mat_add2 = mat_add1 - scalar */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_& a, double gamma )
{   return _CvMAT_ADD_EX_( a.a, 1, a.b, a.beta, -gamma ); }

/* mat_add2 = scalar - mat_add1 */
inline _CvMAT_ADD_EX_ operator - ( double gamma, const _CvMAT_ADD_& a )
{   return _CvMAT_ADD_EX_( a.a, -1, a.b, -a.beta, gamma ); }

/* mat_add2 = mat_add1 * scalar */
inline _CvMAT_ADD_EX_ operator * ( const _CvMAT_ADD_& a, double alpha )
{   return _CvMAT_ADD_EX_( a.a, alpha, a.b, a.beta*alpha, 0 ); }

/* mat_add2 = scalar * mat_add1 */
inline _CvMAT_ADD_EX_ operator * ( double alpha, const _CvMAT_ADD_& a )
{   return _CvMAT_ADD_EX_( a.a, alpha, a.b, a.beta*alpha, 0 ); }

/* -mat_add_ex */
inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_EX_& a )
{   return _CvMAT_ADD_EX_( a.a, -a.alpha, a.b, -a.beta, -a.gamma ); }


/*
* PART II. Matrix multiplication.
*/

/* mmul = mat1 * mat2 */
inline _CvMAT_MUL_ operator * ( const CvMAT& a, const CvMAT& b )
{   return _CvMAT_MUL_( &a, &b, 0 );    }

/* mmul = (mat1^t) * mat2 */
inline _CvMAT_MUL_ operator * ( const _CvMAT_T_& a, const CvMAT& b )
{   return _CvMAT_MUL_( &a.a, &b, a.alpha, 1 );   }

/* mmul = mat1 * (mat2^t) */
inline _CvMAT_MUL_ operator * ( const CvMAT& b, const _CvMAT_T_& a )
{   return _CvMAT_MUL_( &b, &a.a, a.alpha, 2 );  }

/* mmul = (mat1^t) * (mat2^t) */
inline _CvMAT_MUL_ operator * ( const _CvMAT_T_& a, const _CvMAT_T_& b )
{   return _CvMAT_MUL_( &a.a, &b.a, a.alpha*b.alpha, 3 );  }

/* mmul = mat_scaled1 * mat2 */
inline _CvMAT_MUL_ operator * ( const _CvMAT_SCALE_& a, const CvMAT& b )
{   return _CvMAT_MUL_( a.a, &b, a.alpha, 0 ); }

/* mmul = mat1 * mat_scaled2 */
inline _CvMAT_MUL_ operator * ( const CvMAT& b, const _CvMAT_SCALE_& a )
{   return _CvMAT_MUL_( &b, a.a, a.alpha, 0 ); }