git.maemo.org Git - opencv/blob - cxcore/src/cxmeansdv.cpp

   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 #include "_cxcore.h"
  43
  44 /****************************************************************************************\
  45 *                             Mean and StdDev calculation                                *
  46 \****************************************************************************************/
  47
  48 #define ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, \
  49                                sqr_macro, len, cn ) \
  50     for( ; x <= (len) - 4*(cn); x += 4*(cn))\
  51     {                                       \
  52         worktype t0 = src[x];               \
  53         worktype t1 = src[x + (cn)];        \
  54                                             \
  55         s0  += t0 + t1;                     \
  56         sq0 += (sqsumtype)(sqr_macro(t0)) + \
  57                (sqsumtype)(sqr_macro(t1));  \
  58                                             \
  59         t0 = src[x + 2*(cn)];               \
  60         t1 = src[x + 3*(cn)];               \
  61                                             \
  62         s0  += t0 + t1;                     \
  63         sq0 += (sqsumtype)(sqr_macro(t0)) + \
  64                (sqsumtype)(sqr_macro(t1));  \
  65     }                                       \
  66                                             \
  67     for( ; x < (len); x += (cn) )           \
  68     {                                       \
  69         worktype t0 = src[x];               \
  70                                             \
  71         s0 += t0;                           \
  72         sq0 += (sqsumtype)(sqr_macro(t0));  \
  73     }
  74
  75
  76 #define ICV_MEAN_SDV_CASE_C1( worktype, sqsumtype, sqr_macro, len ) \
  77     ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, sqr_macro, len, 1 )
  78
  79
  80 #define ICV_MEAN_SDV_CASE_C2( worktype, sqsumtype, \
  81                               sqr_macro, len ) \
  82     for( ; x < (len); x += 2 )              \
  83     {                                       \
  84         worktype t0 = (src)[x];             \
  85         worktype t1 = (src)[x + 1];         \
  86                                             \
  87         s0 += t0;                           \
  88         sq0 += (sqsumtype)(sqr_macro(t0));  \
  89         s1 += t1;                           \
  90         sq1 += (sqsumtype)(sqr_macro(t1));  \
  91     }
  92
  93
  94 #define ICV_MEAN_SDV_CASE_C3( worktype, sqsumtype, \
  95                               sqr_macro, len ) \
  96     for( ; x < (len); x += 3 )              \
  97     {                                       \
  98         worktype t0 = (src)[x];             \
  99         worktype t1 = (src)[x + 1];         \
 100         worktype t2 = (src)[x + 2];         \
 101                                             \
 102         s0 += t0;                           \
 103         sq0 += (sqsumtype)(sqr_macro(t0));  \
 104         s1 += t1;                           \
 105         sq1 += (sqsumtype)(sqr_macro(t1));  \
 106         s2 += t2;                           \
 107         sq2 += (sqsumtype)(sqr_macro(t2));  \
 108     }
 109
 110
 111 #define ICV_MEAN_SDV_CASE_C4( worktype, sqsumtype, \
 112                               sqr_macro, len ) \
 113     for( ; x < (len); x += 4 )              \
 114     {                                       \
 115         worktype t0 = (src)[x];             \
 116         worktype t1 = (src)[x + 1];         \
 117                                             \
 118         s0 += t0;                           \
 119         sq0 += (sqsumtype)(sqr_macro(t0));  \
 120         s1 += t1;                           \
 121         sq1 += (sqsumtype)(sqr_macro(t1));  \
 122                                             \
 123         t0 = (src)[x + 2];                  \
 124         t1 = (src)[x + 3];                  \
 125                                             \
 126         s2 += t0;                           \
 127         sq2 += (sqsumtype)(sqr_macro(t0));  \
 128         s3 += t1;                           \
 129         sq3 += (sqsumtype)(sqr_macro(t1));  \
 130     }
 131
 132
 133 #define ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, \
 134                                     sqr_macro, len, cn ) \
 135     for( ; x <= (len) - 4; x += 4 )             \
 136     {                                           \
 137         worktype t0;                            \
 138         if( mask[x] )                           \
 139         {                                       \
 140             t0 = src[x*(cn)]; pix++;            \
 141             s0 += t0;                           \
 142             sq0 += sqsumtype(sqr_macro(t0));    \
 143         }                                       \
 144                                                 \
 145         if( mask[x+1] )                         \
 146         {                                       \
 147             t0 = src[(x+1)*(cn)]; pix++;        \
 148             s0 += t0;                           \
 149             sq0 += sqsumtype(sqr_macro(t0));    \
 150         }                                       \
 151                                                 \
 152         if( mask[x+2] )                         \
 153         {                                       \
 154             t0 = src[(x+2)*(cn)]; pix++;        \
 155             s0 += t0;                           \
 156             sq0 += sqsumtype(sqr_macro(t0));    \
 157         }                                       \
 158                                                 \
 159         if( mask[x+3] )                         \
 160         {                                       \
 161             t0 = src[(x+3)*(cn)]; pix++;        \
 162             s0 += t0;                           \
 163             sq0 += sqsumtype(sqr_macro(t0));    \
 164         }                                       \
 165     }                                           \
 166                                                 \
 167     for( ; x < (len); x++ )                     \
 168     {                                           \
 169         if( mask[x] )                           \
 170         {                                       \
 171             worktype t0 = src[x*(cn)]; pix++;   \
 172             s0 += t0;                           \
 173             sq0 += sqsumtype(sqr_macro(t0));    \
 174         }                                       \
 175     }
 176
 177
 178 #define ICV_MEAN_SDV_MASK_CASE_C1( worktype, sqsumtype, sqr_macro, len )    \
 179     ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, sqr_macro, len, 1 )
 180
 181
 182 #define ICV_MEAN_SDV_MASK_CASE_C2( worktype, sqsumtype,\
 183                                    sqr_macro, len )    \
 184     for( ; x < (len); x++ )                     \
 185     {                                           \
 186         if( mask[x] )                           \
 187         {                                       \
 188             worktype t0 = src[x*2];             \
 189             worktype t1 = src[x*2+1];           \
 190             pix++;                              \
 191             s0 += t0;                           \
 192             sq0 += sqsumtype(sqr_macro(t0));    \
 193             s1 += t1;                           \
 194             sq1 += sqsumtype(sqr_macro(t1));    \
 195         }                                       \
 196     }
 197
 198
 199 #define ICV_MEAN_SDV_MASK_CASE_C3( worktype, sqsumtype,\
 200                                    sqr_macro, len )    \
 201     for( ; x < (len); x++ )                     \
 202     {                                           \
 203         if( mask[x] )                           \
 204         {                                       \
 205             worktype t0 = src[x*3];             \
 206             worktype t1 = src[x*3+1];           \
 207             worktype t2 = src[x*3+2];           \
 208             pix++;                              \
 209             s0 += t0;                           \
 210             sq0 += sqsumtype(sqr_macro(t0));    \
 211             s1 += t1;                           \
 212             sq1 += sqsumtype(sqr_macro(t1));    \
 213             s2 += t2;                           \
 214             sq2 += sqsumtype(sqr_macro(t2));    \
 215         }                                       \
 216     }
 217
 218
 219 #define ICV_MEAN_SDV_MASK_CASE_C4( worktype, sqsumtype,\
 220                                    sqr_macro, len )    \
 221     for( ; x < (len); x++ )                     \
 222     {                                           \
 223         if( mask[x] )                           \
 224         {                                       \
 225             worktype t0 = src[x*4];             \
 226             worktype t1 = src[x*4+1];           \
 227             pix++;                              \
 228             s0 += t0;                           \
 229             sq0 += sqsumtype(sqr_macro(t0));    \
 230             s1 += t1;                           \
 231             sq1 += sqsumtype(sqr_macro(t1));    \
 232             t0 = src[x*4+2];                    \
 233             t1 = src[x*4+3];                    \
 234             s2 += t0;                           \
 235             sq2 += sqsumtype(sqr_macro(t0));    \
 236             s3 += t1;                           \
 237             sq3 += sqsumtype(sqr_macro(t1));    \
 238         }                                       \
 239     }
 240
 241
 242 ////////////////////////////////////// entry macros //////////////////////////////////////
 243
 244 #define ICV_MEAN_SDV_ENTRY_COMMON()                 \
 245     int pix;                                        \
 246     double scale, tmp;                              \
 247     step /= sizeof(src[0])
 248
 249 #define ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ) \
 250     sumtype s0 = 0;                                 \
 251     sqsumtype sq0 = 0;                              \
 252     ICV_MEAN_SDV_ENTRY_COMMON()
 253
 254 #define ICV_MEAN_SDV_ENTRY_C2( sumtype, sqsumtype ) \
 255     sumtype s0 = 0, s1 = 0;                         \
 256     sqsumtype sq0 = 0, sq1 = 0;                     \
 257     ICV_MEAN_SDV_ENTRY_COMMON()
 258
 259 #define ICV_MEAN_SDV_ENTRY_C3( sumtype, sqsumtype ) \
 260     sumtype s0 = 0, s1 = 0, s2 = 0;                 \
 261     sqsumtype sq0 = 0, sq1 = 0, sq2 = 0;            \
 262     ICV_MEAN_SDV_ENTRY_COMMON()
 263
 264 #define ICV_MEAN_SDV_ENTRY_C4( sumtype, sqsumtype ) \
 265     sumtype s0 = 0, s1 = 0, s2 = 0, s3 = 0;         \
 266     sqsumtype sq0 = 0, sq1 = 0, sq2 = 0, sq3 = 0;   \
 267     ICV_MEAN_SDV_ENTRY_COMMON()
 268
 269
 270 #define ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )   \
 271     int remaining = block_size;                         \
 272     ICV_MEAN_SDV_ENTRY_COMMON()
 273
 274 #define ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype,        \
 275                         worktype, sqworktype, block_size )      \
 276     sumtype sum0 = 0;                                           \
 277     sqsumtype sqsum0 = 0;                                       \
 278     worktype s0 = 0;                                            \
 279     sqworktype sq0 = 0;                                         \
 280     ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
 281
 282 #define ICV_MEAN_SDV_ENTRY_BLOCK_C2( sumtype, sqsumtype,        \
 283                         worktype, sqworktype, block_size )      \
 284     sumtype sum0 = 0, sum1 = 0;                                 \
 285     sqsumtype sqsum0 = 0, sqsum1 = 0;                           \
 286     worktype s0 = 0, s1 = 0;                                    \
 287     sqworktype sq0 = 0, sq1 = 0;                                \
 288     ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
 289
 290 #define ICV_MEAN_SDV_ENTRY_BLOCK_C3( sumtype, sqsumtype,        \
 291                         worktype, sqworktype, block_size )      \
 292     sumtype sum0 = 0, sum1 = 0, sum2 = 0;                       \
 293     sqsumtype sqsum0 = 0, sqsum1 = 0, sqsum2 = 0;               \
 294     worktype s0 = 0, s1 = 0, s2 = 0;                            \
 295     sqworktype sq0 = 0, sq1 = 0, sq2 = 0;                       \
 296     ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
 297
 298 #define ICV_MEAN_SDV_ENTRY_BLOCK_C4( sumtype, sqsumtype,        \
 299                         worktype, sqworktype, block_size )      \
 300     sumtype sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;             \
 301     sqsumtype sqsum0 = 0, sqsum1 = 0, sqsum2 = 0, sqsum3 = 0;   \
 302     worktype s0 = 0, s1 = 0, s2 = 0, s3 = 0;                    \
 303     sqworktype sq0 = 0, sq1 = 0, sq2 = 0, sq3 = 0;              \
 304     ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
 305
 306
 307 /////////////////////////////////////// exit macros //////////////////////////////////////
 308
 309 #define ICV_MEAN_SDV_EXIT_COMMON()              \
 310     scale = pix ? 1./pix : 0
 311
 312 #define ICV_MEAN_SDV_EXIT_CN( total, sqtotal, idx ) \
 313     ICV_MEAN_SDV_EXIT_COMMON();                 \
 314     mean[idx] = tmp = scale*(double)total##idx; \
 315     tmp = scale*(double)sqtotal##idx - tmp*tmp; \
 316     sdv[idx] = sqrt(MAX(tmp,0.))
 317
 318 #define ICV_MEAN_SDV_EXIT_C1( total, sqtotal )  \
 319     ICV_MEAN_SDV_EXIT_COMMON();                 \
 320     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 )
 321
 322 #define ICV_MEAN_SDV_EXIT_C2( total, sqtotal )  \
 323     ICV_MEAN_SDV_EXIT_COMMON();                 \
 324     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 );  \
 325     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 )
 326
 327 #define ICV_MEAN_SDV_EXIT_C3( total, sqtotal )  \
 328     ICV_MEAN_SDV_EXIT_COMMON();                 \
 329     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 );  \
 330     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 );  \
 331     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 2 )
 332
 333 #define ICV_MEAN_SDV_EXIT_C4( total, sqtotal )  \
 334     ICV_MEAN_SDV_EXIT_COMMON();                 \
 335     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 );  \
 336     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 );  \
 337     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 2 );  \
 338     ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 3 )
 339
 340 ////////////////////////////////////// update macros /////////////////////////////////////
 341
 342 #define ICV_MEAN_SDV_UPDATE_COMMON( block_size )\
 343     remaining = block_size
 344
 345 #define ICV_MEAN_SDV_UPDATE_C1( block_size )    \
 346     ICV_MEAN_SDV_UPDATE_COMMON( block_size );   \
 347     sum0 += s0; sqsum0 += sq0;                  \
 348     s0 = 0; sq0 = 0
 349
 350 #define ICV_MEAN_SDV_UPDATE_C2( block_size )    \
 351     ICV_MEAN_SDV_UPDATE_COMMON( block_size );   \
 352     sum0 += s0; sqsum0 += sq0;                  \
 353     sum1 += s1; sqsum1 += sq1;                  \
 354     s0 = s1 = 0; sq0 = sq1 = 0
 355
 356 #define ICV_MEAN_SDV_UPDATE_C3( block_size )    \
 357     ICV_MEAN_SDV_UPDATE_COMMON( block_size );   \
 358     sum0 += s0; sqsum0 += sq0;                  \
 359     sum1 += s1; sqsum1 += sq1;                  \
 360     sum2 += s2; sqsum2 += sq2;                  \
 361     s0 = s1 = s2 = 0; sq0 = sq1 = sq2 = 0
 362
 363 #define ICV_MEAN_SDV_UPDATE_C4( block_size )    \
 364     ICV_MEAN_SDV_UPDATE_COMMON( block_size );   \
 365     sum0 += s0; sqsum0 += sq0;                  \
 366     sum1 += s1; sqsum1 += sq1;                  \
 367     sum2 += s2; sqsum2 += sq2;                  \
 368     sum3 += s3; sqsum3 += sq3;                  \
 369     s0 = s1 = s2 = s3 = 0; sq0 = sq1 = sq2 = sq3 = 0
 370
 371
 372
 373 #define ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, cn, arrtype,        \
 374                                 sumtype, sqsumtype, worktype,       \
 375                                 sqworktype, block_size, sqr_macro ) \
 376 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##R,         \
 377                         ( const arrtype* src, int step,             \
 378                           CvSize size, double* mean, double* sdv ), \
 379                           (src, step, size, mean, sdv) )            \
 380 {                                                                   \
 381     ICV_MEAN_SDV_ENTRY_BLOCK_C##cn( sumtype, sqsumtype,             \
 382                 worktype, sqworktype, (block_size)*(cn) );          \
 383     pix = size.width * size.height;                                 \
 384     size.width *= (cn);                                             \
 385                                                                     \
 386     for( ; size.height--; src += step )                             \
 387     {                                                               \
 388         int x = 0;                                                  \
 389         while( x < size.width )                                     \
 390         {                                                           \
 391             int limit = MIN( remaining, size.width - x );           \
 392             remaining -= limit;                                     \
 393             limit += x;                                             \
 394             ICV_MEAN_SDV_CASE_C##cn( worktype, sqworktype,          \
 395                                      sqr_macro, limit );            \
 396             if( remaining == 0 )                                    \
 397             {                                                       \
 398                 ICV_MEAN_SDV_UPDATE_C##cn( (block_size)*(cn) );     \
 399             }                                                       \
 400         }                                                           \
 401     }                                                               \
 402                                                                     \
 403     ICV_MEAN_SDV_UPDATE_C##cn(0);                                   \
 404     ICV_MEAN_SDV_EXIT_C##cn( sum, sqsum );                          \
 405     return CV_OK;                                                   \
 406 }
 407
 408
 409 #define ICV_DEF_MEAN_SDV_FUNC_2D( flavor, cn, arrtype,              \
 410                                   sumtype, sqsumtype, worktype )    \
 411 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##R,         \
 412                         ( const arrtype* src, int step,             \
 413                           CvSize size, double* mean, double* sdv ), \
 414                           (src, step, size, mean, sdv) )            \
 415 {                                                                   \
 416     ICV_MEAN_SDV_ENTRY_C##cn( sumtype, sqsumtype );                 \
 417     pix = size.width * size.height;                                 \
 418     size.width *= (cn);                                             \
 419                                                                     \
 420     for( ; size.height--; src += step )                             \
 421     {                                                               \
 422         int x = 0;                                                  \
 423         ICV_MEAN_SDV_CASE_C##cn( worktype, sqsumtype,               \
 424                                  CV_SQR, size.width );              \
 425     }                                                               \
 426                                                                     \
 427     ICV_MEAN_SDV_EXIT_C##cn( s, sq );                               \
 428     return CV_OK;                                                   \
 429 }
 430
 431
 432 #define ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D_COI( flavor, arrtype,        \
 433                                 sumtype, sqsumtype, worktype,       \
 434                                 sqworktype, block_size, sqr_macro ) \
 435 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCR           \
 436                         ( const arrtype* src, int step,             \
 437                           CvSize size, int cn, int coi,             \
 438                           double* mean, double* sdv )               \
 439 {                                                                   \
 440     ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype,                \
 441                 worktype, sqworktype, (block_size)*(cn) );          \
 442     pix = size.width * size.height;                                 \
 443     size.width *= (cn);                                             \
 444     src += coi - 1;                                                 \
 445                                                                     \
 446     for( ; size.height--; src += step )                             \
 447     {                                                               \
 448         int x = 0;                                                  \
 449         while( x < size.width )                                     \
 450         {                                                           \
 451             int limit = MIN( remaining, size.width - x );           \
 452             remaining -= limit;                                     \
 453             limit += x;                                             \
 454             ICV_MEAN_SDV_COI_CASE( worktype, sqworktype,            \
 455                                    sqr_macro, limit, cn);           \
 456             if( remaining == 0 )                                    \
 457             {                                                       \
 458                 ICV_MEAN_SDV_UPDATE_C1( (block_size)*(cn) );        \
 459             }                                                       \
 460         }                                                           \
 461     }                                                               \
 462                                                                     \
 463     ICV_MEAN_SDV_UPDATE_C1(0);                                      \
 464     ICV_MEAN_SDV_EXIT_C1( sum, sqsum );                             \
 465     return CV_OK;                                                   \
 466 }
 467
 468
 469 #define ICV_DEF_MEAN_SDV_FUNC_2D_COI( flavor, arrtype,              \
 470                                       sumtype, sqsumtype, worktype )\
 471 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCR           \
 472                         ( const arrtype* src, int step, CvSize size,\
 473                         int cn, int coi, double* mean, double* sdv )\
 474 {                                                                   \
 475     ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype );                    \
 476     pix = size.width * size.height;                                 \
 477     size.width *= (cn);                                             \
 478     src += coi - 1;                                                 \
 479                                                                     \
 480     for( ; size.height--; src += step )                             \
 481     {                                                               \
 482         int x = 0;                                                  \
 483         ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype,                 \
 484                                CV_SQR, size.width, cn );            \
 485     }                                                               \
 486                                                                     \
 487     ICV_MEAN_SDV_EXIT_C1( s, sq );                                  \
 488     return CV_OK;                                                   \
 489 }
 490
 491
 492 #define ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, cn,            \
 493                         arrtype, sumtype, sqsumtype, worktype,      \
 494                         sqworktype, block_size, sqr_macro )         \
 495 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##MR,        \
 496                         ( const arrtype* src, int step,             \
 497                           const uchar* mask, int maskstep,          \
 498                           CvSize size, double* mean, double* sdv ), \
 499                        (src, step, mask, maskstep, size, mean, sdv))\
 500 {                                                                   \
 501     ICV_MEAN_SDV_ENTRY_BLOCK_C##cn( sumtype, sqsumtype,             \
 502                     worktype, sqworktype, block_size );             \
 503     pix = 0;                                                        \
 504                                                                     \
 505     for( ; size.height--; src += step, mask += maskstep )           \
 506     {                                                               \
 507         int x = 0;                                                  \
 508         while( x < size.width )                                     \
 509         {                                                           \
 510             int limit = MIN( remaining, size.width - x );           \
 511             remaining -= limit;                                     \
 512             limit += x;                                             \
 513             ICV_MEAN_SDV_MASK_CASE_C##cn( worktype, sqworktype,     \
 514                                           sqr_macro, limit );       \
 515             if( remaining == 0 )                                    \
 516             {                                                       \
 517                 ICV_MEAN_SDV_UPDATE_C##cn( block_size );            \
 518             }                                                       \
 519         }                                                           \
 520     }                                                               \
 521                                                                     \
 522     ICV_MEAN_SDV_UPDATE_C##cn(0);                                   \
 523     ICV_MEAN_SDV_EXIT_C##cn( sum, sqsum );                          \
 524     return CV_OK;                                                   \
 525 }
 526
 527
 528 #define ICV_DEF_MEAN_SDV_MASK_FUNC_2D( flavor, cn, arrtype,         \
 529                                        sumtype, sqsumtype, worktype)\
 530 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##MR,        \
 531                         ( const arrtype* src, int step,             \
 532                           const uchar* mask, int maskstep,          \
 533                           CvSize size, double* mean, double* sdv ), \
 534                        (src, step, mask, maskstep, size, mean, sdv))\
 535 {                                                                   \
 536     ICV_MEAN_SDV_ENTRY_C##cn( sumtype, sqsumtype );                 \
 537     pix = 0;                                                        \
 538                                                                     \
 539     for( ; size.height--; src += step, mask += maskstep )           \
 540     {                                                               \
 541         int x = 0;                                                  \
 542         ICV_MEAN_SDV_MASK_CASE_C##cn( worktype, sqsumtype,          \
 543                                       CV_SQR, size.width );         \
 544     }                                                               \
 545                                                                     \
 546     ICV_MEAN_SDV_EXIT_C##cn( s, sq );                               \
 547     return CV_OK;                                                   \
 548 }
 549
 550
 551 #define ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D_COI( flavor,            \
 552                             arrtype, sumtype, sqsumtype, worktype,  \
 553                             sqworktype, block_size, sqr_macro )     \
 554 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCMR          \
 555                         ( const arrtype* src, int step,             \
 556                           const uchar* mask, int maskstep,          \
 557                           CvSize size, int cn, int coi,             \
 558                           double* mean, double* sdv )               \
 559 {                                                                   \
 560     ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype,                \
 561                     worktype, sqworktype, block_size );             \
 562     pix = 0;                                                        \
 563     src += coi - 1;                                                 \
 564                                                                     \
 565     for( ; size.height--; src += step, mask += maskstep )           \
 566     {                                                               \
 567         int x = 0;                                                  \
 568         while( x < size.width )                                     \
 569         {                                                           \
 570             int limit = MIN( remaining, size.width - x );           \
 571             remaining -= limit;                                     \
 572             limit += x;                                             \
 573             ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqworktype,       \
 574                                         sqr_macro, limit, cn );     \
 575             if( remaining == 0 )                                    \
 576             {                                                       \
 577                 ICV_MEAN_SDV_UPDATE_C1( block_size );               \
 578             }                                                       \
 579         }                                                           \
 580     }                                                               \
 581                                                                     \
 582     ICV_MEAN_SDV_UPDATE_C1(0);                                      \
 583     ICV_MEAN_SDV_EXIT_C1( sum, sqsum );                             \
 584     return CV_OK;                                                   \
 585 }
 586
 587
 588 #define ICV_DEF_MEAN_SDV_MASK_FUNC_2D_COI( flavor, arrtype,         \
 589                                     sumtype, sqsumtype, worktype )  \
 590 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCMR          \
 591                         ( const arrtype* src, int step,             \
 592                           const uchar* mask, int maskstep,          \
 593                           CvSize size, int cn, int coi,             \
 594                           double* mean, double* sdv )               \
 595 {                                                                   \
 596     ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype );                    \
 597     pix = 0;                                                        \
 598     src += coi - 1;                                                 \
 599                                                                     \
 600     for( ; size.height--; src += step, mask += maskstep )           \
 601     {                                                               \
 602         int x = 0;                                                  \
 603         ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype,            \
 604                                     CV_SQR, size.width, cn );       \
 605     }                                                               \
 606                                                                     \
 607     ICV_MEAN_SDV_EXIT_C1( s, sq );                                  \
 608     return CV_OK;                                                   \
 609 }
 610
 611
 612 #define ICV_DEF_MEAN_SDV_BLOCK_ALL( flavor, arrtype, sumtype, sqsumtype,\
 613                             worktype, sqworktype, block_size, sqr_macro)\
 614 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 1, arrtype, sumtype, sqsumtype, \
 615                             worktype, sqworktype, block_size, sqr_macro)\
 616 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 2, arrtype, sumtype, sqsumtype, \
 617                             worktype, sqworktype, block_size, sqr_macro)\
 618 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 3, arrtype, sumtype, sqsumtype, \
 619                             worktype, sqworktype, block_size, sqr_macro)\
 620 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 4, arrtype, sumtype, sqsumtype, \
 621                             worktype, sqworktype, block_size, sqr_macro)\
 622 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype,\
 623                             worktype, sqworktype, block_size, sqr_macro)\
 624                                                                         \
 625 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 1, arrtype, sumtype,       \
 626             sqsumtype, worktype, sqworktype, block_size, sqr_macro )    \
 627 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 2, arrtype, sumtype,       \
 628             sqsumtype, worktype, sqworktype, block_size, sqr_macro )    \
 629 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 3, arrtype, sumtype,       \
 630             sqsumtype, worktype, sqworktype, block_size, sqr_macro )    \
 631 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 4, arrtype, sumtype,       \
 632             sqsumtype, worktype, sqworktype, block_size, sqr_macro )    \
 633 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D_COI( flavor, arrtype, sumtype,      \
 634             sqsumtype, worktype, sqworktype, block_size, sqr_macro )
 635
 636 #define ICV_DEF_MEAN_SDV_ALL( flavor, arrtype, sumtype, sqsumtype, worktype )   \
 637 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 1, arrtype, sumtype, sqsumtype, worktype )    \
 638 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 2, arrtype, sumtype, sqsumtype, worktype )    \
 639 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 3, arrtype, sumtype, sqsumtype, worktype )    \
 640 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 4, arrtype, sumtype, sqsumtype, worktype )    \
 641 ICV_DEF_MEAN_SDV_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype, worktype )   \
 642                                                                                 \
 643 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 1, arrtype, sumtype, sqsumtype, worktype) \
 644 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 2, arrtype, sumtype, sqsumtype, worktype) \
 645 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 3, arrtype, sumtype, sqsumtype, worktype) \
 646 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 4, arrtype, sumtype, sqsumtype, worktype) \
 647 ICV_DEF_MEAN_SDV_MASK_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype, worktype )
 648
 649
 650 ICV_DEF_MEAN_SDV_BLOCK_ALL( 8u, uchar, int64, int64, unsigned, unsigned, 1 << 16, CV_SQR_8U )
 651 ICV_DEF_MEAN_SDV_BLOCK_ALL( 16u, ushort, int64, int64, unsigned, int64, 1 << 16, CV_SQR )
 652 ICV_DEF_MEAN_SDV_BLOCK_ALL( 16s, short, int64, int64, int, int64, 1 << 16, CV_SQR )
 653
 654 ICV_DEF_MEAN_SDV_ALL( 32s, int, double, double, double )
 655 ICV_DEF_MEAN_SDV_ALL( 32f, float, double, double, double )
 656 ICV_DEF_MEAN_SDV_ALL( 64f, double, double, double, double )
 657
 658 #define icvMean_StdDev_8s_C1R  0
 659 #define icvMean_StdDev_8s_C2R  0
 660 #define icvMean_StdDev_8s_C3R  0
 661 #define icvMean_StdDev_8s_C4R  0
 662 #define icvMean_StdDev_8s_CnCR 0
 663
 664 #define icvMean_StdDev_8s_C1MR  0
 665 #define icvMean_StdDev_8s_C2MR  0
 666 #define icvMean_StdDev_8s_C3MR  0
 667 #define icvMean_StdDev_8s_C4MR  0
 668 #define icvMean_StdDev_8s_CnCMR 0
 669
 670 CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean_StdDev, R )
 671 CV_DEF_INIT_FUNC_TAB_2D( Mean_StdDev, CnCR )
 672 CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean_StdDev, MR )
 673 CV_DEF_INIT_FUNC_TAB_2D( Mean_StdDev, CnCMR )
 674
 675 CV_IMPL  void
 676 cvAvgSdv( const CvArr* img, CvScalar* _mean, CvScalar* _sdv, const void* mask )
 677 {
 678     CvScalar mean = {{0,0,0,0}};
 679     CvScalar sdv = {{0,0,0,0}};
 680
 681     static CvBigFuncTable meansdv_tab;
 682     static CvFuncTable meansdvcoi_tab;
 683     static CvBigFuncTable meansdvmask_tab;
 684     static CvFuncTable meansdvmaskcoi_tab;
 685     static int inittab = 0;
 686
 687     CV_FUNCNAME("cvMean_StdDev");
 688
 689     __BEGIN__;
 690
 691     int type, coi = 0;
 692     int mat_step, mask_step = 0;
 693     CvSize size;
 694     CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;
 695
 696     if( !inittab )
 697     {
 698         icvInitMean_StdDevRTable( &meansdv_tab );
 699         icvInitMean_StdDevCnCRTable( &meansdvcoi_tab );
 700         icvInitMean_StdDevMRTable( &meansdvmask_tab );
 701         icvInitMean_StdDevCnCMRTable( &meansdvmaskcoi_tab );
 702         inittab = 1;
 703     }
 704
 705     if( !CV_IS_MAT(mat) )
 706         CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
 707
 708     type = CV_MAT_TYPE( mat->type );
 709
 710     if( CV_MAT_CN(type) > 4 && coi == 0 )
 711         CV_ERROR( CV_StsOutOfRange, "The input array must have at most 4 channels unless COI is set" );
 712
 713     size = cvGetMatSize( mat );
 714     mat_step = mat->step;
 715
 716     if( !mask )
 717     {
 718         if( CV_IS_MAT_CONT( mat->type ))
 719         {
 720             size.width *= size.height;
 721             size.height = 1;
 722             mat_step = CV_STUB_STEP;
 723         }
 724
 725         if( CV_MAT_CN(type) == 1 || coi == 0 )
 726         {
 727             CvFunc2D_1A2P func = (CvFunc2D_1A2P)(meansdv_tab.fn_2d[type]);
 728
 729             if( !func )
 730                 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
 731
 732             IPPI_CALL( func( mat->data.ptr, mat_step, size, mean.val, sdv.val ));
 733         }
 734         else
 735         {
 736             CvFunc2DnC_1A2P func = (CvFunc2DnC_1A2P)
 737                 (meansdvcoi_tab.fn_2d[CV_MAT_DEPTH(type)]);
 738
 739             if( !func )
 740                 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
 741
 742             IPPI_CALL( func( mat->data.ptr, mat_step, size,
 743                              CV_MAT_CN(type), coi, mean.val, sdv.val ));
 744         }
 745     }
 746     else
 747     {
 748         CV_CALL( matmask = cvGetMat( matmask, &maskstub ));
 749
 750         mask_step = matmask->step;
 751
 752         if( !CV_IS_MASK_ARR( matmask ))
 753             CV_ERROR( CV_StsBadMask, "" );
 754
 755         if( !CV_ARE_SIZES_EQ( mat, matmask ))
 756             CV_ERROR( CV_StsUnmatchedSizes, "" );
 757
 758         if( CV_IS_MAT_CONT( mat->type & matmask->type ))
 759         {
 760             size.width *= size.height;
 761             size.height = 1;
 762             mat_step = mask_step = CV_STUB_STEP;
 763         }
 764
 765         if( CV_MAT_CN(type) == 1 || coi == 0 )
 766         {
 767             CvFunc2D_2A2P func = (CvFunc2D_2A2P)(meansdvmask_tab.fn_2d[type]);
 768
 769             if( !func )
 770                 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
 771
 772             IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
 773                              mask_step, size, mean.val, sdv.val ));
 774         }
 775         else
 776         {
 777             CvFunc2DnC_2A2P func = (CvFunc2DnC_2A2P)
 778                 (meansdvmaskcoi_tab.fn_2d[CV_MAT_DEPTH(type)]);
 779
 780             if( !func )
 781                 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
 782
 783             IPPI_CALL( func( mat->data.ptr, mat_step,
 784                              matmask->data.ptr, mask_step,
 785                              size, CV_MAT_CN(type), coi, mean.val, sdv.val ));
 786         }
 787     }
 788
 789     __END__;
 790
 791     if( _mean )
 792         *_mean = mean;
 793
 794     if( _sdv )
 795         *_sdv = sdv;
 796 }
 797
 798
 799 /*  End of file  */