cvmat.hpp

Simple example of circle detection in OpenCV + C++Builder6.

    CvMAT& operator = ( const _CvMAT_ADD_EX_& mat_add );
    CvMAT& operator = ( const _CvMAT_SCALE_& scale_mat );
    CvMAT& operator = ( const _CvMAT_SCALE_SHIFT_& scale_shift_mat );
    CvMAT& operator = ( const _CvMAT_MUL_& mmul );
    CvMAT& operator = ( const _CvMAT_MUL_ADD_& mmuladd );
    CvMAT& operator = ( const _CvMAT_LOGIC_& mat_logic );
    CvMAT& operator = ( const _CvMAT_UN_LOGIC_& mat_logic );
    CvMAT& operator = ( const _CvMAT_NOT_& not_mat );
    CvMAT& operator = ( const _CvMAT_DOT_OP_& dot_mul );
    CvMAT& operator = ( const _CvMAT_SOLVE_& solve_mat );
    CvMAT& operator = ( const _CvMAT_CMP_& cmp_mat );
    CvMAT& operator = ( const _CvMAT_CVT_& mat_cvt );

    /* copy matrix data, not only matrix header */
    CvMAT& operator = ( const _CvMAT_COPY_& mat_copy );

    /* augmented assignments */
    CvMAT& operator += ( const CvMat& mat );
    CvMAT& operator += ( double val );
    CvMAT& operator += ( const CvScalar& val );
    CvMAT& operator += ( const _CvMAT_SCALE_& scale_mat );
    CvMAT& operator += ( const _CvMAT_SCALE_SHIFT_& scale_mat );
    CvMAT& operator += ( const _CvMAT_MUL_& mmul );

    CvMAT& operator -= ( const CvMat& mat );
    CvMAT& operator -= ( double val );
    CvMAT& operator -= ( const CvScalar& val );
    CvMAT& operator -= ( const _CvMAT_SCALE_& scale_mat );
    CvMAT& operator -= ( const _CvMAT_SCALE_SHIFT_& scale_mat );
    CvMAT& operator -= ( const _CvMAT_MUL_& mmul );

    CvMAT& operator *= ( const CvMat& mat );
    CvMAT& operator *= ( double val );
    CvMAT& operator *= ( const CvScalar& val );
    CvMAT& operator *= ( const _CvMAT_SCALE_& scale_mat );
    CvMAT& operator *= ( const _CvMAT_SCALE_SHIFT_& scale_mat );

    CvMAT& operator &= ( const CvMat& mat );
    CvMAT& operator &= ( double val );
    CvMAT& operator &= ( const CvScalar& val );

    CvMAT& operator |= ( const CvMat& mat );
    CvMAT& operator |= ( double val );
    CvMAT& operator |= ( const CvScalar& val );

    CvMAT& operator ^= ( const CvMat& mat );
    CvMAT& operator ^= ( double val );
    CvMAT& operator ^= ( const CvScalar& val );

    /* various scalar charactertics */
    double norm( int norm_type = CV_L2 ) const;
    double norm( CvMat& mat, int norm_type = CV_L2 ) const;
    CvScalar sum() const;

    double det() const;
    double trace() const;

    _CvMAT_T_  t() const; /* transposition */
    _CvMAT_INV_ inv(int method = 0) const;
    /* inversion using one of the following methods:
          method = 0 - Gaussian elimination,
          method = 1 - SVD */

    _CvMAT_DOT_OP_  mul( const CvMAT& mat ) const;
    _CvMAT_DOT_OP_  mul( const _CvMAT_SCALE_& mat ) const;

    _CvMAT_DOT_OP_  div( const CvMAT& mat ) const;
    _CvMAT_DOT_OP_  div( const _CvMAT_SCALE_& mat ) const;

    _CvMAT_DOT_OP_  min( const CvMAT& mat ) const;
    _CvMAT_DOT_OP_  max( const CvMAT& mat ) const;
    _CvMAT_DOT_OP_  min( double value ) const;
    _CvMAT_DOT_OP_  max( double value ) const;
    double          min( CvPoint* minloc = 0 ) const;
    double          max( CvPoint* maxloc = 0 ) const;

    _CvMAT_DOT_OP_  abs() const;
    
    /* accessing matrix elements */
    _CvMATElem_ operator ()( int row );
    _CvMATConstElem_ operator ()( int row ) const;

    _CvMATElem_ operator ()( int row, int col );
    _CvMATConstElem_ operator ()( int row, int col ) const;

    _CvMATElem_ operator ()( CvPoint loc );
    _CvMATConstElem_ operator ()( CvPoint loc ) const;

    _CvMATElemCn_ operator()( int row, int col, int coi );
    double operator()( int row, int col, int coi ) const;

    _CvMATElemCn_ operator()( CvPoint pt, int coi );
    double operator()( CvPoint pt, int coi ) const;

    void* ptr( int row );
    const void* ptr( int row ) const;

    void* ptr( int row, int col );
    const void* ptr( int row, int col ) const;

    void* ptr( CvPoint pt );
    const void* ptr( CvPoint pt ) const;

    /* accessing matrix parts */
    CvMAT row( int row ) const;
    CvMAT rowrange( int row1, int row2 ) const;
    CvMAT col( int col ) const;
    CvMAT colrange( int col1, int col2 ) const;
    CvMAT rect( CvRect rect ) const;
    CvMAT diag( int diag = 0 ) const;

    _CvMAT_COPY_ clone() const;

    /* convert matrix */
    _CvMAT_CVT_ cvt( int newdepth = -1, double scale = 1,
                     double shift = 0 ) const;

    /* matrix transformation */
    void  reshape( int newcn, int newrows = 0 );
    void  flipX();
    void  flipY();
    void  flipXY();

    /* matrix I/O: use dynamically linked runtime libraries */
    void  write( const char* name = 0, FILE* f = 0, const char* fmt = 0 );
    void  read( char** name = 0, FILE* f = 0 );

    /* decrease matrix data reference counter and clear data pointer */
    void  release();
protected:
    
    void  create( int rows, int cols, int type );
};


/* !!! Internal Use Only !!! */
/* proxies for matrix elements */

/* const_A(i,j) */
struct  CV_EXPORTS _CvMATConstElem_
{
    explicit _CvMATConstElem_( const uchar* ptr, int type );
    operator CvScalar () const;
    double operator ()( int coi = 0 ) const;

    uchar* ptr;
    int type;
};


/* A(i,j,cn) or A(i,j)(cn) */
struct  CV_EXPORTS _CvMATElemCn_
{
    explicit _CvMATElemCn_( uchar* ptr, int type, int coi );
    operator double() const;
    
    _CvMATElemCn_& operator = ( const _CvMATConstElem_& elem );
    _CvMATElemCn_& operator = ( const _CvMATElemCn_& elem );
    _CvMATElemCn_& operator = ( const CvScalar& scalar );
    _CvMATElemCn_& operator = ( double d );
    _CvMATElemCn_& operator = ( float f );
    _CvMATElemCn_& operator = ( int i );

    uchar* ptr;
    int type;
};


/* A(i,j) */
struct  CV_EXPORTS _CvMATElem_ : public _CvMATConstElem_
{
    explicit _CvMATElem_( uchar* ptr, int type );
    _CvMATElemCn_ operator ()( int coi = 0 );

    _CvMATElem_& operator = ( const _CvMATConstElem_& elem );
    _CvMATElem_& operator = ( const _CvMATElem_& elem );
    _CvMATElem_& operator = ( const _CvMATElemCn_& elem );
    _CvMATElem_& operator = ( const CvScalar& val );
    _CvMATElem_& operator = ( double d );
    _CvMATElem_& operator = ( float f );
    _CvMATElem_& operator = ( int i );
};


struct  CV_EXPORTS _CvMAT_BASE_OP_
{
    _CvMAT_BASE_OP_() {};
    virtual operator CvMAT() const = 0;

    _CvMAT_DOT_OP_  mul( const CvMAT& a ) const;
    _CvMAT_DOT_OP_  mul( const _CvMAT_SCALE_& a ) const;

    _CvMAT_DOT_OP_  div( const CvMAT& a ) const;
    _CvMAT_DOT_OP_  div( const _CvMAT_SCALE_& a ) const;

    _CvMAT_DOT_OP_  max( const CvMAT& a ) const;
    _CvMAT_DOT_OP_  min( const CvMAT& a ) const;

    _CvMAT_DOT_OP_  max( double value ) const;
    _CvMAT_DOT_OP_  min( double value ) const;

    double          max( CvPoint* maxloc = 0 ) const;
    double          min( CvPoint* minloc = 0 ) const;

    _CvMAT_DOT_OP_  abs() const;

    _CvMAT_INV_     inv( int method = 0 ) const;
    _CvMAT_T_       t() const;

    CvMAT     row( int row ) const;
    CvMAT     rowrange( int row1, int row2 ) const;
    CvMAT     col( int col ) const;
    CvMAT     colrange( int col1, int col2 ) const;
    CvMAT     rect( CvRect rect ) const;
    CvMAT     diag( int diag = 0 ) const;
    _CvMAT_CVT_     cvt( int newdepth = -1, double scale = 1, double shift = 0 ) const;
    
    double          norm( int norm_type = CV_L2 ) const;
    double          det() const;
    double          trace() const;
    CvScalar        sum() const;
};


/* (A^t)*alpha */
struct  CV_EXPORTS _CvMAT_T_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_T_( const CvMAT* a );
    explicit _CvMAT_T_( const CvMAT* a, double alpha );
    
    double det() const;
    double norm( int normType = CV_L2 ) const;
    operator CvMAT() const;

    CvMAT  a;
    double alpha;
};


/* inv(A) */
struct  CV_EXPORTS _CvMAT_INV_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_INV_( const CvMAT* mat, int method );
    operator CvMAT() const;

    CvMAT a;
    int method;
};


/* (A^ta)*(B^tb)*alpha */
struct  CV_EXPORTS _CvMAT_MUL_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_MUL_( const CvMAT* a, const CvMAT* b, int t_ab );
    explicit _CvMAT_MUL_( const CvMAT* a, const CvMAT* b,
                          double alpha, int t_abc );
    operator CvMAT() const;

    double alpha;
    CvMAT* a;
    CvMAT* b;
    int t_ab; /* (t_ab & 1) = ta, (t_ab & 2) = tb */
};


/* (A^ta)*(B^tb)*alpha + (C^tc)*beta */
struct  CV_EXPORTS _CvMAT_MUL_ADD_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_MUL_ADD_( const CvMAT* a, const CvMAT* b,
                              const CvMAT* c, int t_abc );
    explicit _CvMAT_MUL_ADD_( const CvMAT* a, const CvMAT* b, double alpha,
                              const CvMAT* c, double beta, int t_abc );
    operator CvMAT() const;

    double alpha, beta;
    CvMAT* a;
    CvMAT* b;
    CvMAT* c;
    int t_abc; /* (t_abc & 1) = ta, (t_abc & 2) = tb, (t_abc & 4) = tc */
};


/* A + B*beta */
struct  CV_EXPORTS _CvMAT_ADD_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_ADD_( const CvMAT* a, const CvMAT* b, double beta = 1 );
    operator CvMAT() const;

    double   norm( int norm_type = CV_L2 ) const;
    _CvMAT_DOT_OP_ abs() const;

    double beta;
    CvMAT* a;
    CvMAT* b;
};


/* A*alpha + B*beta + gamma */
struct  CV_EXPORTS _CvMAT_ADD_EX_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_ADD_EX_( const CvMAT* a, double alpha,
                             const CvMAT* b, double beta, double gamma = 0 );
    operator CvMAT() const;

    double alpha, beta, gamma;
    CvMAT* a;
    CvMAT* b;
};


/* A*alpha */
struct  CV_EXPORTS _CvMAT_SCALE_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_SCALE_( const CvMAT* a, double alpha );
    operator CvMAT() const;

    _CvMAT_DOT_OP_  mul( const CvMAT& a ) const;
    _CvMAT_DOT_OP_  mul( const _CvMAT_SCALE_& a ) const;

    _CvMAT_DOT_OP_  div( const CvMAT& a ) const;
    _CvMAT_DOT_OP_  div( const _CvMAT_SCALE_& a ) const;

    double alpha;
    CvMAT* a;
};


/* A*alpha + beta */
struct  CV_EXPORTS _CvMAT_SCALE_SHIFT_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_SCALE_SHIFT_( const CvMAT* a, double alpha, double beta );
    operator CvMAT() const;

    _CvMAT_DOT_OP_  abs() const;

    double alpha, beta;
    CvMAT* a;
};


/* (A & B), (A | B) or (A ^ B) */
struct  CV_EXPORTS _CvMAT_LOGIC_ : public _CvMAT_BASE_OP_
{
    enum Op { AND = 0, OR = 1, XOR = 2 };
    explicit _CvMAT_LOGIC_( const CvMAT* a, const CvMAT* b, Op op, int flags = 0 );
    operator CvMAT() const;

    CvMAT* a;
    CvMAT* b;
    Op op;
    int flags;
};


/* (A & scalar), (A | scalar) or (A ^ scalar) */
struct  CV_EXPORTS _CvMAT_UN_LOGIC_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_UN_LOGIC_( const CvMAT* a, double alpha,
                               _CvMAT_LOGIC_::Op op, int flags = 0 );
    operator CvMAT() const;

    CvMAT* a;
    double alpha;
    _CvMAT_LOGIC_::Op op;
    int flags;
};


/* ~A */
struct  CV_EXPORTS _CvMAT_NOT_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_NOT_( const CvMAT* a );
    operator CvMAT() const;

    CvMAT* a;
};


/* conversion of data type */
struct  CV_EXPORTS _CvMAT_CVT_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_CVT_( const CvMAT* a, int newdepth = -1,
                          double scale = 1, double shift = 0 );
    operator CvMAT() const;

    CvMAT a;
    int newdepth;
    double scale, shift;
};


/* conversion of data type */
struct  CV_EXPORTS _CvMAT_COPY_
{
    explicit _CvMAT_COPY_( const CvMAT* a );
    operator CvMAT() const;
    CvMAT* a;
};


/* a.op(b), where op = mul, div, min, max ... */
struct  CV_EXPORTS _CvMAT_DOT_OP_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_DOT_OP_( const CvMAT* a, const CvMAT* b,
                             int op, double alpha = 1 );
    operator CvMAT() const;

    CvMAT a; /* keep the left operand copy */
    CvMAT* b;
    double alpha;
    int op;
};


/* A.inv()*B or A.pinv()*B */
struct  CV_EXPORTS _CvMAT_SOLVE_ : public _CvMAT_BASE_OP_
{
    explicit _CvMAT_SOLVE_( const CvMAT* a, const CvMAT* b, int method );
    operator CvMAT() const;

    CvMAT* a;
    CvMAT* b;
    int method;
};