git.maemo.org Git - opencv/blob - cvaux/include/cvmat.hpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                        Intel License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
  14 // Third party copyrights are property of their respective owners.
  15 //
  16 // Redistribution and use in source and binary forms, with or without modification,
  17 // are permitted provided that the following conditions are met:
  18 //
  19 //   * Redistribution's of source code must retain the above copyright notice,
  20 //     this list of conditions and the following disclaimer.
  21 //
  22 //   * Redistribution's in binary form must reproduce the above copyright notice,
  23 //     this list of conditions and the following disclaimer in the documentation
  24 //     and/or other materials provided with the distribution.
  25 //
  26 //   * The name of Intel Corporation may not be used to endorse or promote products
  27 //     derived from this software without specific prior written permission.
  28 //
  29 // This software is provided by the copyright holders and contributors "as is" and
  30 // any express or implied warranties, including, but not limited to, the implied
  31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  32 // In no event shall the Intel Corporation or contributors be liable for any direct,
  33 // indirect, incidental, special, exemplary, or consequential damages
  34 // (including, but not limited to, procurement of substitute goods or services;
  35 // loss of use, data, or profits; or business interruption) however caused
  36 // and on any theory of liability, whether in contract, strict liability,
  37 // or tort (including negligence or otherwise) arising in any way out of
  38 // the use of this software, even if advised of the possibility of such damage.
  39 //
  40 //M*/
  41
  42 #ifndef _CVMAT_HPP_
  43 #define _CVMAT_HPP_
  44
  45 #if 0 && (defined __cplusplus && (_MSC_VER>=1200 || defined __BORLANDC__ || defined __GNUC__))
  46
  47 #if _MSC_VER >= 1200
  48 #pragma warning( disable: 4710 ) /* suppress "function ... is not inlined" */
  49 #endif
  50
  51 #include <string.h>
  52 #include <stdio.h>
  53
  54 #undef min
  55 #undef max
  56
  57 /****************************************************************************************\
  58 *                            C++ - like operations on CvScalar                           *
  59 \****************************************************************************************/
  60
  61 inline CvScalar& operator += ( CvScalar& a, const CvScalar& b )
  62 {
  63     double t0 = a.val[0] + b.val[0];
  64     double t1 = a.val[1] + b.val[1];
  65     a.val[0] = t0;
  66     a.val[1] = t1;
  67
  68     t0 = a.val[2] + b.val[2];
  69     t1 = a.val[3] + b.val[3];
  70     a.val[2] = t0;
  71     a.val[3] = t1;
  72
  73     return a;
  74 }
  75
  76
  77 inline CvScalar& operator -= ( CvScalar& a, const CvScalar& b )
  78 {
  79     double t0 = a.val[0] - b.val[0];
  80     double t1 = a.val[1] - b.val[1];
  81     a.val[0] = t0;
  82     a.val[1] = t1;
  83
  84     t0 = a.val[2] - b.val[2];
  85     t1 = a.val[3] - b.val[3];
  86     a.val[2] = t0;
  87     a.val[3] = t1;
  88
  89     return a;
  90 }
  91
  92
  93 inline CvScalar& operator *= ( CvScalar& a, double b )
  94 {
  95     double t0 = a.val[0] * b;
  96     double t1 = a.val[1] * b;
  97     a.val[0] = t0;
  98     a.val[1] = t1;
  99
 100     t0 = a.val[2] * b;
 101     t1 = a.val[3] * b;
 102     a.val[2] = t0;
 103     a.val[3] = t1;
 104
 105     return a;
 106 }
 107
 108
 109 inline CvScalar& operator /= ( CvScalar& a, double b )
 110 {
 111     double inv_b = 1./b;
 112     double t0 = a.val[0] * inv_b;
 113     double t1 = a.val[1] * inv_b;
 114     a.val[0] = t0;
 115     a.val[1] = t1;
 116
 117     t0 = a.val[2] * inv_b;
 118     t1 = a.val[3] * inv_b;
 119     a.val[2] = t0;
 120     a.val[3] = t1;
 121
 122     return a;
 123 }
 124
 125
 126 inline CvScalar& operator *= ( CvScalar& a, const CvScalar& b )
 127 {
 128     double t0 = a.val[0]*b.val[0] - a.val[1]*b.val[1] -
 129                 a.val[2]*b.val[2] - a.val[3]*b.val[3];
 130
 131     double t1 = a.val[0]*b.val[1] + a.val[1]*b.val[0] +
 132                 a.val[2]*b.val[3] - a.val[3]*b.val[2];
 133
 134     double t2 = a.val[0]*b.val[2] - a.val[1]*b.val[3] +
 135                 a.val[2]*b.val[0] + a.val[3]*b.val[1];
 136
 137     double t3 = a.val[0]*b.val[3] + a.val[1]*b.val[2] -
 138                 a.val[2]*b.val[1] + a.val[3]*b.val[0];
 139
 140     a.val[0] = t0;
 141     a.val[1] = t1;
 142     a.val[2] = t2;
 143     a.val[3] = t3;
 144
 145     return a;
 146 }
 147
 148
 149 inline CvScalar& operator /= ( CvScalar& a, const CvScalar& b )
 150 {
 151     double inv_d = -1./(b.val[0]*b.val[0] + b.val[1]*b.val[1] +
 152                         b.val[2]*b.val[2] + b.val[3]*b.val[3]);
 153     return a *= cvScalar( b.val[0] * -inv_d, b.val[1] * inv_d,
 154                           b.val[2] * inv_d, b.val[3] * inv_d );
 155 }
 156
 157
 158 inline CvScalar& operator += ( CvScalar& a, double b )
 159 {
 160     a.val[0] += b;
 161     return a;
 162 }
 163
 164
 165 inline CvScalar& operator -= ( CvScalar& a, double b )
 166 {
 167     a.val[0] -= b;
 168     return a;
 169 }
 170
 171
 172 inline CvScalar operator + ( const CvScalar& a, const CvScalar& b )
 173 {
 174     return cvScalar( a.val[0] + b.val[0], a.val[1] + b.val[1],
 175                      a.val[2] + b.val[2], a.val[3] + b.val[3] );
 176 }
 177
 178
 179 inline CvScalar operator - ( const CvScalar& a, const CvScalar& b )
 180 {
 181     return cvScalar( a.val[0] - b.val[0], a.val[1] - b.val[1],
 182                      a.val[2] - b.val[2], a.val[3] - b.val[3] );
 183 }
 184
 185
 186 inline CvScalar operator + ( const CvScalar& a, double b )
 187 {
 188     return cvScalar( a.val[0] + b, a.val[1], a.val[2], a.val[3] );
 189 }
 190
 191
 192 inline CvScalar operator - ( const CvScalar& a, double b )
 193 {
 194     return cvScalar( a.val[0] - b, a.val[1], a.val[2], a.val[3] );
 195 }
 196
 197
 198 inline CvScalar operator + ( double a, const CvScalar& b )
 199 {
 200     return cvScalar( a + b.val[0], b.val[1], b.val[2], b.val[3] );
 201 }
 202
 203
 204 inline CvScalar operator - ( double a, const CvScalar& b )
 205 {
 206     return cvScalar( a - b.val[0], -b.val[1], -b.val[2], -b.val[3] );
 207 }
 208
 209
 210 inline CvScalar operator - ( const CvScalar& b )
 211 {
 212     return cvScalar( -b.val[0], -b.val[1], -b.val[2], -b.val[3] );
 213 }
 214
 215
 216 inline CvScalar operator * ( const CvScalar& a, const CvScalar& b )
 217 {
 218     CvScalar c = a;
 219
 220     return (c *= b);
 221 }
 222
 223
 224 inline CvScalar operator * ( const CvScalar& a, double b )
 225 {
 226     return cvScalar( a.val[0]*b, a.val[1]*b, a.val[2]*b, a.val[3]*b );
 227 }
 228
 229
 230 inline CvScalar operator * ( double a, const CvScalar& b )
 231 {
 232     return cvScalar( b.val[0]*a, b.val[1]*a, b.val[2]*a, b.val[3]*a );
 233 }
 234
 235
 236 inline CvScalar operator / ( const CvScalar& a, const CvScalar& b )
 237 {
 238     CvScalar c = a;
 239     return (c /= b);
 240 }
 241
 242
 243 inline CvScalar operator / ( const CvScalar& a, double b )
 244 {
 245     double inv_b = 1./b;
 246     return cvScalar( a.val[0]*inv_b, a.val[1]*inv_b,
 247                      a.val[2]*inv_b, a.val[3]*inv_b );
 248 }
 249
 250
 251 inline CvScalar operator / ( double a, const CvScalar& b )
 252 {
 253     double inv_d = -a/(b.val[0]*b.val[0] + b.val[1]*b.val[1] +
 254                        b.val[2]*b.val[2] + b.val[3]*b.val[3]);
 255     return cvScalar( b.val[0] * -inv_d, b.val[1] * inv_d,
 256                      b.val[2] * inv_d, b.val[3] * inv_d );
 257 }
 258
 259
 260 inline CvScalar& operator &= ( CvScalar& a, const CvScalar& b )
 261 {
 262     int t0 = cvRound(a.val[0]) & cvRound(b.val[0]);
 263     int t1 = cvRound(a.val[1]) & cvRound(b.val[1]);
 264     a.val[0] = t0;
 265     a.val[1] = t1;
 266
 267     t0 = cvRound(a.val[2]) & cvRound(b.val[2]);
 268     t1 = cvRound(a.val[3]) & cvRound(b.val[3]);
 269     a.val[2] = t0;
 270     a.val[3] = t1;
 271
 272     return a;
 273 }
 274
 275
 276 inline CvScalar& operator |= ( CvScalar& a, const CvScalar& b )
 277 {
 278     int t0 = cvRound(a.val[0]) | cvRound(b.val[0]);
 279     int t1 = cvRound(a.val[1]) | cvRound(b.val[1]);
 280     a.val[0] = t0;
 281     a.val[1] = t1;
 282
 283     t0 = cvRound(a.val[2]) | cvRound(b.val[2]);
 284     t1 = cvRound(a.val[3]) | cvRound(b.val[3]);
 285     a.val[2] = t0;
 286     a.val[3] = t1;
 287
 288     return a;
 289 }
 290
 291
 292 inline CvScalar& operator ^= ( CvScalar& a, const CvScalar& b )
 293 {
 294     int t0 = cvRound(a.val[0]) ^ cvRound(b.val[0]);
 295     int t1 = cvRound(a.val[1]) ^ cvRound(b.val[1]);
 296     a.val[0] = t0;
 297     a.val[1] = t1;
 298
 299     t0 = cvRound(a.val[2]) ^ cvRound(b.val[2]);
 300     t1 = cvRound(a.val[3]) ^ cvRound(b.val[3]);
 301     a.val[2] = t0;
 302     a.val[3] = t1;
 303
 304     return a;
 305 }
 306
 307
 308 inline CvScalar operator & ( const CvScalar& a, const CvScalar& b )
 309 {
 310     CvScalar c = a;
 311     return (c &= b);
 312 }
 313
 314
 315 inline CvScalar operator | ( const CvScalar& a, const CvScalar& b )
 316 {
 317     CvScalar c = a;
 318     return (c |= b);
 319 }
 320
 321
 322 inline CvScalar operator ^ ( const CvScalar& a, const CvScalar& b )
 323 {
 324     CvScalar c = a;
 325     return (c ^= b);
 326 }
 327
 328
 329 inline CvScalar operator ~ ( const CvScalar& a )
 330 {
 331     return cvScalar( ~cvRound(a.val[0]), ~cvRound(a.val[1]),
 332                      ~cvRound(a.val[2]), ~cvRound(a.val[3]));
 333 }
 334
 335
 336 /****************************************************************************************\
 337 *                                   C++ Matrix Class                                     *
 338 \****************************************************************************************/
 339
 340 struct  _CvMATConstElem_;
 341 struct  _CvMATElem_;
 342 struct  _CvMATElemCn_;
 343
 344 struct  _CvMAT_T_;
 345 struct  _CvMAT_MUL_;
 346 struct  _CvMAT_INV_;
 347 struct  _CvMAT_SCALE_;
 348 struct  _CvMAT_SCALE_SHIFT_;
 349 struct  _CvMAT_ADD_;
 350 struct  _CvMAT_ADD_EX_;
 351 struct  _CvMAT_MUL_ADD_;
 352 struct  _CvMAT_LOGIC_;
 353 struct  _CvMAT_UN_LOGIC_;
 354 struct  _CvMAT_NOT_;
 355 struct  _CvMAT_CVT_;
 356 struct  _CvMAT_COPY_;
 357 struct  _CvMAT_DOT_OP_;
 358 struct  _CvMAT_SOLVE_;
 359 struct  _CvMAT_CMP_;
 360
 361 class CV_EXPORTS CvMAT : public CvMat
 362 {
 363 protected:
 364
 365 public:
 366     /* helper methods for retrieving/setting matrix elements */
 367     static double get( const uchar* ptr, int type, int coi = 0 );
 368     static void set( uchar* ptr, int type, int coi, double d );
 369     static void set( uchar* ptr, int type, int coi, int i );
 370     static void set( uchar* ptr, int type, double d );
 371     static void set( uchar* ptr, int type, int i );
 372
 373     /******************* constructors ********************/
 374     /* empty */
 375     explicit CvMAT();
 376
 377     /* creation */
 378     explicit CvMAT( int rows, int cols, int type, void* data, int step = CV_AUTOSTEP );
 379     explicit CvMAT( int rows, int type, void* data, int step = CV_AUTOSTEP );
 380     explicit CvMAT( int rows, int cols, int type );
 381     explicit CvMAT( int rows, int type );
 382
 383     /* extracting part of an existing matrix */
 384     explicit CvMAT( const CvMat& mat, CvRect rect ); /* submatrix */
 385     explicit CvMAT( const CvMat& mat, int k, int i ); /* submatrix:
 386                                                     k == 0 - i-th row
 387                                                     k > 0 - i-th column
 388                                                     k < 0 - i-th diagonal */
 389     /* copying */
 390     CvMAT( const CvMat& mat );
 391     CvMAT( const CvMAT& mat );
 392     CvMAT( const IplImage& img );
 393
 394     /* CvMAT b = op(a1,a2,...) */
 395     explicit CvMAT( const _CvMAT_T_& mat_t );
 396     explicit CvMAT( const _CvMAT_INV_& inv_mat );
 397     explicit CvMAT( const _CvMAT_ADD_& mat_add );
 398     explicit CvMAT( const _CvMAT_ADD_EX_& mat_add );
 399     explicit CvMAT( const _CvMAT_SCALE_& scale_mat );
 400     explicit CvMAT( const _CvMAT_SCALE_SHIFT_& scale_shift_mat );
 401     explicit CvMAT( const _CvMAT_MUL_& mmul );
 402     explicit CvMAT( const _CvMAT_MUL_ADD_& mmuladd );
 403     explicit CvMAT( const _CvMAT_LOGIC_& mat_logic );
 404     explicit CvMAT( const _CvMAT_UN_LOGIC_& mat_logic );
 405     explicit CvMAT( const _CvMAT_NOT_& not_mat );
 406     explicit CvMAT( const _CvMAT_COPY_& mat_copy );
 407     explicit CvMAT( const _CvMAT_CVT_& mat_copy );
 408     explicit CvMAT( const _CvMAT_DOT_OP_& dot_mul );
 409     explicit CvMAT( const _CvMAT_SOLVE_& solve_mat );
 410     explicit CvMAT( const _CvMAT_CMP_& cmp_mat );
 411
 412     /* desctructor */
 413     ~CvMAT();
 414
 415     /* copying and filling with a constant */
 416     CvMAT& operator = ( const CvMAT& mat );
 417     CvMAT& operator = ( const CvMat& mat );
 418     CvMAT& operator = ( const IplImage& img );
 419     CvMAT& operator = ( double fillval );
 420     CvMAT& operator = ( const CvScalar& fillval );
 421
 422     /* b = op(a1, a2,...) */
 423     CvMAT& operator = ( const _CvMAT_T_& mat_t );
 424     CvMAT& operator = ( const _CvMAT_INV_& inv_mat );
 425     CvMAT& operator = ( const _CvMAT_ADD_& mat_add );
 426     CvMAT& operator = ( const _CvMAT_ADD_EX_& mat_add );
 427     CvMAT& operator = ( const _CvMAT_SCALE_& scale_mat );
 428     CvMAT& operator = ( const _CvMAT_SCALE_SHIFT_& scale_shift_mat );
 429     CvMAT& operator = ( const _CvMAT_MUL_& mmul );
 430     CvMAT& operator = ( const _CvMAT_MUL_ADD_& mmuladd );
 431     CvMAT& operator = ( const _CvMAT_LOGIC_& mat_logic );
 432     CvMAT& operator = ( const _CvMAT_UN_LOGIC_& mat_logic );
 433     CvMAT& operator = ( const _CvMAT_NOT_& not_mat );
 434     CvMAT& operator = ( const _CvMAT_DOT_OP_& dot_mul );
 435     CvMAT& operator = ( const _CvMAT_SOLVE_& solve_mat );
 436     CvMAT& operator = ( const _CvMAT_CMP_& cmp_mat );
 437     CvMAT& operator = ( const _CvMAT_CVT_& mat_cvt );
 438
 439     /* copy matrix data, not only matrix header */
 440     CvMAT& operator = ( const _CvMAT_COPY_& mat_copy );
 441
 442     /* augmented assignments */
 443     CvMAT& operator += ( const CvMat& mat );
 444     CvMAT& operator += ( double val );
 445     CvMAT& operator += ( const CvScalar& val );
 446     CvMAT& operator += ( const _CvMAT_SCALE_& scale_mat );
 447     CvMAT& operator += ( const _CvMAT_SCALE_SHIFT_& scale_mat );
 448     CvMAT& operator += ( const _CvMAT_MUL_& mmul );
 449
 450     CvMAT& operator -= ( const CvMat& mat );
 451     CvMAT& operator -= ( double val );
 452     CvMAT& operator -= ( const CvScalar& val );
 453     CvMAT& operator -= ( const _CvMAT_SCALE_& scale_mat );
 454     CvMAT& operator -= ( const _CvMAT_SCALE_SHIFT_& scale_mat );
 455     CvMAT& operator -= ( const _CvMAT_MUL_& mmul );
 456
 457     CvMAT& operator *= ( const CvMat& mat );
 458     CvMAT& operator *= ( double val );
 459     CvMAT& operator *= ( const CvScalar& val );
 460     CvMAT& operator *= ( const _CvMAT_SCALE_& scale_mat );
 461     CvMAT& operator *= ( const _CvMAT_SCALE_SHIFT_& scale_mat );
 462
 463     CvMAT& operator &= ( const CvMat& mat );
 464     CvMAT& operator &= ( double val );
 465     CvMAT& operator &= ( const CvScalar& val );
 466
 467     CvMAT& operator |= ( const CvMat& mat );
 468     CvMAT& operator |= ( double val );
 469     CvMAT& operator |= ( const CvScalar& val );
 470
 471     CvMAT& operator ^= ( const CvMat& mat );
 472     CvMAT& operator ^= ( double val );
 473     CvMAT& operator ^= ( const CvScalar& val );
 474
 475     /* various scalar charactertics */
 476     double norm( int norm_type = CV_L2 ) const;
 477     double norm( CvMat& mat, int norm_type = CV_L2 ) const;
 478     CvScalar sum() const;
 479
 480     double det() const;
 481     double trace() const;
 482
 483     _CvMAT_T_  t() const; /* transposition */
 484     _CvMAT_INV_ inv(int method = 0) const;
 485     /* inversion using one of the following methods:
 486           method = 0 - Gaussian elimination,
 487           method = 1 - SVD */
 488
 489     _CvMAT_DOT_OP_  mul( const CvMAT& mat ) const;
 490     _CvMAT_DOT_OP_  mul( const _CvMAT_SCALE_& mat ) const;
 491
 492     _CvMAT_DOT_OP_  div( const CvMAT& mat ) const;
 493     _CvMAT_DOT_OP_  div( const _CvMAT_SCALE_& mat ) const;
 494
 495     _CvMAT_DOT_OP_  min( const CvMAT& mat ) const;
 496     _CvMAT_DOT_OP_  max( const CvMAT& mat ) const;
 497     _CvMAT_DOT_OP_  min( double value ) const;
 498     _CvMAT_DOT_OP_  max( double value ) const;
 499     double          min( CvPoint* minloc = 0 ) const;
 500     double          max( CvPoint* maxloc = 0 ) const;
 501
 502     _CvMAT_DOT_OP_  abs() const;
 503
 504     /* accessing matrix elements */
 505     _CvMATElem_ operator ()( int row );
 506     _CvMATConstElem_ operator ()( int row ) const;
 507
 508     _CvMATElem_ operator ()( int row, int col );
 509     _CvMATConstElem_ operator ()( int row, int col ) const;
 510
 511     _CvMATElem_ operator ()( CvPoint loc );
 512     _CvMATConstElem_ operator ()( CvPoint loc ) const;
 513
 514     _CvMATElemCn_ operator()( int row, int col, int coi );
 515     double operator()( int row, int col, int coi ) const;
 516
 517     _CvMATElemCn_ operator()( CvPoint pt, int coi );
 518     double operator()( CvPoint pt, int coi ) const;
 519
 520     void* ptr( int row );
 521     const void* ptr( int row ) const;
 522
 523     void* ptr( int row, int col );
 524     const void* ptr( int row, int col ) const;
 525
 526     void* ptr( CvPoint pt );
 527     const void* ptr( CvPoint pt ) const;
 528
 529     /* accessing matrix parts */
 530     CvMAT row( int row ) const;
 531     CvMAT rowrange( int row1, int row2 ) const;
 532     CvMAT col( int col ) const;
 533     CvMAT colrange( int col1, int col2 ) const;
 534     CvMAT rect( CvRect rect ) const;
 535     CvMAT diag( int diag = 0 ) const;
 536
 537     _CvMAT_COPY_ clone() const;
 538
 539     /* convert matrix */
 540     _CvMAT_CVT_ cvt( int newdepth = -1, double scale = 1,
 541                      double shift = 0 ) const;
 542
 543     /* matrix transformation */
 544     void  reshape( int newcn, int newrows = 0 );
 545     void  flipX();
 546     void  flipY();
 547     void  flipXY();
 548
 549     /* matrix I/O: use dynamically linked runtime libraries */
 550     void  write( const char* name = 0, FILE* f = 0, const char* fmt = 0 );
 551     void  read( char** name = 0, FILE* f = 0 );
 552
 553     /* decrease matrix data reference counter and clear data pointer */
 554     void  release();
 555 protected:
 556
 557     void  create( int rows, int cols, int type );
 558 };
 559
 560
 561 /* !!! Internal Use Only !!! */
 562 /* proxies for matrix elements */
 563
 564 /* const_A(i,j) */
 565 struct  CV_EXPORTS _CvMATConstElem_
 566 {
 567     explicit _CvMATConstElem_( const uchar* ptr, int type );
 568     operator CvScalar () const;
 569     double operator ()( int coi = 0 ) const;
 570
 571     uchar* ptr;
 572     int type;
 573 };
 574
 575
 576 /* A(i,j,cn) or A(i,j)(cn) */
 577 struct  CV_EXPORTS _CvMATElemCn_
 578 {
 579     explicit _CvMATElemCn_( uchar* ptr, int type, int coi );
 580     operator double() const;
 581
 582     _CvMATElemCn_& operator = ( const _CvMATConstElem_& elem );
 583     _CvMATElemCn_& operator = ( const _CvMATElemCn_& elem );
 584     _CvMATElemCn_& operator = ( const CvScalar& scalar );
 585     _CvMATElemCn_& operator = ( double d );
 586     _CvMATElemCn_& operator = ( float f );
 587     _CvMATElemCn_& operator = ( int i );
 588
 589     uchar* ptr;
 590     int type;
 591 };
 592
 593
 594 /* A(i,j) */
 595 struct  CV_EXPORTS _CvMATElem_ : public _CvMATConstElem_
 596 {
 597     explicit _CvMATElem_( uchar* ptr, int type );
 598     _CvMATElemCn_ operator ()( int coi = 0 );
 599
 600     _CvMATElem_& operator = ( const _CvMATConstElem_& elem );
 601     _CvMATElem_& operator = ( const _CvMATElem_& elem );
 602     _CvMATElem_& operator = ( const _CvMATElemCn_& elem );
 603     _CvMATElem_& operator = ( const CvScalar& val );
 604     _CvMATElem_& operator = ( double d );
 605     _CvMATElem_& operator = ( float f );
 606     _CvMATElem_& operator = ( int i );
 607 };
 608
 609
 610 struct  CV_EXPORTS _CvMAT_BASE_OP_
 611 {
 612     _CvMAT_BASE_OP_() {};
 613     virtual operator CvMAT() const = 0;
 614
 615     _CvMAT_DOT_OP_  mul( const CvMAT& a ) const;
 616     _CvMAT_DOT_OP_  mul( const _CvMAT_SCALE_& a ) const;
 617
 618     _CvMAT_DOT_OP_  div( const CvMAT& a ) const;
 619     _CvMAT_DOT_OP_  div( const _CvMAT_SCALE_& a ) const;
 620
 621     _CvMAT_DOT_OP_  max( const CvMAT& a ) const;
 622     _CvMAT_DOT_OP_  min( const CvMAT& a ) const;
 623
 624     _CvMAT_DOT_OP_  max( double value ) const;
 625     _CvMAT_DOT_OP_  min( double value ) const;
 626
 627     double          max( CvPoint* maxloc = 0 ) const;
 628     double          min( CvPoint* minloc = 0 ) const;
 629
 630     _CvMAT_DOT_OP_  abs() const;
 631
 632     _CvMAT_INV_     inv( int method = 0 ) const;
 633     _CvMAT_T_       t() const;
 634
 635     CvMAT     row( int row ) const;
 636     CvMAT     rowrange( int row1, int row2 ) const;
 637     CvMAT     col( int col ) const;
 638     CvMAT     colrange( int col1, int col2 ) const;
 639     CvMAT     rect( CvRect rect ) const;
 640     CvMAT     diag( int diag = 0 ) const;
 641     _CvMAT_CVT_     cvt( int newdepth = -1, double scale = 1, double shift = 0 ) const;
 642
 643     double          norm( int norm_type = CV_L2 ) const;
 644     double          det() const;
 645     double          trace() const;
 646     CvScalar        sum() const;
 647 };
 648
 649
 650 /* (A^t)*alpha */
 651 struct  CV_EXPORTS _CvMAT_T_ : public _CvMAT_BASE_OP_
 652 {
 653     explicit _CvMAT_T_( const CvMAT* a );
 654     explicit _CvMAT_T_( const CvMAT* a, double alpha );
 655
 656     double det() const;
 657     double norm( int normType = CV_L2 ) const;
 658     operator CvMAT() const;
 659
 660     CvMAT  a;
 661     double alpha;
 662 };
 663
 664
 665 /* inv(A) */
 666 struct  CV_EXPORTS _CvMAT_INV_ : public _CvMAT_BASE_OP_
 667 {
 668     explicit _CvMAT_INV_( const CvMAT* mat, int method );
 669     operator CvMAT() const;
 670
 671     CvMAT a;
 672     int method;
 673 };
 674
 675
 676 /* (A^ta)*(B^tb)*alpha */
 677 struct  CV_EXPORTS _CvMAT_MUL_ : public _CvMAT_BASE_OP_
 678 {
 679     explicit _CvMAT_MUL_( const CvMAT* a, const CvMAT* b, int t_ab );
 680     explicit _CvMAT_MUL_( const CvMAT* a, const CvMAT* b,
 681                           double alpha, int t_abc );
 682     operator CvMAT() const;
 683
 684     double alpha;
 685     CvMAT* a;
 686     CvMAT* b;
 687     int t_ab; /* (t_ab & 1) = ta, (t_ab & 2) = tb */
 688 };
 689
 690
 691 /* (A^ta)*(B^tb)*alpha + (C^tc)*beta */
 692 struct  CV_EXPORTS _CvMAT_MUL_ADD_ : public _CvMAT_BASE_OP_
 693 {
 694     explicit _CvMAT_MUL_ADD_( const CvMAT* a, const CvMAT* b,
 695                               const CvMAT* c, int t_abc );
 696     explicit _CvMAT_MUL_ADD_( const CvMAT* a, const CvMAT* b, double alpha,
 697                               const CvMAT* c, double beta, int t_abc );
 698     operator CvMAT() const;
 699
 700     double alpha, beta;
 701     CvMAT* a;
 702     CvMAT* b;
 703     CvMAT* c;
 704     int t_abc; /* (t_abc & 1) = ta, (t_abc & 2) = tb, (t_abc & 4) = tc */
 705 };
 706
 707
 708 /* A + B*beta */
 709 struct  CV_EXPORTS _CvMAT_ADD_ : public _CvMAT_BASE_OP_
 710 {
 711     explicit _CvMAT_ADD_( const CvMAT* a, const CvMAT* b, double beta = 1 );
 712     operator CvMAT() const;
 713
 714     double   norm( int norm_type = CV_L2 ) const;
 715     _CvMAT_DOT_OP_ abs() const;
 716
 717     double beta;
 718     CvMAT* a;
 719     CvMAT* b;
 720 };
 721
 722
 723 /* A*alpha + B*beta + gamma */
 724 struct  CV_EXPORTS _CvMAT_ADD_EX_ : public _CvMAT_BASE_OP_
 725 {
 726     explicit _CvMAT_ADD_EX_( const CvMAT* a, double alpha,
 727                              const CvMAT* b, double beta, double gamma = 0 );
 728     operator CvMAT() const;
 729
 730     double alpha, beta, gamma;
 731     CvMAT* a;
 732     CvMAT* b;
 733 };
 734
 735
 736 /* A*alpha */
 737 struct  CV_EXPORTS _CvMAT_SCALE_ : public _CvMAT_BASE_OP_
 738 {
 739     explicit _CvMAT_SCALE_( const CvMAT* a, double alpha );
 740     operator CvMAT() const;
 741
 742     _CvMAT_DOT_OP_  mul( const CvMAT& a ) const;
 743     _CvMAT_DOT_OP_  mul( const _CvMAT_SCALE_& a ) const;
 744
 745     _CvMAT_DOT_OP_  div( const CvMAT& a ) const;
 746     _CvMAT_DOT_OP_  div( const _CvMAT_SCALE_& a ) const;
 747
 748     double alpha;
 749     CvMAT* a;
 750 };
 751
 752
 753 /* A*alpha + beta */
 754 struct  CV_EXPORTS _CvMAT_SCALE_SHIFT_ : public _CvMAT_BASE_OP_
 755 {
 756     explicit _CvMAT_SCALE_SHIFT_( const CvMAT* a, double alpha, double beta );
 757     operator CvMAT() const;
 758
 759     _CvMAT_DOT_OP_  abs() const;
 760
 761     double alpha, beta;
 762     CvMAT* a;
 763 };
 764
 765
 766 /* (A & B), (A | B) or (A ^ B) */
 767 struct  CV_EXPORTS _CvMAT_LOGIC_ : public _CvMAT_BASE_OP_
 768 {
 769     enum Op { AND = 0, OR = 1, XOR = 2 };
 770     explicit _CvMAT_LOGIC_( const CvMAT* a, const CvMAT* b, Op op, int flags = 0 );
 771     operator CvMAT() const;
 772
 773     CvMAT* a;
 774     CvMAT* b;
 775     Op op;
 776     int flags;
 777 };
 778
 779
 780 /* (A & scalar), (A | scalar) or (A ^ scalar) */
 781 struct  CV_EXPORTS _CvMAT_UN_LOGIC_ : public _CvMAT_BASE_OP_
 782 {
 783     explicit _CvMAT_UN_LOGIC_( const CvMAT* a, double alpha,
 784                                _CvMAT_LOGIC_::Op op, int flags = 0 );
 785     operator CvMAT() const;
 786
 787     CvMAT* a;
 788     double alpha;
 789     _CvMAT_LOGIC_::Op op;
 790     int flags;
 791 };
 792
 793
 794 /* ~A */
 795 struct  CV_EXPORTS _CvMAT_NOT_ : public _CvMAT_BASE_OP_
 796 {
 797     explicit _CvMAT_NOT_( const CvMAT* a );
 798     operator CvMAT() const;
 799
 800     CvMAT* a;
 801 };
 802
 803
 804 /* conversion of data type */
 805 struct  CV_EXPORTS _CvMAT_CVT_ : public _CvMAT_BASE_OP_
 806 {
 807     explicit _CvMAT_CVT_( const CvMAT* a, int newdepth = -1,
 808                           double scale = 1, double shift = 0 );
 809     operator CvMAT() const;
 810
 811     CvMAT a;
 812     int newdepth;
 813     double scale, shift;
 814 };
 815
 816
 817 /* conversion of data type */
 818 struct  CV_EXPORTS _CvMAT_COPY_
 819 {
 820     explicit _CvMAT_COPY_( const CvMAT* a );
 821     operator CvMAT() const;
 822     CvMAT* a;
 823 };
 824
 825
 826 /* a.op(b), where op = mul, div, min, max ... */
 827 struct  CV_EXPORTS _CvMAT_DOT_OP_ : public _CvMAT_BASE_OP_
 828 {
 829     explicit _CvMAT_DOT_OP_( const CvMAT* a, const CvMAT* b,
 830                              int op, double alpha = 1 );
 831     operator CvMAT() const;
 832
 833     CvMAT a; /* keep the left operand copy */
 834     CvMAT* b;
 835     double alpha;
 836     int op;
 837 };
 838
 839
 840 /* A.inv()*B or A.pinv()*B */
 841 struct  CV_EXPORTS _CvMAT_SOLVE_ : public _CvMAT_BASE_OP_
 842 {
 843     explicit _CvMAT_SOLVE_( const CvMAT* a, const CvMAT* b, int method );
 844     operator CvMAT() const;
 845
 846     CvMAT* a;
 847     CvMAT* b;
 848     int method;
 849 };
 850
 851
 852 /* A <=> B */
 853 struct  CV_EXPORTS _CvMAT_CMP_ : public _CvMAT_BASE_OP_
 854 {
 855     explicit _CvMAT_CMP_( const CvMAT* a, const CvMAT* b, int cmp_op );
 856     explicit _CvMAT_CMP_( const CvMAT* a, double alpha, int cmp_op );
 857     operator CvMAT() const;
 858
 859     CvMAT* a;
 860     CvMAT* b;
 861     double alpha;
 862     int cmp_op;
 863 };
 864
 865
 866 /************************* _CvMATConstElem_ inline methods ******************************/
 867
 868 inline _CvMATConstElem_::_CvMATConstElem_(const uchar* p, int t) : ptr((uchar*)p), type(t)
 869 {}
 870
 871
 872 inline _CvMATConstElem_::operator CvScalar() const
 873 {
 874     CvScalar scalar;
 875     cvRawDataToScalar( ptr, type, &scalar );
 876
 877     return scalar;
 878 }
 879
 880
 881 inline double _CvMATConstElem_::operator ()( int coi ) const
 882 {   return CvMAT::get( ptr, type, coi );    }
 883
 884
 885 inline _CvMATElemCn_::_CvMATElemCn_( uchar* p, int t, int coi ) :
 886     ptr(p), type(CV_MAT_DEPTH(t))
 887 {
 888     if( coi )
 889     {
 890         assert( (unsigned)coi < (unsigned)CV_MAT_CN(t) );
 891         ptr += coi * CV_ELEM_SIZE(type);
 892     }
 893 }
 894
 895
 896 inline _CvMATElemCn_::operator double() const
 897 {   return CvMAT::get( ptr, type ); }
 898
 899
 900 inline _CvMATElemCn_& _CvMATElemCn_::operator = ( const _CvMATConstElem_& elem )
 901 {
 902     if( type == elem.type )
 903         memcpy( ptr, elem.ptr, CV_ELEM_SIZE(type) );
 904     else
 905     {
 906         assert( CV_MAT_CN(elem.type) == 1 );
 907         CvMAT::set( ptr, type, 0, elem(0));
 908     }
 909
 910     return *this;
 911 }
 912
 913
 914 inline _CvMATElemCn_& _CvMATElemCn_::operator = ( const _CvMATElemCn_& elem )
 915 {
 916     if( type == elem.type )
 917         memcpy( ptr, elem.ptr, CV_ELEM_SIZE(type) );
 918     else
 919         CvMAT::set( ptr, type, 0, (double)elem );
 920     return *this;
 921 }
 922
 923
 924 inline _CvMATElemCn_& _CvMATElemCn_::operator = ( const CvScalar& scalar )
 925 {
 926     CvMAT::set( ptr, type, 0, scalar.val[0] );
 927     return *this;
 928 }
 929
 930
 931 inline _CvMATElemCn_& _CvMATElemCn_::operator = ( double d )
 932 {
 933     CvMAT::set( ptr, type, 0, d );
 934     return *this;
 935 }
 936
 937
 938 inline _CvMATElemCn_& _CvMATElemCn_::operator = ( float f )
 939 {
 940     CvMAT::set( ptr, type, 0, (double)f );
 941     return *this;
 942 }
 943
 944
 945 inline _CvMATElemCn_& _CvMATElemCn_::operator = ( int i )
 946 {
 947     CvMAT::set( ptr, type, 0, i );
 948     return *this;
 949 }
 950
 951
 952 inline _CvMATElem_::_CvMATElem_( uchar* p, int t ) : _CvMATConstElem_( (const uchar*)p, t )
 953 {}
 954
 955
 956 inline _CvMATElemCn_ _CvMATElem_::operator ()( int coi )
 957 {   return _CvMATElemCn_( ptr, type, coi ); }
 958
 959
 960 inline _CvMATElem_& _CvMATElem_::operator = ( const _CvMATConstElem_& elem )
 961 {
 962     if( type == elem.type )
 963         memcpy( ptr, elem.ptr, CV_ELEM_SIZE(type) );
 964     else
 965     {
 966         assert( CV_MAT_CN( type ^ elem.type ) == 0 );
 967         CvScalar sc = (CvScalar)elem;
 968         cvScalarToRawData( &sc, ptr, type, 0 );
 969     }
 970
 971     return *this;
 972 }
 973
 974
 975 inline _CvMATElem_& _CvMATElem_::operator = ( const _CvMATElem_& elem )
 976 {
 977     *this = (const _CvMATConstElem_&)elem;
 978     return *this;
 979 }
 980
 981
 982 inline _CvMATElem_& _CvMATElem_::operator = ( const _CvMATElemCn_& elem )
 983 {
 984     if( type == elem.type )
 985         memcpy( ptr, elem.ptr, CV_ELEM_SIZE(type) );
 986     else
 987         CvMAT::set( ptr, type, (double)elem );
 988
 989     return *this;
 990 }
 991
 992
 993 inline _CvMATElem_& _CvMATElem_::operator = ( const CvScalar& scalar )
 994 {
 995     cvScalarToRawData( &scalar, ptr, type, 0 );
 996     return *this;
 997 }
 998
 999
1000 inline _CvMATElem_& _CvMATElem_::operator = ( double d )
1001 {
1002     CvMAT::set( ptr, type, d );
1003     return *this;
1004 }
1005
1006
1007 inline _CvMATElem_& _CvMATElem_::operator = ( float f )
1008 {
1009     CvMAT::set( ptr, type, (double)f );
1010     return *this;
1011 }
1012
1013
1014 inline _CvMATElem_& _CvMATElem_::operator = ( int i )
1015 {
1016     CvMAT::set( ptr, type, i );
1017     return *this;
1018 }
1019
1020
1021 /********************************** CvMAT inline methods ********************************/
1022
1023 inline CvMAT::CvMAT()
1024 {
1025     memset( this, 0, sizeof(*this));
1026 }
1027
1028
1029 inline CvMAT::CvMAT( int rows, int cols, int type, void* data, int step )
1030 {
1031     cvInitMatHeader( this, rows, cols, type, data, step );
1032 }
1033
1034
1035 inline CvMAT::CvMAT( int rows, int type, void* data, int step )
1036 {
1037     cvInitMatHeader( this, rows, 1, type, data, step );
1038 }
1039
1040
1041 inline void CvMAT::create( int rows, int cols, int type )
1042 {
1043     int step = cols*CV_ELEM_SIZE(type), total_size = step*rows;
1044     this->rows = rows;
1045     this->cols = cols;
1046     this->step = rows == 1 ? 0 : step;
1047     this->type = CV_MAT_MAGIC_VAL | (type & CV_MAT_TYPE_MASK) | CV_MAT_CONT_FLAG;
1048     refcount = (int*)cvAlloc((size_t)total_size + 8);
1049     data.ptr = (uchar*)(((size_t)(refcount + 1) + 7) & -8);
1050     *refcount = 1;
1051 }
1052
1053
1054 inline CvMAT::CvMAT( int rows, int cols, int type )
1055 {
1056     create( rows, cols, type );
1057 }
1058
1059
1060 inline CvMAT::CvMAT( int rows, int type )
1061 {
1062     create( rows, 1, type );
1063 }
1064
1065
1066 inline CvMAT::CvMAT( const CvMat& mat )
1067 {
1068     memcpy( this, &mat, sizeof(mat));
1069     if( refcount )
1070         (*refcount)++;
1071 }
1072
1073
1074 inline CvMAT::CvMAT( const CvMAT& mat )
1075 {
1076     memcpy( this, &mat, sizeof(mat));
1077     if( refcount )
1078         (*refcount)++;
1079 }
1080
1081
1082 inline CvMAT::CvMAT( const IplImage& img )
1083 {
1084     cvGetMat( &img, this );
1085 }
1086
1087
1088 inline void CvMAT::release()
1089 {
1090     data.ptr = NULL;
1091     if( refcount != NULL && --*refcount == 0 )
1092         cvFree( (void**)&refcount );
1093     refcount = 0;
1094 }
1095
1096
1097 inline CvMAT::~CvMAT()
1098 {
1099     release();
1100 }
1101
1102
1103 inline CvMAT& CvMAT::operator = ( const CvMAT& mat )
1104 {
1105     if( this != &mat )
1106     {
1107         release();
1108         memcpy( this, &mat, sizeof(mat));
1109         if( refcount )
1110             (*refcount)++;
1111     }
1112     return *this;
1113 }
1114
1115
1116 inline CvMAT& CvMAT::operator = ( const CvMat& mat )
1117 {
1118     *this = (const CvMAT&)mat;
1119     return *this;
1120 }
1121
1122
1123 inline CvMAT& CvMAT::operator = ( const IplImage& img )
1124 {
1125     release();
1126     cvGetMat( &img, this );
1127
1128     return *this;
1129 }
1130
1131
1132 inline CvMAT& CvMAT::operator = ( double fillval )
1133 {
1134     cvFillImage( this, fillval );
1135     return *this;
1136 }
1137
1138
1139 inline CvMAT& CvMAT::operator = ( const CvScalar& fillval )
1140 {
1141     cvSet( this, fillval );
1142     return *this;
1143 }
1144
1145
1146 inline CvMAT& CvMAT::operator += ( const CvMat& mat )
1147 {
1148     cvAdd( this, &mat, this );
1149     return *this;
1150 }
1151
1152
1153 inline CvMAT& CvMAT::operator += ( double val )
1154 {
1155     cvAddS( this, cvScalar(val), this );
1156     return *this;
1157 }
1158
1159
1160 inline CvMAT& CvMAT::operator += ( const CvScalar& val )
1161 {
1162     cvAddS( this, val, this );
1163     return *this;
1164 }
1165
1166
1167 inline CvMAT& CvMAT::operator -= ( const CvMat& mat )
1168 {
1169     cvSub( this, &mat, this );
1170     return *this;
1171 }
1172
1173
1174 inline CvMAT& CvMAT::operator -= ( double val )
1175 {
1176     cvSubS( this, cvScalar(val), this );
1177     return *this;
1178 }
1179
1180
1181 inline CvMAT& CvMAT::operator -= ( const CvScalar& val )
1182 {
1183     cvSubS( this, val, this );
1184     return *this;
1185 }
1186
1187
1188 inline CvMAT& CvMAT::operator *= ( const CvMat& mat )
1189 {
1190     cvMul( this, &mat, this );
1191     return *this;
1192 }
1193
1194
1195 inline CvMAT& CvMAT::operator *= ( double val )
1196 {
1197     cvScale( this, this, val, 0 );
1198     return *this;
1199 }
1200
1201
1202 inline CvMAT& CvMAT::operator *= ( const CvScalar& val )
1203 {
1204     cvScaleAdd( this, val, 0, this );
1205     return *this;
1206 }
1207
1208
1209 inline CvMAT& CvMAT::operator &= ( const CvMat& mat )
1210 {
1211     cvAnd( this, &mat, this );
1212     return *this;
1213 }
1214
1215
1216 inline CvMAT& CvMAT::operator &= ( double val )
1217 {
1218     cvAndS( this, cvScalarAll(val), this );
1219     return *this;
1220 }
1221
1222
1223 inline CvMAT& CvMAT::operator &= ( const CvScalar& val )
1224 {
1225     cvAndS( this, val, this );
1226     return *this;
1227 }
1228
1229
1230 inline CvMAT& CvMAT::operator |= ( const CvMat& mat )
1231 {
1232     cvOr( this, &mat, this );
1233     return *this;
1234 }
1235
1236
1237 inline CvMAT& CvMAT::operator |= ( double val )
1238 {
1239     cvOrS( this, cvScalarAll(val), this );
1240     return *this;
1241 }
1242
1243
1244 inline CvMAT& CvMAT::operator |= ( const CvScalar& val )
1245 {
1246     cvOrS( this, val, this );
1247     return *this;
1248 }
1249
1250
1251 inline CvMAT& CvMAT::operator ^= ( const CvMat& mat )
1252 {
1253     cvXor( this, &mat, this );
1254     return *this;
1255 }
1256
1257
1258 inline CvMAT& CvMAT::operator ^= ( double val )
1259 {
1260     cvXorS( this, cvScalarAll(val), this );
1261     return *this;
1262 }
1263
1264
1265 inline CvMAT& CvMAT::operator ^= ( const CvScalar& val )
1266 {
1267     cvXorS( this, val, this );
1268     return *this;
1269 }
1270
1271
1272 inline double CvMAT::norm( int normType ) const
1273 {   return cvNorm( this, 0, normType ); }
1274
1275
1276 inline double CvMAT::min( CvPoint* minloc ) const
1277 {
1278     double t;
1279     cvMinMaxLoc( this, &t, 0, minloc, 0, 0 );
1280     return t;
1281 }
1282
1283 inline double CvMAT::max( CvPoint* maxloc ) const
1284 {
1285     double t;
1286     cvMinMaxLoc( this, 0, &t, 0, maxloc, 0 );
1287     return t;
1288 }
1289
1290
1291 inline double CvMAT::norm( CvMat& mat, int normType ) const
1292 {   return cvNorm( this, &mat, normType );  }
1293
1294
1295 inline CvScalar CvMAT::sum() const
1296 {   return cvSum( this );   }
1297
1298
1299 inline double CvMAT::det() const
1300 {   return cvDet( this );   }
1301
1302
1303 inline void CvMAT::reshape( int newcn, int newrows )
1304 {   cvReshape( this, this, newcn, newrows );    }
1305
1306
1307 inline void CvMAT::flipX()
1308 {   cvFlip( this, this, 1 );    }
1309
1310
1311 inline void CvMAT::flipY()
1312 {   cvFlip( this, this, 0 );    }
1313
1314
1315 inline void CvMAT::flipXY()
1316 {   cvFlip( this, this, -1 );   }
1317
1318
1319 inline _CvMATElem_ CvMAT::operator ()( int row )
1320 {   return _CvMATElem_( CV_MAT_ELEM_PTR( *this, row, 0 ), type );   }
1321
1322
1323 inline _CvMATConstElem_ CvMAT::operator ()( int row ) const
1324 {   return _CvMATConstElem_( CV_MAT_ELEM_PTR( *this, row, 0 ), type ); }
1325
1326
1327 inline _CvMATElem_ CvMAT::operator ()( int row, int col )
1328 {   return _CvMATElem_( CV_MAT_ELEM_PTR( *this, row, col ), type ); }
1329
1330
1331 inline _CvMATConstElem_ CvMAT::operator ()( int row, int col ) const
1332 {   return _CvMATConstElem_( CV_MAT_ELEM_PTR( *this, row, col ), type ); }
1333
1334
1335 inline _CvMATElemCn_ CvMAT::operator()( int row, int col, int coi )
1336 {   return _CvMATElemCn_( CV_MAT_ELEM_PTR( *this, row, col ), type, coi );  }
1337
1338
1339 inline _CvMATElemCn_ CvMAT::operator()( CvPoint pt, int coi )
1340 {   return _CvMATElemCn_( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type, coi );  }
1341
1342
1343 inline double CvMAT::operator()( int row, int col, int coi ) const
1344 {   return get( CV_MAT_ELEM_PTR( *this, row, col ), type, coi );    }
1345
1346
1347 inline _CvMATElem_ CvMAT::operator ()( CvPoint pt )
1348 {   return _CvMATElem_( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type ); }
1349
1350
1351 inline _CvMATConstElem_ CvMAT::operator ()( CvPoint pt ) const
1352 {   return _CvMATConstElem_( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type ); }
1353
1354
1355 inline double CvMAT::operator()( CvPoint pt, int coi ) const
1356 {   return get( CV_MAT_ELEM_PTR( *this, pt.y, pt.x ), type, coi );    }
1357
1358
1359 inline void* CvMAT::ptr( int row )
1360 {   return CV_MAT_ELEM_PTR( *this, row, 0 );    }
1361
1362
1363 inline const void* CvMAT::ptr( int row ) const
1364 {   return (const void*)CV_MAT_ELEM_PTR( *this, row, 0 );   }
1365
1366
1367 inline void* CvMAT::ptr( int row, int col )
1368 {   return CV_MAT_ELEM_PTR( *this, row, col );  }
1369
1370
1371 inline const void* CvMAT::ptr( int row, int col ) const
1372 {   return (const void*)CV_MAT_ELEM_PTR( *this, row, col ); }
1373
1374
1375 inline void* CvMAT::ptr( CvPoint pt )
1376 {   return CV_MAT_ELEM_PTR( *this, pt.y, pt.x );    }
1377
1378
1379 inline const void* CvMAT::ptr( CvPoint pt ) const
1380 {   return (const void*)CV_MAT_ELEM_PTR( *this, pt.y, pt.x ); }
1381
1382
1383 inline _CvMAT_INV_ CvMAT::inv( int method ) const
1384 {   return _CvMAT_INV_( this, method ); }
1385
1386
1387 inline _CvMAT_T_ CvMAT::t() const
1388 {   return _CvMAT_T_( this );   }
1389
1390
1391 inline _CvMAT_COPY_ CvMAT::clone() const
1392 {   return _CvMAT_COPY_( this ); }
1393
1394 inline _CvMAT_CVT_ CvMAT::cvt( int newdepth, double scale, double shift ) const
1395 {   return _CvMAT_CVT_( this, newdepth, scale, shift ); }
1396
1397
1398 inline CvMAT::CvMAT( const CvMat& mat, CvRect rect )
1399 {
1400     type = 0;
1401     cvGetSubArr( &mat, this, rect );
1402     cvIncRefData( this );
1403 }
1404
1405
1406 /* submatrix:
1407      k == 0 - i-th row
1408      k > 0 - i-th column
1409      k < 0 - i-th diagonal */
1410 inline CvMAT::CvMAT( const CvMat& mat, int k, int i )
1411 {
1412     type = 0;
1413     if( k == 0 )
1414         cvGetRow( &mat, this, i );
1415     else if( k > 0 )
1416         cvGetCol( &mat, this, i );
1417     else
1418         cvGetDiag( &mat, this, i );
1419     cvIncRefData( this );
1420 }
1421
1422
1423 inline CvMAT CvMAT::row( int r ) const
1424 {   return CvMAT( *this, 0, r );  }
1425
1426
1427 inline CvMAT CvMAT::col( int c ) const
1428 {   return CvMAT( *this, 1, c );  }
1429
1430
1431 inline CvMAT CvMAT::diag( int d ) const
1432 {   return CvMAT( *this, -1, d );  }
1433
1434
1435 inline CvMAT CvMAT::rect( CvRect rect ) const
1436 {   return CvMAT( *this, rect );    }
1437
1438 inline CvMAT CvMAT::rowrange( int row1, int row2 ) const
1439 {
1440     assert( 0 <= row1 && row1 < row2 && row2 <= height );
1441     return CvMAT( *this, cvRect( 0, row1, width, row2 - row1 ));
1442 }
1443
1444 inline CvMAT CvMAT::colrange( int col1, int col2 ) const
1445 {
1446     assert( 0 <= col1 && col1 < col2 && col2 <= width );
1447     return CvMAT( *this, cvRect( col1, 0, col2 - col1, height ));
1448 }
1449
1450 inline _CvMAT_DOT_OP_ CvMAT::mul( const CvMAT& mat ) const
1451 {   return _CvMAT_DOT_OP_( this, &mat, '*' );   }
1452
1453 inline _CvMAT_DOT_OP_ CvMAT::mul( const _CvMAT_SCALE_& mat ) const
1454 {   return _CvMAT_DOT_OP_( this, mat.a, '*', mat.alpha );   }
1455
1456 inline _CvMAT_DOT_OP_ CvMAT::div( const CvMAT& mat ) const
1457 {   return _CvMAT_DOT_OP_( this, &mat, '/' );  }
1458
1459 inline _CvMAT_DOT_OP_ CvMAT::div( const _CvMAT_SCALE_& mat ) const
1460 {   return _CvMAT_DOT_OP_( this, mat.a, '/', 1./mat.alpha );    }
1461
1462 inline _CvMAT_DOT_OP_ CvMAT::min( const CvMAT& mat ) const
1463 {   return _CvMAT_DOT_OP_( this, &mat, 'm' );   }
1464
1465 inline _CvMAT_DOT_OP_ CvMAT::max( const CvMAT& mat ) const
1466 {   return _CvMAT_DOT_OP_( this, &mat, 'M' );   }
1467
1468 inline _CvMAT_DOT_OP_ CvMAT::min( double value ) const
1469 {   return _CvMAT_DOT_OP_( this, 0, 'm', value );   }
1470
1471 inline _CvMAT_DOT_OP_ CvMAT::max( double value ) const
1472 {   return _CvMAT_DOT_OP_( this, 0, 'M', value );   }
1473
1474 inline _CvMAT_DOT_OP_ CvMAT::abs() const
1475 {   return _CvMAT_DOT_OP_( this, 0, 'a', 0 );   }
1476
1477 /****************************************************************************************\
1478 *                               binary operations (+,-,*)                                *
1479 \****************************************************************************************/
1480
1481 /*
1482 * PART I. Scaling, shifting, addition/subtraction operations
1483 */
1484
1485 /* (mat2^t) = (mat1^t) * scalar */
1486 inline _CvMAT_T_ operator * ( const _CvMAT_T_& a, double alpha )
1487 {   return _CvMAT_T_( &a.a, a.alpha*alpha );  }
1488
1489 /* (mat2^t) = scalar * (mat1^t) */
1490 inline _CvMAT_T_ operator * ( double alpha, const _CvMAT_T_& a )
1491 {   return _CvMAT_T_( &a.a, a.alpha*alpha );  }
1492
1493 /* -(mat^t) */
1494 inline _CvMAT_T_ operator - ( const _CvMAT_T_& a )
1495 {   return _CvMAT_T_( &a.a, -a.alpha ); }
1496
1497 /* mat_scaled = mat * scalar */
1498 inline _CvMAT_SCALE_ operator * ( const CvMAT& a, double alpha )
1499 {   return _CvMAT_SCALE_( &a, alpha );  }
1500
1501 /* mat_scaled = scalar * mat */
1502 inline _CvMAT_SCALE_ operator * ( double alpha, const CvMAT& a )
1503 {   return _CvMAT_SCALE_( &a, alpha );  }
1504
1505 /* mat_scaled2 = mat_scaled1 * scalar */
1506 inline _CvMAT_SCALE_ operator * ( const _CvMAT_SCALE_& a, double alpha )
1507 {   return _CvMAT_SCALE_( a.a, a.alpha*alpha ); }
1508
1509 /* mat_scaled2 = scalar * mat_scaled1 */
1510 inline _CvMAT_SCALE_ operator * ( double alpha, const _CvMAT_SCALE_& a )
1511 {   return _CvMAT_SCALE_( a.a, a.alpha*alpha ); }
1512
1513 /* -mat_scaled */
1514 inline _CvMAT_SCALE_ operator - ( const _CvMAT_SCALE_& a )
1515 {   return _CvMAT_SCALE_( a.a, -a.alpha ); }
1516
1517
1518 /* mat_scaled_shifted = mat + scalar */
1519 inline _CvMAT_SCALE_SHIFT_ operator + ( const CvMAT& a, double beta )
1520 {   return _CvMAT_SCALE_SHIFT_( &a, 1, beta );  }
1521
1522 /* mat_scaled_shifted = scalar + mat */
1523 inline _CvMAT_SCALE_SHIFT_ operator + ( double beta, const CvMAT& a )
1524 {   return _CvMAT_SCALE_SHIFT_( &a, 1, beta );  }
1525
1526 /* mat_scaled_shifted = mat - scalar */
1527 inline _CvMAT_SCALE_SHIFT_ operator - ( const CvMAT& a, double beta )
1528 {   return _CvMAT_SCALE_SHIFT_( &a, 1, -beta ); }
1529
1530 /* mat_scaled_shifted = scalar - mat */
1531 inline _CvMAT_SCALE_SHIFT_ operator - ( double beta, const CvMAT& a )
1532 {   return _CvMAT_SCALE_SHIFT_( &a, -1, beta ); }
1533
1534 /* mat_scaled_shifted = mat_scaled + scalar */
1535 inline _CvMAT_SCALE_SHIFT_ operator + ( const _CvMAT_SCALE_& a, double beta )
1536 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, beta );   }
1537
1538 /* mat_scaled_shifted = scalar + mat_scaled */
1539 inline _CvMAT_SCALE_SHIFT_ operator + ( double beta, const _CvMAT_SCALE_& a )
1540 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, beta );   }
1541
1542 /* mat_scaled_shifted = mat_scaled - scalar */
1543 inline _CvMAT_SCALE_SHIFT_ operator - ( const _CvMAT_SCALE_& a, double beta )
1544 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, -beta );  }
1545
1546 /* mat_scaled_shifted = scalar - mat_scaled */
1547 inline _CvMAT_SCALE_SHIFT_ operator - ( double beta, const _CvMAT_SCALE_& a )
1548 {   return _CvMAT_SCALE_SHIFT_( a.a, -a.alpha, beta );  }
1549
1550 /* mat_scaled_shifted2 = mat_scaled_shifted1 + scalar */
1551 inline _CvMAT_SCALE_SHIFT_ operator + ( const _CvMAT_SCALE_SHIFT_& a, double beta )
1552 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, a.beta + beta );  }
1553
1554 /* mat_scaled_shifted2 = scalar + mat_scaled_shifted1 */
1555 inline _CvMAT_SCALE_SHIFT_ operator + ( double beta, const _CvMAT_SCALE_SHIFT_& a )
1556 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, a.beta + beta );  }
1557
1558 /* mat_scaled_shifted2 = mat_scaled_shifted1 - scalar */
1559 inline _CvMAT_SCALE_SHIFT_ operator - ( const _CvMAT_SCALE_SHIFT_& a, double beta )
1560 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha, a.beta - beta );  }
1561
1562 /* mat_scaled_shifted2 = scalar - mat_scaled_shifted1 */
1563 inline _CvMAT_SCALE_SHIFT_ operator - ( double beta, const _CvMAT_SCALE_SHIFT_& a )
1564 {   return _CvMAT_SCALE_SHIFT_( a.a, -a.alpha, beta - a.beta ); }
1565
1566 /* mat_scaled_shifted2 = mat_scaled_shifted1 * scalar */
1567 inline _CvMAT_SCALE_SHIFT_ operator * ( const _CvMAT_SCALE_SHIFT_& a, double alpha )
1568 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha*alpha, a.beta*alpha ); }
1569
1570 /* mat_scaled_shifted2 = scalar * mat_scaled_shifted1 */
1571 inline _CvMAT_SCALE_SHIFT_ operator * ( double alpha, const _CvMAT_SCALE_SHIFT_& a )
1572 {   return _CvMAT_SCALE_SHIFT_( a.a, a.alpha*alpha, a.beta*alpha ); }
1573
1574 /* -mat_scaled_shifted */
1575 inline _CvMAT_SCALE_SHIFT_ operator - ( const _CvMAT_SCALE_SHIFT_& a )
1576 {   return _CvMAT_SCALE_SHIFT_( a.a, -a.alpha, -a.beta ); }
1577
1578
1579 /* -mat1 */
1580 inline _CvMAT_SCALE_ operator - ( const CvMAT& a )
1581 {   return _CvMAT_SCALE_( &a, -1 );   }
1582
1583 /* mat_add = mat1 + mat2 */
1584 inline _CvMAT_ADD_ operator + ( const CvMAT& a, const CvMAT& b )
1585 {   return _CvMAT_ADD_( &a, &b );   }
1586
1587 /* mat_add = mat1 - mat2 */
1588 inline _CvMAT_ADD_ operator - ( const CvMAT& a, const CvMAT& b )
1589 {   return _CvMAT_ADD_( &a, &b, -1 );    }
1590
1591 /* mat_add = mat_scaled1 + mat2 */
1592 inline _CvMAT_ADD_ operator + ( const _CvMAT_SCALE_& a, const CvMAT& b )
1593 {   return _CvMAT_ADD_( &b, a.a, a.alpha );  }
1594
1595 /* mat_add = mat1 + mat_scaled2 */
1596 inline _CvMAT_ADD_ operator + ( const CvMAT& b, const _CvMAT_SCALE_& a )
1597 {   return _CvMAT_ADD_( &b, a.a, a.alpha );  }
1598
1599 /* -mat_add */
1600 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_& a )
1601 {   return _CvMAT_ADD_EX_( a.a, -1, a.b, -a.beta ); }
1602
1603 /* mat_add = mat_scaled1 - mat2 */
1604 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_& a, const CvMAT& b )
1605 {   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, -1 ); }
1606
1607 /* mat_add = mat1 - mat_scaled2 */
1608 inline _CvMAT_ADD_ operator - ( const CvMAT& b, const _CvMAT_SCALE_& a )
1609 {   return _CvMAT_ADD_( &b, a.a, -a.alpha ); }
1610
1611 /* mat_add = mat_scaled_shifted1 + mat2 */
1612 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_SHIFT_& a, const CvMAT& b )
1613 {   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, 1, a.beta ); }
1614
1615 /* mat_add = mat1 + mat_scaled_shifted2 */
1616 inline _CvMAT_ADD_EX_ operator + ( const CvMAT& b, const _CvMAT_SCALE_SHIFT_& a )
1617 {   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, 1, a.beta ); }
1618
1619 /* mat_add = mat_scaled_shifted1 - mat2 */
1620 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_SHIFT_& a, const CvMAT& b )
1621 {   return _CvMAT_ADD_EX_( a.a, a.alpha, &b, -1, a.beta ); }
1622
1623 /* mat_add = mat1 - mat_scaled_shifted2 */
1624 inline _CvMAT_ADD_EX_ operator - ( const CvMAT& b, const _CvMAT_SCALE_SHIFT_& a )
1625 {   return _CvMAT_ADD_EX_( a.a, -a.alpha, &b, 1, -a.beta ); }
1626
1627 /* mat_add = mat_scaled_shifted1 + mat_scaled2 */
1628 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_SHIFT_& a, const _CvMAT_SCALE_& b )
1629 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha, a.beta ); }
1630
1631 /* mat_add = mat_scaled1 + mat_scaled_shifted2 */
1632 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_& b, const _CvMAT_SCALE_SHIFT_& a )
1633 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha, a.beta ); }
1634
1635 /* mat_add = mat_scaled_shifted1 - mat_scaled2 */
1636 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_SHIFT_& a, const _CvMAT_SCALE_& b )
1637 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, -b.alpha, a.beta ); }
1638
1639 /* mat_add = mat_scaled1 - mat_scaled_shifted2 */
1640 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_& b, const _CvMAT_SCALE_SHIFT_& a )
1641 {   return _CvMAT_ADD_EX_( a.a, -a.alpha, b.a, b.alpha, -a.beta ); }
1642
1643 /* mat_add = mat_scaled1 + mat_scaled2 */
1644 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_& a, const _CvMAT_SCALE_& b )
1645 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha ); }
1646
1647 /* mat_add = mat_scaled1 - mat_scaled2 */
1648 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_& a, const _CvMAT_SCALE_& b )
1649 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, -b.alpha ); }
1650
1651 /* mat_add = mat_scaled_shifted1 + mat_scaled_shifted2 */
1652 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_SCALE_SHIFT_& a,
1653                                 const _CvMAT_SCALE_SHIFT_& b )
1654 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, b.alpha, a.beta + b.beta ); }
1655
1656 /* mat_add = mat_scaled_shifted1 - mat_scaled_shifted2 */
1657 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_SCALE_SHIFT_& a,
1658                                 const _CvMAT_SCALE_SHIFT_& b )
1659 {   return _CvMAT_ADD_EX_( a.a, a.alpha, b.a, -b.alpha, a.beta - b.beta ); }
1660
1661 /* mat_add2 = mat_add1 + scalar */
1662 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_ADD_EX_& a, double gamma )
1663 {   return _CvMAT_ADD_EX_( a.a, a.alpha, a.b, a.beta, a.gamma + gamma ); }
1664
1665 /* mat_add2 = scalar + mat_add1 */
1666 inline _CvMAT_ADD_EX_ operator + ( double gamma, const _CvMAT_ADD_EX_& a )
1667 {   return _CvMAT_ADD_EX_( a.a, a.alpha, a.b, a.beta, a.gamma + gamma ); }
1668
1669 /* mat_add2 = mat_add1 - scalar */
1670 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_EX_& a, double gamma )
1671 {   return _CvMAT_ADD_EX_( a.a, a.alpha, a.b, a.beta, a.gamma - gamma ); }
1672
1673 /* mat_add2 = scalar - mat_add1 */
1674 inline _CvMAT_ADD_EX_ operator - ( double gamma, const _CvMAT_ADD_EX_& a )
1675 {   return _CvMAT_ADD_EX_( a.a, -a.alpha, a.b, -a.beta, gamma - a.gamma ); }
1676
1677 /* mat_add2 = mat_add1 * scalar */
1678 inline _CvMAT_ADD_EX_ operator * ( const _CvMAT_ADD_EX_& a, double alpha )
1679 {   return _CvMAT_ADD_EX_( a.a, a.alpha*alpha, a.b, a.beta*alpha, a.gamma*alpha ); }
1680
1681 /* mat_add2 = scalar * mat_add1 */
1682 inline _CvMAT_ADD_EX_ operator * ( double alpha, const _CvMAT_ADD_EX_& a )
1683 {   return _CvMAT_ADD_EX_( a.a, a.alpha*alpha, a.b, a.beta*alpha, a.gamma*alpha ); }
1684
1685 /* mat_add2 = mat_add1 + scalar */
1686 inline _CvMAT_ADD_EX_ operator + ( const _CvMAT_ADD_& a, double gamma )
1687 {   return _CvMAT_ADD_EX_( a.a, 1, a.b, a.beta, gamma ); }
1688
1689 /* mat_add2 = scalar + mat_add1 */
1690 inline _CvMAT_ADD_EX_ operator + ( double gamma, const _CvMAT_ADD_& a )
1691 {   return _CvMAT_ADD_EX_( a.a, 1, a.b, a.beta, gamma ); }
1692
1693 /* mat_add2 = mat_add1 - scalar */
1694 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_& a, double gamma )
1695 {   return _CvMAT_ADD_EX_( a.a, 1, a.b, a.beta, -gamma ); }
1696
1697 /* mat_add2 = scalar - mat_add1 */
1698 inline _CvMAT_ADD_EX_ operator - ( double gamma, const _CvMAT_ADD_& a )
1699 {   return _CvMAT_ADD_EX_( a.a, -1, a.b, -a.beta, gamma ); }
1700
1701 /* mat_add2 = mat_add1 * scalar */
1702 inline _CvMAT_ADD_EX_ operator * ( const _CvMAT_ADD_& a, double alpha )
1703 {   return _CvMAT_ADD_EX_( a.a, alpha, a.b, a.beta*alpha, 0 ); }
1704
1705 /* mat_add2 = scalar * mat_add1 */
1706 inline _CvMAT_ADD_EX_ operator * ( double alpha, const _CvMAT_ADD_& a )
1707 {   return _CvMAT_ADD_EX_( a.a, alpha, a.b, a.beta*alpha, 0 ); }
1708
1709 /* -mat_add_ex */
1710 inline _CvMAT_ADD_EX_ operator - ( const _CvMAT_ADD_EX_& a )
1711 {   return _CvMAT_ADD_EX_( a.a, -a.alpha, a.b, -a.beta, -a.gamma ); }
1712
1713
1714 /*
1715 * PART II. Matrix multiplication.
1716 */
1717
1718 /* mmul = mat1 * mat2 */
1719 inline _CvMAT_MUL_ operator * ( const CvMAT& a, const CvMAT& b )
1720 {   return _CvMAT_MUL_( &a, &b, 0 );    }
1721
1722 /* mmul = (mat1^t) * mat2 */
1723 inline _CvMAT_MUL_ operator * ( const _CvMAT_T_& a, const CvMAT& b )
1724 {   return _CvMAT_MUL_( &a.a, &b, a.alpha, 1 );   }
1725
1726 /* mmul = mat1 * (mat2^t) */
1727 inline _CvMAT_MUL_ operator * ( const CvMAT& b, const _CvMAT_T_& a )
1728 {   return _CvMAT_MUL_( &b, &a.a, a.alpha, 2 );  }
1729
1730 /* mmul = (mat1^t) * (mat2^t) */
1731 inline _CvMAT_MUL_ operator * ( const _CvMAT_T_& a, const _CvMAT_T_& b )
1732 {   return _CvMAT_MUL_( &a.a, &b.a, a.alpha*b.alpha, 3 );  }
1733
1734 /* mmul = mat_scaled1 * mat2 */
1735 inline _CvMAT_MUL_ operator * ( const _CvMAT_SCALE_& a, const CvMAT& b )
1736 {   return _CvMAT_MUL_( a.a, &b, a.alpha, 0 ); }
1737
1738 /* mmul = mat1 * mat_scaled2 */
1739 inline _CvMAT_MUL_ operator * ( const CvMAT& b, const _CvMAT_SCALE_& a )
1740 {   return _CvMAT_MUL_( &b, a.a, a.alpha, 0 ); }
1741
1742 /* mmul = (mat1^t) * mat_scaled1 */
1743 inline _CvMAT_MUL_ operator * ( const _CvMAT_T_& a, const _CvMAT_SCALE_& b )
1744 {   return _CvMAT_MUL_( &a.a, b.a, a.alpha*b.alpha, 1 ); }
1745
1746 /* mmul = mat_scaled1 * (mat2^t) */
1747 inline _CvMAT_MUL_ operator * ( const _CvMAT_SCALE_& b, const _CvMAT_T_& a )
1748 {   return _CvMAT_MUL_( b.a, &a.a, a.alpha*b.alpha, 2 ); }
1749
1750 /* mmul = mat_scaled1 * mat_scaled2 */
1751 inline _CvMAT_MUL_ operator * ( const _CvMAT_SCALE_& a, const _CvMAT_SCALE_& b )
1752 {   return _CvMAT_MUL_( a.a, b.a, a.alpha*b.alpha, 0 ); }
1753
1754 /* mmul2 = mmul1 * scalar */
1755 inline _CvMAT_MUL_ operator * ( const _CvMAT_MUL_& a, double alpha )
1756 {   return _CvMAT_MUL_( a.a, a.b, a.alpha*alpha, a.t_ab ); }
1757
1758 /* mmul2 = scalar * mmul1 */
1759 inline _CvMAT_MUL_ operator * ( double alpha, const _CvMAT_MUL_& a )
1760 {   return _CvMAT_MUL_( a.a, a.b, a.alpha*alpha, a.t_ab ); }
1761
1762 /* -mmul */
1763 inline _CvMAT_MUL_ operator - ( const _CvMAT_MUL_& a )
1764 {   return _CvMAT_MUL_( a.a, a.b, -a.alpha, a.t_ab ); }
1765
1766 /* mmuladd = mmul + mat */
1767 inline _CvMAT_MUL_ADD_ operator + ( const _CvMAT_MUL_& a, const CvMAT& b )
1768 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, &b, 1, a.t_ab ); }
1769
1770 /* !!! Comment this off because of ambigous conversion error !!!
1771    mmuladd = mat + mmul */
1772 /* inline _CvMAT_MUL_ADD_ operator + ( const CvMAT& b, const _CvMAT_MUL_& a )
1773 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, &b, 1, a.t_ab ); }*/
1774
1775 /* mmuladd = mmul - mat */
1776 inline _CvMAT_MUL_ADD_ operator - ( const _CvMAT_MUL_& a, const CvMAT& b )
1777 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, &b, -1, a.t_ab ); }
1778
1779 /* !!! Comment this off because of ambigous conversion error !!!
1780    mmuladd = mat - mmul */
1781 /*inline _CvMAT_MUL_ADD_ operator - ( const CvMAT& b, const _CvMAT_MUL_& a )
1782 {   return _CvMAT_MUL_ADD_( a.a, a.b, -a.alpha, &b, 1, a.t_ab ); }*/
1783
1784 /* mmuladd = mmul + mat_scaled */
1785 inline _CvMAT_MUL_ADD_ operator + ( const _CvMAT_MUL_& a, const _CvMAT_SCALE_& b )
1786 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, b.a, b.alpha, a.t_ab ); }
1787
1788 /* mmuladd = mat_scaled + mmul */
1789 inline _CvMAT_MUL_ADD_ operator + ( const _CvMAT_SCALE_& b, const _CvMAT_MUL_& a )
1790 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, b.a, b.alpha, a.t_ab ); }
1791
1792 /* mmuladd = mmul - mat_scaled */
1793 inline _CvMAT_MUL_ADD_ operator - ( const _CvMAT_MUL_& a, const _CvMAT_SCALE_& b )
1794 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, b.a, -b.alpha, a.t_ab ); }
1795
1796 /* mmuladd = mat_scaled - mmul */
1797 inline _CvMAT_MUL_ADD_ operator - ( const _CvMAT_SCALE_& b, const _CvMAT_MUL_& a )
1798 {   return _CvMAT_MUL_ADD_( a.a, a.b, -a.alpha, b.a, b.alpha, a.t_ab ); }
1799
1800 /* mmuladd = mmul + (mat^t) */
1801 inline _CvMAT_MUL_ADD_ operator + ( const _CvMAT_MUL_& a, const _CvMAT_T_& b )
1802 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, &b.a, b.alpha, a.t_ab + 4 );  }
1803
1804 /* mmuladd = (mat^t) + mmul */
1805 inline _CvMAT_MUL_ADD_ operator + ( const _CvMAT_T_& b, const _CvMAT_MUL_& a )
1806 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, &b.a, b.alpha, a.t_ab + 4 );  }
1807
1808 /* mmuladd = mmul - (mat^t) */
1809 inline _CvMAT_MUL_ADD_ operator - ( const _CvMAT_MUL_& a, const _CvMAT_T_& b )
1810 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha, &b.a, -b.alpha, a.t_ab + 4 );  }
1811
1812 /* mmuladd = (mat^t) - mmul */
1813 inline _CvMAT_MUL_ADD_ operator - ( const _CvMAT_T_& b, const _CvMAT_MUL_& a )
1814 {   return _CvMAT_MUL_ADD_( a.a, a.b, -a.alpha, &b.a, b.alpha, a.t_ab + 4 );  }
1815
1816
1817 /* mmuladd = mat_scaled_shifted * mat */
1818 inline _CvMAT_MUL_ADD_ operator * ( const _CvMAT_SCALE_SHIFT_& a, const CvMAT& b )
1819 {   return _CvMAT_MUL_ADD_( a.a, &b, a.alpha, &b, a.beta, 0 );  }
1820
1821 /* mmuladd = mat * mat_scaled_shifted */
1822 inline _CvMAT_MUL_ADD_ operator * ( const CvMAT& b, const _CvMAT_SCALE_SHIFT_& a )
1823 {   return _CvMAT_MUL_ADD_( &b, a.a, a.alpha, &b, a.beta, 0 );  }
1824
1825 /* mmuladd = mat_scaled_shifted * mat_scaled */
1826 inline _CvMAT_MUL_ADD_ operator * ( const _CvMAT_SCALE_SHIFT_& a, const _CvMAT_SCALE_& b )
1827 {   return _CvMAT_MUL_ADD_( a.a, b.a, a.alpha*b.alpha, b.a, a.beta*b.alpha, 0 );  }
1828
1829 /* mmuladd = mat_scaled * mat_scaled_shifted */
1830 inline _CvMAT_MUL_ADD_ operator * ( const _CvMAT_SCALE_& b, const _CvMAT_SCALE_SHIFT_& a )
1831 {   return _CvMAT_MUL_ADD_( b.a, a.a, a.alpha*b.alpha, b.a, a.beta*b.alpha, 0 );  }
1832
1833 /* mmuladd = mat_scaled_shifted * (mat^t) */
1834 inline _CvMAT_MUL_ADD_ operator * ( const _CvMAT_SCALE_SHIFT_& a, const _CvMAT_T_& b )
1835 {   return _CvMAT_MUL_ADD_( a.a, &b.a, a.alpha*b.alpha, &b.a, a.beta*b.alpha, 6 );  }
1836
1837 /* mmuladd = (mat^t) * mat_scaled_shifted */
1838 inline _CvMAT_MUL_ADD_ operator * ( const _CvMAT_T_& b, const _CvMAT_SCALE_SHIFT_& a )
1839 {   return _CvMAT_MUL_ADD_( &b.a, a.a, a.alpha*b.alpha, &b.a, a.beta*b.alpha, 5 );  }
1840
1841 /* mmuladd2 = mmuladd1 * scalar */
1842 inline _CvMAT_MUL_ADD_ operator * ( const _CvMAT_MUL_ADD_& a, double alpha )
1843 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha*alpha, a.c, a.beta*alpha, a.t_abc ); }
1844
1845 /* mmuladd2 = scalar * mmuladd1 */
1846 inline _CvMAT_MUL_ADD_ operator * ( double alpha, const _CvMAT_MUL_ADD_& a )
1847 {   return _CvMAT_MUL_ADD_( a.a, a.b, a.alpha*alpha, a.c, a.beta*alpha, a.t_abc ); }
1848
1849 /* -mmuladd */
1850 inline _CvMAT_MUL_ADD_ operator - ( const _CvMAT_MUL_ADD_& a )
1851 {   return _CvMAT_MUL_ADD_( a.a, a.b, -a.alpha, a.c, -a.beta, a.t_abc ); }
1852
1853 /* inv(a)*b, i.e. solve a*x = b */
1854 inline _CvMAT_SOLVE_ operator * ( const _CvMAT_INV_& a, const CvMAT& b )
1855 {   return _CvMAT_SOLVE_( &a.a, &b, a.method );    }
1856
1857
1858 /*
1859 * PART III. Logical operations
1860 */
1861 inline _CvMAT_NOT_ operator ~ ( const CvMAT& a )
1862 {   return _CvMAT_NOT_(&a); }
1863
1864 inline _CvMAT_LOGIC_ operator & ( const CvMAT& a, const CvMAT& b )
1865 {   return _CvMAT_LOGIC_( &a, &b, _CvMAT_LOGIC_::AND, 0 ); }
1866
1867 inline _CvMAT_LOGIC_ operator & ( const _CvMAT_NOT_& a, const CvMAT& b )
1868 {   return _CvMAT_LOGIC_( a.a, &b, _CvMAT_LOGIC_::AND, 1 ); }
1869
1870 inline _CvMAT_LOGIC_ operator & ( const CvMAT& a, const _CvMAT_NOT_& b )
1871 {   return _CvMAT_LOGIC_( &a, b.a, _CvMAT_LOGIC_::AND, 2 ); }
1872
1873 inline _CvMAT_LOGIC_ operator & ( const _CvMAT_NOT_& a, const _CvMAT_NOT_& b )
1874 {   return _CvMAT_LOGIC_( a.a, b.a, _CvMAT_LOGIC_::AND, 3 ); }
1875
1876
1877 inline _CvMAT_LOGIC_ operator | ( const CvMAT& a, const CvMAT& b )
1878 {   return _CvMAT_LOGIC_( &a, &b, _CvMAT_LOGIC_::OR, 0 ); }
1879
1880 inline _CvMAT_LOGIC_ operator | ( const _CvMAT_NOT_& a, const CvMAT& b )
1881 {   return _CvMAT_LOGIC_( a.a, &b, _CvMAT_LOGIC_::OR, 1 ); }
1882
1883 inline _CvMAT_LOGIC_ operator | ( const CvMAT& a, const _CvMAT_NOT_& b )
1884 {   return _CvMAT_LOGIC_( &a, b.a, _CvMAT_LOGIC_::OR, 2 ); }
1885
1886 inline _CvMAT_LOGIC_ operator | ( const _CvMAT_NOT_& a, const _CvMAT_NOT_& b )
1887 {   return _CvMAT_LOGIC_( a.a, b.a, _CvMAT_LOGIC_::OR, 3 ); }
1888
1889
1890 inline _CvMAT_LOGIC_ operator ^ ( const CvMAT& a, const CvMAT& b )
1891 {   return _CvMAT_LOGIC_( &a, &b, _CvMAT_LOGIC_::XOR, 0 ); }
1892
1893 inline _CvMAT_LOGIC_ operator ^ ( const _CvMAT_NOT_& a, const CvMAT& b )
1894 {   return _CvMAT_LOGIC_( a.a, &b, _CvMAT_LOGIC_::XOR, 1 ); }
1895
1896 inline _CvMAT_LOGIC_ operator ^ ( const CvMAT& a, const _CvMAT_NOT_& b )
1897 {   return _CvMAT_LOGIC_( &a, b.a, _CvMAT_LOGIC_::XOR, 2 ); }
1898
1899 inline _CvMAT_LOGIC_ operator ^ ( const _CvMAT_NOT_& a, const _CvMAT_NOT_& b )
1900 {   return _CvMAT_LOGIC_( a.a, b.a, _CvMAT_LOGIC_::XOR, 3 ); }
1901
1902
1903 inline _CvMAT_UN_LOGIC_ operator & ( const CvMAT& a, double alpha )
1904 {   return _CvMAT_UN_LOGIC_( &a, alpha, _CvMAT_LOGIC_::AND, 0 ); }
1905
1906 inline _CvMAT_UN_LOGIC_ operator & ( double alpha, const CvMAT& a )
1907 {   return _CvMAT_UN_LOGIC_( &a, alpha, _CvMAT_LOGIC_::AND, 0 ); }
1908
1909 inline _CvMAT_UN_LOGIC_ operator & ( const _CvMAT_NOT_& a, double alpha )
1910 {   return _CvMAT_UN_LOGIC_( a.a, alpha, _CvMAT_LOGIC_::AND, 1 ); }
1911
1912 inline _CvMAT_UN_LOGIC_ operator & ( double alpha, const _CvMAT_NOT_& a )
1913 {   return _CvMAT_UN_LOGIC_( a.a, alpha, _CvMAT_LOGIC_::AND, 1 ); }
1914
1915
1916 inline _CvMAT_UN_LOGIC_ operator | ( const CvMAT& a, double alpha )
1917 {   return _CvMAT_UN_LOGIC_( &a, alpha, _CvMAT_LOGIC_::OR, 0 ); }
1918
1919 inline _CvMAT_UN_LOGIC_ operator | ( double alpha, const CvMAT& a )
1920 {   return _CvMAT_UN_LOGIC_( &a, alpha, _CvMAT_LOGIC_::OR, 0 ); }
1921
1922 inline _CvMAT_UN_LOGIC_ operator | ( const _CvMAT_NOT_& a, double alpha )
1923 {   return _CvMAT_UN_LOGIC_( a.a, alpha, _CvMAT_LOGIC_::OR, 1 ); }
1924
1925 inline _CvMAT_UN_LOGIC_ operator | ( double alpha, const _CvMAT_NOT_& a )
1926 {   return _CvMAT_UN_LOGIC_( a.a, alpha, _CvMAT_LOGIC_::OR, 1 ); }
1927
1928
1929 inline _CvMAT_UN_LOGIC_ operator ^ ( const CvMAT& a, double alpha )
1930 {   return _CvMAT_UN_LOGIC_( &a, alpha, _CvMAT_LOGIC_::XOR, 0 ); }
1931
1932 inline _CvMAT_UN_LOGIC_ operator ^ ( double alpha, const CvMAT& a )
1933 {   return _CvMAT_UN_LOGIC_( &a, alpha, _CvMAT_LOGIC_::XOR, 0 ); }
1934
1935 inline _CvMAT_UN_LOGIC_ operator ^ ( const _CvMAT_NOT_& a, double alpha )
1936 {   return _CvMAT_UN_LOGIC_( a.a, alpha, _CvMAT_LOGIC_::XOR, 1 ); }
1937
1938 inline _CvMAT_UN_LOGIC_ operator ^ ( double alpha, const _CvMAT_NOT_& a )
1939 {   return _CvMAT_UN_LOGIC_( a.a, alpha, _CvMAT_LOGIC_::XOR, 1 ); }
1940
1941
1942 /*
1943 * PART IV. Comparison operations
1944 */
1945 inline _CvMAT_CMP_ operator > ( const CvMAT& a, const CvMAT& b )
1946 {   return _CvMAT_CMP_( &a, &b, CV_CMP_GT ); }
1947
1948 inline _CvMAT_CMP_ operator >= ( const CvMAT& a, const CvMAT& b )
1949 {   return _CvMAT_CMP_( &a, &b, CV_CMP_GE ); }
1950
1951 inline _CvMAT_CMP_ operator < ( const CvMAT& a, const CvMAT& b )
1952 {   return _CvMAT_CMP_( &a, &b, CV_CMP_LT ); }
1953
1954 inline _CvMAT_CMP_ operator <= ( const CvMAT& a, const CvMAT& b )
1955 {   return _CvMAT_CMP_( &a, &b, CV_CMP_LE ); }
1956
1957 inline _CvMAT_CMP_ operator == ( const CvMAT& a, const CvMAT& b )
1958 {   return _CvMAT_CMP_( &a, &b, CV_CMP_EQ ); }
1959
1960 inline _CvMAT_CMP_ operator != ( const CvMAT& a, const CvMAT& b )
1961 {   return _CvMAT_CMP_( &a, &b, CV_CMP_NE ); }
1962
1963
1964 inline _CvMAT_CMP_ operator > ( const CvMAT& a, double alpha )
1965 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_GT ); }
1966
1967 inline _CvMAT_CMP_ operator > ( double alpha, const CvMAT& a )
1968 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_LT ); }
1969
1970 inline _CvMAT_CMP_ operator >= ( const CvMAT& a, double alpha )
1971 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_GE ); }
1972
1973 inline _CvMAT_CMP_ operator >= ( double alpha, const CvMAT& a )
1974 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_LE ); }
1975
1976 inline _CvMAT_CMP_ operator < ( const CvMAT& a, double alpha )
1977 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_LT ); }
1978
1979 inline _CvMAT_CMP_ operator < ( double alpha, const CvMAT& a )
1980 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_GT ); }
1981
1982 inline _CvMAT_CMP_ operator <= ( const CvMAT& a, double alpha )
1983 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_LE ); }
1984
1985 inline _CvMAT_CMP_ operator <= ( double alpha, const CvMAT& a )
1986 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_GE ); }
1987
1988 inline _CvMAT_CMP_ operator == ( const CvMAT& a, double alpha )
1989 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_EQ ); }
1990
1991 inline _CvMAT_CMP_ operator == ( double alpha, const CvMAT& a )
1992 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_EQ ); }
1993
1994 inline _CvMAT_CMP_ operator != ( const CvMAT& a, double alpha )
1995 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_NE ); }
1996
1997 inline _CvMAT_CMP_ operator != ( double alpha, const CvMAT& a )
1998 {   return _CvMAT_CMP_( &a, alpha, CV_CMP_NE ); }
1999
2000
2001 /*
2002 * PART V. Speedup for some augmented assignments to CvMAT
2003 */
2004
2005 inline CvMAT& CvMAT::operator += ( const _CvMAT_SCALE_& scale_mat )
2006 {   return (*this = *this + scale_mat); }
2007
2008 inline CvMAT& CvMAT::operator += ( const _CvMAT_SCALE_SHIFT_& scale_mat )
2009 {   return (*this = *this + scale_mat); }
2010
2011 inline CvMAT& CvMAT::operator += ( const _CvMAT_MUL_& mmul )
2012 {   return (*this = mmul + *this);  }
2013
2014 inline CvMAT& CvMAT::operator -= ( const _CvMAT_SCALE_& scale_mat )
2015 {   return (*this = *this - scale_mat);  }
2016
2017 inline CvMAT& CvMAT::operator -= ( const _CvMAT_SCALE_SHIFT_& scale_mat )
2018 {   return (*this = *this - scale_mat);  }
2019
2020 inline CvMAT& CvMAT::operator -= ( const _CvMAT_MUL_& mmul )
2021 {   return (*this = -mmul + *this);  }
2022
2023 inline CvMAT& CvMAT::operator *= ( const _CvMAT_SCALE_& scale_mat )
2024 {   return (*this = *this * scale_mat);  }
2025
2026 inline CvMAT& CvMAT::operator *= ( const _CvMAT_SCALE_SHIFT_& scale_mat )
2027 {   return (*this = *this * scale_mat);  }
2028
2029 /****************************************************************************************\
2030 *                        misc. operations on temporary matrices (+,-,*)                  *
2031 \****************************************************************************************/
2032
2033 /*
2034 * the base proxy class implementation
2035 */
2036
2037 /* a.*b */
2038 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::mul( const CvMAT& a ) const
2039 {   return ((CvMAT)*this).mul(a);  }
2040
2041 /* a.*b*alpha */
2042 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::mul( const _CvMAT_SCALE_& a ) const
2043 {   return ((CvMAT)*this).mul(a);  }
2044
2045 /* a./b */
2046 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::div( const CvMAT& a ) const
2047 {   return ((CvMAT)*this).div(a);  }
2048
2049 /* a./(b*alpha) */
2050 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::div( const _CvMAT_SCALE_& a ) const
2051 {   return ((CvMAT)*this).div(a);  }
2052
2053 /* a.max(b) */
2054 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::min( const CvMAT& a ) const
2055 {   return ((CvMAT)*this).min(a);  }
2056
2057 /* a.min(b) */
2058 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::max( const CvMAT& a ) const
2059 {   return ((CvMAT)*this).max(a);  }
2060
2061 /* a.max(alpha) */
2062 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::min( double alpha ) const
2063 {   return ((CvMAT)*this).min(alpha);  }
2064
2065 /* a.min(alpha) */
2066 inline _CvMAT_DOT_OP_ _CvMAT_BASE_OP_::max( double alpha ) const
2067 {   return ((CvMAT)*this).max(alpha);  }
2068
2069
2070 inline _CvMAT_INV_  _CvMAT_BASE_OP_::inv( int method ) const
2071 {   return ((CvMAT)*this).inv(method);  }
2072
2073 inline _CvMAT_T_  _CvMAT_BASE_OP_::t() const
2074 {   return ((CvMAT)*this).t();  }
2075
2076 inline _CvMAT_CVT_ _CvMAT_BASE_OP_::cvt( int newdepth, double scale, double shift ) const
2077 {   return ((CvMAT)*this).cvt( newdepth, scale, shift ); }
2078
2079 inline CvMAT  _CvMAT_BASE_OP_::row( int r ) const
2080 {   return CvMAT((CvMAT)*this, 0, r ); }
2081
2082 inline CvMAT  _CvMAT_BASE_OP_::rowrange( int row1, int row2 ) const
2083 {
2084     CvMAT m = (CvMAT)*this;
2085     assert( 0 <= row1 && row1 < row2 && row2 <= m.height );
2086     return CvMAT( m, cvRect( 0, row1, m.width, row2 - row1 ));
2087 }
2088
2089 inline CvMAT  _CvMAT_BASE_OP_::col( int c ) const
2090 {   return CvMAT( (CvMAT)*this, 1, c ); }
2091
2092 inline CvMAT  _CvMAT_BASE_OP_::colrange( int col1, int col2 ) const
2093 {
2094     CvMAT m = (CvMAT)*this;
2095     assert( 0 <= col1 && col1 < col2 && col2 <= m.width );
2096     return CvMAT( m, cvRect( col1, 0, col2 - col1, m.height ));
2097 }
2098
2099 inline CvMAT  _CvMAT_BASE_OP_::rect( CvRect r ) const
2100 {   return CvMAT( (CvMAT)*this, r ); }
2101
2102 inline CvMAT  _CvMAT_BASE_OP_::diag( int d ) const
2103 {   return CvMAT( (CvMAT)*this, -1, d ); }
2104
2105 inline double _CvMAT_BASE_OP_::det() const
2106 {   return ((CvMAT)*this).det(); }
2107
2108 inline double _CvMAT_BASE_OP_::norm( int norm_type ) const
2109 {   return ((CvMAT)*this).norm( norm_type ); }
2110
2111 inline CvScalar _CvMAT_BASE_OP_::sum() const
2112 {   return ((CvMAT)*this).sum(); }
2113
2114 inline double _CvMAT_BASE_OP_::min( CvPoint* minloc ) const
2115 {   return ((CvMAT)*this).min( minloc ); }
2116
2117 inline double _CvMAT_BASE_OP_::max( CvPoint* maxloc ) const
2118 {   return ((CvMAT)*this).max( maxloc ); }
2119
2120
2121 /****************************************************************************************/
2122 /*                              proxy classes implementation.                           */
2123 /*                              part I. constructors                                    */
2124 /****************************************************************************************/
2125
2126 /* constructors */
2127 inline _CvMAT_COPY_::_CvMAT_COPY_( const CvMAT* _a ) : a((CvMAT*)_a)  {}
2128
2129 inline _CvMAT_CVT_::_CvMAT_CVT_( const CvMAT* _a, int _newdepth,
2130                                  double _scale, double _shift ) :
2131     a(*(CvMAT*)_a), newdepth(_newdepth), scale(_scale), shift(_shift)  {}
2132
2133 inline _CvMAT_T_::_CvMAT_T_( const CvMAT* _a ) : a(*(CvMAT*)_a), alpha(1)  {}
2134
2135
2136 inline _CvMAT_T_::_CvMAT_T_( const CvMAT* _a, double _alpha ) :
2137     a(*(CvMAT*)_a), alpha(_alpha)  {}
2138
2139
2140 inline _CvMAT_INV_::_CvMAT_INV_( const CvMAT* _a, int _method ) :
2141     a(*(CvMAT*)_a), method(_method) {}
2142
2143
2144 inline _CvMAT_MUL_::_CvMAT_MUL_( const CvMAT* _a, const CvMAT* _b, int _t_ab ) :
2145     a((CvMAT*)_a), b((CvMAT*)_b), alpha(1), t_ab(_t_ab) {}
2146
2147
2148 inline _CvMAT_MUL_::_CvMAT_MUL_( const CvMAT* _a, const CvMAT* _b,
2149                                  double _alpha, int _t_ab ) :
2150     a((CvMAT*)_a), b((CvMAT*)_b), alpha(_alpha), t_ab(_t_ab) {}
2151
2152
2153 inline _CvMAT_MUL_ADD_::_CvMAT_MUL_ADD_( const CvMAT* _a, const CvMAT* _b,
2154                                          const CvMAT* _c, int _t_abc ) :
2155     a((CvMAT*)_a), b((CvMAT*)_b), c((CvMAT*)_c), t_abc(_t_abc) {}
2156
2157
2158 inline _CvMAT_MUL_ADD_::_CvMAT_MUL_ADD_( const CvMAT* _a, const CvMAT* _b, double _alpha,
2159                                          const CvMAT* _c, double _beta, int _t_abc ) :
2160     a((CvMAT*)_a), b((CvMAT*)_b), alpha(_alpha),
2161     c((CvMAT*)_c), beta(_beta), t_abc(_t_abc) {}
2162
2163
2164 inline _CvMAT_ADD_::_CvMAT_ADD_( const CvMAT* _a, const CvMAT* _b, double _beta ) :
2165     a((CvMAT*)_a), b((CvMAT*)_b), beta(_beta) {}
2166
2167
2168 inline _CvMAT_ADD_EX_::_CvMAT_ADD_EX_( const CvMAT* _a, double _alpha,
2169                                        const CvMAT* _b, double _beta, double _gamma ) :
2170     a((CvMAT*)_a), alpha(_alpha), b((CvMAT*)_b), beta(_beta), gamma(_gamma) {}
2171
2172
2173 inline _CvMAT_SCALE_::_CvMAT_SCALE_( const CvMAT* _a, double _alpha ) :
2174     a((CvMAT*)_a), alpha(_alpha) {}
2175
2176
2177 inline _CvMAT_SCALE_SHIFT_::_CvMAT_SCALE_SHIFT_( const CvMAT* _a,
2178                                                  double _alpha, double _beta ) :
2179     a((CvMAT*)_a), alpha(_alpha), beta(_beta) {}
2180
2181
2182 inline _CvMAT_LOGIC_::_CvMAT_LOGIC_( const CvMAT* _a, const CvMAT* _b,
2183                                             _CvMAT_LOGIC_::Op _op, int _flags ) :
2184     a((CvMAT*)_a), b((CvMAT*)_b), op(_op), flags(_flags) {}
2185
2186
2187 inline _CvMAT_UN_LOGIC_::_CvMAT_UN_LOGIC_( const CvMAT* _a, double _alpha,
2188                                            _CvMAT_LOGIC_::Op _op, int _flags ) :
2189     a((CvMAT*)_a), alpha(_alpha), op(_op), flags(_flags) {}
2190
2191
2192 inline _CvMAT_NOT_::_CvMAT_NOT_( const CvMAT* _a ) :
2193     a((CvMAT*)_a) {}
2194
2195
2196 inline _CvMAT_DOT_OP_::_CvMAT_DOT_OP_( const CvMAT* _a, const CvMAT* _b,
2197                                        int _op, double _alpha ) :
2198     a(*_a), b((CvMAT*)_b), op(_op), alpha(_alpha) {}
2199
2200
2201 inline _CvMAT_SOLVE_::_CvMAT_SOLVE_( const CvMAT* _a, const CvMAT* _b, int _method ) :
2202     a((CvMAT*)_a), b((CvMAT*)_b), method(_method) {}
2203
2204 inline _CvMAT_CMP_::_CvMAT_CMP_( const CvMAT* _a, const CvMAT* _b, int _cmp_op ) :
2205     a((CvMAT*)_a), b((CvMAT*)_b), alpha(0), cmp_op(_cmp_op) {}
2206
2207 inline _CvMAT_CMP_::_CvMAT_CMP_( const CvMAT* _a, double _alpha, int _cmp_op ) :
2208     a((CvMAT*)_a), b(0), alpha(_alpha), cmp_op(_cmp_op) {}
2209
2210 /****************************************************************************************/
2211 /*                              proxy classes implementation.                           */
2212 /*                              part II. conversion to CvMAT                      */
2213 /****************************************************************************************/
2214
2215 inline _CvMAT_T_::operator CvMAT() const
2216 {   return CvMAT( *this );    }
2217
2218 inline _CvMAT_INV_::operator CvMAT() const
2219 {   return CvMAT( *this );    }
2220
2221 inline _CvMAT_MUL_::operator CvMAT() const
2222 {   return CvMAT( *this );    }
2223
2224 inline _CvMAT_SCALE_::operator CvMAT() const
2225 {   return CvMAT( *this );    }
2226
2227 inline _CvMAT_SCALE_SHIFT_::operator CvMAT() const
2228 {   return CvMAT( *this );    }
2229
2230 inline _CvMAT_ADD_::operator CvMAT() const
2231 {   return CvMAT( *this );    }
2232
2233 inline _CvMAT_ADD_EX_::operator CvMAT() const
2234 {   return CvMAT( *this );    }
2235
2236 inline _CvMAT_MUL_ADD_::operator CvMAT() const
2237 {   return CvMAT( *this );    }
2238
2239 inline _CvMAT_LOGIC_::operator CvMAT() const
2240 {   return CvMAT( *this );    }
2241
2242 inline _CvMAT_UN_LOGIC_::operator CvMAT() const
2243 {   return CvMAT( *this );    }
2244
2245 inline _CvMAT_NOT_::operator CvMAT() const
2246 {   return CvMAT( *this );    }
2247
2248 inline _CvMAT_DOT_OP_::operator CvMAT() const
2249 {   return CvMAT( *this );    }
2250
2251 inline _CvMAT_SOLVE_::operator CvMAT() const
2252 {   return CvMAT( *this );    }
2253
2254 inline _CvMAT_CMP_::operator CvMAT() const
2255 {   return CvMAT( *this );    }
2256
2257 inline _CvMAT_CVT_::operator CvMAT() const
2258 {   return CvMAT(*this);   }
2259
2260 inline _CvMAT_COPY_::operator CvMAT() const
2261 {   return *a;   }
2262
2263 /****************************************************************************************/
2264 /*                              proxy classes implementation.                           */
2265 /*                              part III. custom overrided methods                      */
2266 /****************************************************************************************/
2267
2268 inline _CvMAT_DOT_OP_ _CvMAT_SCALE_::mul( const CvMAT& mat ) const
2269 {   return _CvMAT_DOT_OP_( a, &mat, '*', alpha );   }
2270
2271 inline _CvMAT_DOT_OP_ _CvMAT_SCALE_::mul( const _CvMAT_SCALE_& mat ) const
2272 {   return _CvMAT_DOT_OP_( a, mat.a, '*', alpha*mat.alpha );   }
2273
2274 inline _CvMAT_DOT_OP_ _CvMAT_SCALE_::div( const CvMAT& mat ) const
2275 {   return _CvMAT_DOT_OP_( a, &mat, '/', alpha );   }
2276
2277 inline _CvMAT_DOT_OP_ _CvMAT_SCALE_::div( const _CvMAT_SCALE_& mat ) const
2278 {   return _CvMAT_DOT_OP_( a, mat.a, '/', alpha/mat.alpha );   }
2279
2280 inline _CvMAT_DOT_OP_ operator * ( const _CvMAT_DOT_OP_& dot_op, double alpha )
2281 {   return _CvMAT_DOT_OP_( &dot_op.a, dot_op.b, dot_op.op, dot_op.alpha * alpha );  }
2282
2283 inline _CvMAT_DOT_OP_ operator * ( double alpha, const _CvMAT_DOT_OP_& dot_op )
2284 {   return _CvMAT_DOT_OP_( &dot_op.a, dot_op.b, dot_op.op, dot_op.alpha * alpha );  }
2285
2286 inline _CvMAT_DOT_OP_ operator / ( double alpha, const CvMAT& mat )
2287 {   return _CvMAT_DOT_OP_( &mat, 0, '/', alpha );  }
2288
2289 inline _CvMAT_DOT_OP_ operator / ( double alpha, const _CvMAT_SCALE_& mat )
2290 {   return _CvMAT_DOT_OP_( mat.a, 0, '/', alpha/mat.alpha );  }
2291
2292
2293 inline double _CvMAT_T_::det() const
2294 {   return a.det();     }
2295
2296 inline double _CvMAT_T_::norm( int norm_type ) const
2297 {   return a.norm( norm_type );    }
2298
2299 inline double _CvMAT_ADD_::norm( int norm_type ) const
2300 {
2301     if( beta == -1 )
2302         return cvNorm( a, b, norm_type );
2303     else
2304         return ((CvMAT)*this).norm( norm_type );
2305 }
2306
2307 inline _CvMAT_DOT_OP_ _CvMAT_ADD_::abs() const
2308 {
2309     if( beta == -1 )
2310         return _CvMAT_DOT_OP_( a, b, 'a', 0 );
2311     else
2312         return ((CvMAT)*this).abs();
2313 }
2314
2315 inline _CvMAT_DOT_OP_ _CvMAT_SCALE_SHIFT_::abs() const
2316 {
2317     if( alpha == 1 )
2318         return _CvMAT_DOT_OP_( a, 0, 'a', -beta );
2319     else
2320         return ((CvMAT)*this).abs();
2321 }
2322
2323 #endif /* __cplusplus */
2324
2325 #endif /*_CVMAT_HPP_*/
2326