+++ /dev/null
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-// By downloading, copying, installing or using the software you agree to this license.
-// If you do not agree to this license, do not download, install,
-// copy or use the software.
-//
-//
-// Intel License Agreement
-// For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// * Redistribution's of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistribution's in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// * The name of Intel Corporation may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "_cxcore.h"
-
-/****************************************************************************************\
-* Mean and StdDev calculation *
-\****************************************************************************************/
-
-#define ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, \
- sqr_macro, len, cn ) \
- for( ; x <= (len) - 4*(cn); x += 4*(cn))\
- { \
- worktype t0 = src[x]; \
- worktype t1 = src[x + (cn)]; \
- \
- s0 += t0 + t1; \
- sq0 += (sqsumtype)(sqr_macro(t0)) + \
- (sqsumtype)(sqr_macro(t1)); \
- \
- t0 = src[x + 2*(cn)]; \
- t1 = src[x + 3*(cn)]; \
- \
- s0 += t0 + t1; \
- sq0 += (sqsumtype)(sqr_macro(t0)) + \
- (sqsumtype)(sqr_macro(t1)); \
- } \
- \
- for( ; x < (len); x += (cn) ) \
- { \
- worktype t0 = src[x]; \
- \
- s0 += t0; \
- sq0 += (sqsumtype)(sqr_macro(t0)); \
- }
-
-
-#define ICV_MEAN_SDV_CASE_C1( worktype, sqsumtype, sqr_macro, len ) \
- ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, sqr_macro, len, 1 )
-
-
-#define ICV_MEAN_SDV_CASE_C2( worktype, sqsumtype, \
- sqr_macro, len ) \
- for( ; x < (len); x += 2 ) \
- { \
- worktype t0 = (src)[x]; \
- worktype t1 = (src)[x + 1]; \
- \
- s0 += t0; \
- sq0 += (sqsumtype)(sqr_macro(t0)); \
- s1 += t1; \
- sq1 += (sqsumtype)(sqr_macro(t1)); \
- }
-
-
-#define ICV_MEAN_SDV_CASE_C3( worktype, sqsumtype, \
- sqr_macro, len ) \
- for( ; x < (len); x += 3 ) \
- { \
- worktype t0 = (src)[x]; \
- worktype t1 = (src)[x + 1]; \
- worktype t2 = (src)[x + 2]; \
- \
- s0 += t0; \
- sq0 += (sqsumtype)(sqr_macro(t0)); \
- s1 += t1; \
- sq1 += (sqsumtype)(sqr_macro(t1)); \
- s2 += t2; \
- sq2 += (sqsumtype)(sqr_macro(t2)); \
- }
-
-
-#define ICV_MEAN_SDV_CASE_C4( worktype, sqsumtype, \
- sqr_macro, len ) \
- for( ; x < (len); x += 4 ) \
- { \
- worktype t0 = (src)[x]; \
- worktype t1 = (src)[x + 1]; \
- \
- s0 += t0; \
- sq0 += (sqsumtype)(sqr_macro(t0)); \
- s1 += t1; \
- sq1 += (sqsumtype)(sqr_macro(t1)); \
- \
- t0 = (src)[x + 2]; \
- t1 = (src)[x + 3]; \
- \
- s2 += t0; \
- sq2 += (sqsumtype)(sqr_macro(t0)); \
- s3 += t1; \
- sq3 += (sqsumtype)(sqr_macro(t1)); \
- }
-
-
-#define ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, \
- sqr_macro, len, cn ) \
- for( ; x <= (len) - 4; x += 4 ) \
- { \
- worktype t0; \
- if( mask[x] ) \
- { \
- t0 = src[x*(cn)]; pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- } \
- \
- if( mask[x+1] ) \
- { \
- t0 = src[(x+1)*(cn)]; pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- } \
- \
- if( mask[x+2] ) \
- { \
- t0 = src[(x+2)*(cn)]; pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- } \
- \
- if( mask[x+3] ) \
- { \
- t0 = src[(x+3)*(cn)]; pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- } \
- } \
- \
- for( ; x < (len); x++ ) \
- { \
- if( mask[x] ) \
- { \
- worktype t0 = src[x*(cn)]; pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- } \
- }
-
-
-#define ICV_MEAN_SDV_MASK_CASE_C1( worktype, sqsumtype, sqr_macro, len ) \
- ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, sqr_macro, len, 1 )
-
-
-#define ICV_MEAN_SDV_MASK_CASE_C2( worktype, sqsumtype,\
- sqr_macro, len ) \
- for( ; x < (len); x++ ) \
- { \
- if( mask[x] ) \
- { \
- worktype t0 = src[x*2]; \
- worktype t1 = src[x*2+1]; \
- pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- s1 += t1; \
- sq1 += sqsumtype(sqr_macro(t1)); \
- } \
- }
-
-
-#define ICV_MEAN_SDV_MASK_CASE_C3( worktype, sqsumtype,\
- sqr_macro, len ) \
- for( ; x < (len); x++ ) \
- { \
- if( mask[x] ) \
- { \
- worktype t0 = src[x*3]; \
- worktype t1 = src[x*3+1]; \
- worktype t2 = src[x*3+2]; \
- pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- s1 += t1; \
- sq1 += sqsumtype(sqr_macro(t1)); \
- s2 += t2; \
- sq2 += sqsumtype(sqr_macro(t2)); \
- } \
- }
-
-
-#define ICV_MEAN_SDV_MASK_CASE_C4( worktype, sqsumtype,\
- sqr_macro, len ) \
- for( ; x < (len); x++ ) \
- { \
- if( mask[x] ) \
- { \
- worktype t0 = src[x*4]; \
- worktype t1 = src[x*4+1]; \
- pix++; \
- s0 += t0; \
- sq0 += sqsumtype(sqr_macro(t0)); \
- s1 += t1; \
- sq1 += sqsumtype(sqr_macro(t1)); \
- t0 = src[x*4+2]; \
- t1 = src[x*4+3]; \
- s2 += t0; \
- sq2 += sqsumtype(sqr_macro(t0)); \
- s3 += t1; \
- sq3 += sqsumtype(sqr_macro(t1)); \
- } \
- }
-
-
-////////////////////////////////////// entry macros //////////////////////////////////////
-
-#define ICV_MEAN_SDV_ENTRY_COMMON() \
- int pix; \
- double scale, tmp; \
- step /= sizeof(src[0])
-
-#define ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ) \
- sumtype s0 = 0; \
- sqsumtype sq0 = 0; \
- ICV_MEAN_SDV_ENTRY_COMMON()
-
-#define ICV_MEAN_SDV_ENTRY_C2( sumtype, sqsumtype ) \
- sumtype s0 = 0, s1 = 0; \
- sqsumtype sq0 = 0, sq1 = 0; \
- ICV_MEAN_SDV_ENTRY_COMMON()
-
-#define ICV_MEAN_SDV_ENTRY_C3( sumtype, sqsumtype ) \
- sumtype s0 = 0, s1 = 0, s2 = 0; \
- sqsumtype sq0 = 0, sq1 = 0, sq2 = 0; \
- ICV_MEAN_SDV_ENTRY_COMMON()
-
-#define ICV_MEAN_SDV_ENTRY_C4( sumtype, sqsumtype ) \
- sumtype s0 = 0, s1 = 0, s2 = 0, s3 = 0; \
- sqsumtype sq0 = 0, sq1 = 0, sq2 = 0, sq3 = 0; \
- ICV_MEAN_SDV_ENTRY_COMMON()
-
-
-#define ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size ) \
- int remaining = block_size; \
- ICV_MEAN_SDV_ENTRY_COMMON()
-
-#define ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype, \
- worktype, sqworktype, block_size ) \
- sumtype sum0 = 0; \
- sqsumtype sqsum0 = 0; \
- worktype s0 = 0; \
- sqworktype sq0 = 0; \
- ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
-
-#define ICV_MEAN_SDV_ENTRY_BLOCK_C2( sumtype, sqsumtype, \
- worktype, sqworktype, block_size ) \
- sumtype sum0 = 0, sum1 = 0; \
- sqsumtype sqsum0 = 0, sqsum1 = 0; \
- worktype s0 = 0, s1 = 0; \
- sqworktype sq0 = 0, sq1 = 0; \
- ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
-
-#define ICV_MEAN_SDV_ENTRY_BLOCK_C3( sumtype, sqsumtype, \
- worktype, sqworktype, block_size ) \
- sumtype sum0 = 0, sum1 = 0, sum2 = 0; \
- sqsumtype sqsum0 = 0, sqsum1 = 0, sqsum2 = 0; \
- worktype s0 = 0, s1 = 0, s2 = 0; \
- sqworktype sq0 = 0, sq1 = 0, sq2 = 0; \
- ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
-
-#define ICV_MEAN_SDV_ENTRY_BLOCK_C4( sumtype, sqsumtype, \
- worktype, sqworktype, block_size ) \
- sumtype sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0; \
- sqsumtype sqsum0 = 0, sqsum1 = 0, sqsum2 = 0, sqsum3 = 0; \
- worktype s0 = 0, s1 = 0, s2 = 0, s3 = 0; \
- sqworktype sq0 = 0, sq1 = 0, sq2 = 0, sq3 = 0; \
- ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
-
-
-/////////////////////////////////////// exit macros //////////////////////////////////////
-
-#define ICV_MEAN_SDV_EXIT_COMMON() \
- scale = pix ? 1./pix : 0
-
-#define ICV_MEAN_SDV_EXIT_CN( total, sqtotal, idx ) \
- ICV_MEAN_SDV_EXIT_COMMON(); \
- mean[idx] = tmp = scale*(double)total##idx; \
- tmp = scale*(double)sqtotal##idx - tmp*tmp; \
- sdv[idx] = sqrt(MAX(tmp,0.))
-
-#define ICV_MEAN_SDV_EXIT_C1( total, sqtotal ) \
- ICV_MEAN_SDV_EXIT_COMMON(); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 )
-
-#define ICV_MEAN_SDV_EXIT_C2( total, sqtotal ) \
- ICV_MEAN_SDV_EXIT_COMMON(); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 ); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 )
-
-#define ICV_MEAN_SDV_EXIT_C3( total, sqtotal ) \
- ICV_MEAN_SDV_EXIT_COMMON(); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 ); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 ); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 2 )
-
-#define ICV_MEAN_SDV_EXIT_C4( total, sqtotal ) \
- ICV_MEAN_SDV_EXIT_COMMON(); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 ); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 ); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 2 ); \
- ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 3 )
-
-////////////////////////////////////// update macros /////////////////////////////////////
-
-#define ICV_MEAN_SDV_UPDATE_COMMON( block_size )\
- remaining = block_size
-
-#define ICV_MEAN_SDV_UPDATE_C1( block_size ) \
- ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
- sum0 += s0; sqsum0 += sq0; \
- s0 = 0; sq0 = 0
-
-#define ICV_MEAN_SDV_UPDATE_C2( block_size ) \
- ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
- sum0 += s0; sqsum0 += sq0; \
- sum1 += s1; sqsum1 += sq1; \
- s0 = s1 = 0; sq0 = sq1 = 0
-
-#define ICV_MEAN_SDV_UPDATE_C3( block_size ) \
- ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
- sum0 += s0; sqsum0 += sq0; \
- sum1 += s1; sqsum1 += sq1; \
- sum2 += s2; sqsum2 += sq2; \
- s0 = s1 = s2 = 0; sq0 = sq1 = sq2 = 0
-
-#define ICV_MEAN_SDV_UPDATE_C4( block_size ) \
- ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
- sum0 += s0; sqsum0 += sq0; \
- sum1 += s1; sqsum1 += sq1; \
- sum2 += s2; sqsum2 += sq2; \
- sum3 += s3; sqsum3 += sq3; \
- s0 = s1 = s2 = s3 = 0; sq0 = sq1 = sq2 = sq3 = 0
-
-
-
-#define ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, cn, arrtype, \
- sumtype, sqsumtype, worktype, \
- sqworktype, block_size, sqr_macro ) \
-IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##R, \
- ( const arrtype* src, int step, \
- CvSize size, double* mean, double* sdv ), \
- (src, step, size, mean, sdv) ) \
-{ \
- ICV_MEAN_SDV_ENTRY_BLOCK_C##cn( sumtype, sqsumtype, \
- worktype, sqworktype, (block_size)*(cn) ); \
- pix = size.width * size.height; \
- size.width *= (cn); \
- \
- for( ; size.height--; src += step ) \
- { \
- int x = 0; \
- while( x < size.width ) \
- { \
- int limit = MIN( remaining, size.width - x ); \
- remaining -= limit; \
- limit += x; \
- ICV_MEAN_SDV_CASE_C##cn( worktype, sqworktype, \
- sqr_macro, limit ); \
- if( remaining == 0 ) \
- { \
- ICV_MEAN_SDV_UPDATE_C##cn( (block_size)*(cn) ); \
- } \
- } \
- } \
- \
- ICV_MEAN_SDV_UPDATE_C##cn(0); \
- ICV_MEAN_SDV_EXIT_C##cn( sum, sqsum ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_FUNC_2D( flavor, cn, arrtype, \
- sumtype, sqsumtype, worktype ) \
-IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##R, \
- ( const arrtype* src, int step, \
- CvSize size, double* mean, double* sdv ), \
- (src, step, size, mean, sdv) ) \
-{ \
- ICV_MEAN_SDV_ENTRY_C##cn( sumtype, sqsumtype ); \
- pix = size.width * size.height; \
- size.width *= (cn); \
- \
- for( ; size.height--; src += step ) \
- { \
- int x = 0; \
- ICV_MEAN_SDV_CASE_C##cn( worktype, sqsumtype, \
- CV_SQR, size.width ); \
- } \
- \
- ICV_MEAN_SDV_EXIT_C##cn( s, sq ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D_COI( flavor, arrtype, \
- sumtype, sqsumtype, worktype, \
- sqworktype, block_size, sqr_macro ) \
-static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCR \
- ( const arrtype* src, int step, \
- CvSize size, int cn, int coi, \
- double* mean, double* sdv ) \
-{ \
- ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype, \
- worktype, sqworktype, (block_size)*(cn) ); \
- pix = size.width * size.height; \
- size.width *= (cn); \
- src += coi - 1; \
- \
- for( ; size.height--; src += step ) \
- { \
- int x = 0; \
- while( x < size.width ) \
- { \
- int limit = MIN( remaining, size.width - x ); \
- remaining -= limit; \
- limit += x; \
- ICV_MEAN_SDV_COI_CASE( worktype, sqworktype, \
- sqr_macro, limit, cn); \
- if( remaining == 0 ) \
- { \
- ICV_MEAN_SDV_UPDATE_C1( (block_size)*(cn) ); \
- } \
- } \
- } \
- \
- ICV_MEAN_SDV_UPDATE_C1(0); \
- ICV_MEAN_SDV_EXIT_C1( sum, sqsum ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_FUNC_2D_COI( flavor, arrtype, \
- sumtype, sqsumtype, worktype )\
-static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCR \
- ( const arrtype* src, int step, CvSize size,\
- int cn, int coi, double* mean, double* sdv )\
-{ \
- ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ); \
- pix = size.width * size.height; \
- size.width *= (cn); \
- src += coi - 1; \
- \
- for( ; size.height--; src += step ) \
- { \
- int x = 0; \
- ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, \
- CV_SQR, size.width, cn ); \
- } \
- \
- ICV_MEAN_SDV_EXIT_C1( s, sq ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, cn, \
- arrtype, sumtype, sqsumtype, worktype, \
- sqworktype, block_size, sqr_macro ) \
-IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##MR, \
- ( const arrtype* src, int step, \
- const uchar* mask, int maskstep, \
- CvSize size, double* mean, double* sdv ), \
- (src, step, mask, maskstep, size, mean, sdv))\
-{ \
- ICV_MEAN_SDV_ENTRY_BLOCK_C##cn( sumtype, sqsumtype, \
- worktype, sqworktype, block_size ); \
- pix = 0; \
- \
- for( ; size.height--; src += step, mask += maskstep ) \
- { \
- int x = 0; \
- while( x < size.width ) \
- { \
- int limit = MIN( remaining, size.width - x ); \
- remaining -= limit; \
- limit += x; \
- ICV_MEAN_SDV_MASK_CASE_C##cn( worktype, sqworktype, \
- sqr_macro, limit ); \
- if( remaining == 0 ) \
- { \
- ICV_MEAN_SDV_UPDATE_C##cn( block_size ); \
- } \
- } \
- } \
- \
- ICV_MEAN_SDV_UPDATE_C##cn(0); \
- ICV_MEAN_SDV_EXIT_C##cn( sum, sqsum ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_MASK_FUNC_2D( flavor, cn, arrtype, \
- sumtype, sqsumtype, worktype)\
-IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##MR, \
- ( const arrtype* src, int step, \
- const uchar* mask, int maskstep, \
- CvSize size, double* mean, double* sdv ), \
- (src, step, mask, maskstep, size, mean, sdv))\
-{ \
- ICV_MEAN_SDV_ENTRY_C##cn( sumtype, sqsumtype ); \
- pix = 0; \
- \
- for( ; size.height--; src += step, mask += maskstep ) \
- { \
- int x = 0; \
- ICV_MEAN_SDV_MASK_CASE_C##cn( worktype, sqsumtype, \
- CV_SQR, size.width ); \
- } \
- \
- ICV_MEAN_SDV_EXIT_C##cn( s, sq ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D_COI( flavor, \
- arrtype, sumtype, sqsumtype, worktype, \
- sqworktype, block_size, sqr_macro ) \
-static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCMR \
- ( const arrtype* src, int step, \
- const uchar* mask, int maskstep, \
- CvSize size, int cn, int coi, \
- double* mean, double* sdv ) \
-{ \
- ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype, \
- worktype, sqworktype, block_size ); \
- pix = 0; \
- src += coi - 1; \
- \
- for( ; size.height--; src += step, mask += maskstep ) \
- { \
- int x = 0; \
- while( x < size.width ) \
- { \
- int limit = MIN( remaining, size.width - x ); \
- remaining -= limit; \
- limit += x; \
- ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqworktype, \
- sqr_macro, limit, cn ); \
- if( remaining == 0 ) \
- { \
- ICV_MEAN_SDV_UPDATE_C1( block_size ); \
- } \
- } \
- } \
- \
- ICV_MEAN_SDV_UPDATE_C1(0); \
- ICV_MEAN_SDV_EXIT_C1( sum, sqsum ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_MASK_FUNC_2D_COI( flavor, arrtype, \
- sumtype, sqsumtype, worktype ) \
-static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCMR \
- ( const arrtype* src, int step, \
- const uchar* mask, int maskstep, \
- CvSize size, int cn, int coi, \
- double* mean, double* sdv ) \
-{ \
- ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ); \
- pix = 0; \
- src += coi - 1; \
- \
- for( ; size.height--; src += step, mask += maskstep ) \
- { \
- int x = 0; \
- ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, \
- CV_SQR, size.width, cn ); \
- } \
- \
- ICV_MEAN_SDV_EXIT_C1( s, sq ); \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_MEAN_SDV_BLOCK_ALL( flavor, arrtype, sumtype, sqsumtype,\
- worktype, sqworktype, block_size, sqr_macro)\
-ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 1, arrtype, sumtype, sqsumtype, \
- worktype, sqworktype, block_size, sqr_macro)\
-ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 2, arrtype, sumtype, sqsumtype, \
- worktype, sqworktype, block_size, sqr_macro)\
-ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 3, arrtype, sumtype, sqsumtype, \
- worktype, sqworktype, block_size, sqr_macro)\
-ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 4, arrtype, sumtype, sqsumtype, \
- worktype, sqworktype, block_size, sqr_macro)\
-ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype,\
- worktype, sqworktype, block_size, sqr_macro)\
- \
-ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 1, arrtype, sumtype, \
- sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
-ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 2, arrtype, sumtype, \
- sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
-ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 3, arrtype, sumtype, \
- sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
-ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 4, arrtype, sumtype, \
- sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
-ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D_COI( flavor, arrtype, sumtype, \
- sqsumtype, worktype, sqworktype, block_size, sqr_macro )
-
-#define ICV_DEF_MEAN_SDV_ALL( flavor, arrtype, sumtype, sqsumtype, worktype ) \
-ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 1, arrtype, sumtype, sqsumtype, worktype ) \
-ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 2, arrtype, sumtype, sqsumtype, worktype ) \
-ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 3, arrtype, sumtype, sqsumtype, worktype ) \
-ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 4, arrtype, sumtype, sqsumtype, worktype ) \
-ICV_DEF_MEAN_SDV_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype, worktype ) \
- \
-ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 1, arrtype, sumtype, sqsumtype, worktype) \
-ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 2, arrtype, sumtype, sqsumtype, worktype) \
-ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 3, arrtype, sumtype, sqsumtype, worktype) \
-ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 4, arrtype, sumtype, sqsumtype, worktype) \
-ICV_DEF_MEAN_SDV_MASK_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype, worktype )
-
-
-ICV_DEF_MEAN_SDV_BLOCK_ALL( 8u, uchar, int64, int64, unsigned, unsigned, 1 << 16, CV_SQR_8U )
-ICV_DEF_MEAN_SDV_BLOCK_ALL( 16u, ushort, int64, int64, unsigned, int64, 1 << 16, CV_SQR )
-ICV_DEF_MEAN_SDV_BLOCK_ALL( 16s, short, int64, int64, int, int64, 1 << 16, CV_SQR )
-
-ICV_DEF_MEAN_SDV_ALL( 32s, int, double, double, double )
-ICV_DEF_MEAN_SDV_ALL( 32f, float, double, double, double )
-ICV_DEF_MEAN_SDV_ALL( 64f, double, double, double, double )
-
-#define icvMean_StdDev_8s_C1R 0
-#define icvMean_StdDev_8s_C2R 0
-#define icvMean_StdDev_8s_C3R 0
-#define icvMean_StdDev_8s_C4R 0
-#define icvMean_StdDev_8s_CnCR 0
-
-#define icvMean_StdDev_8s_C1MR 0
-#define icvMean_StdDev_8s_C2MR 0
-#define icvMean_StdDev_8s_C3MR 0
-#define icvMean_StdDev_8s_C4MR 0
-#define icvMean_StdDev_8s_CnCMR 0
-
-CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean_StdDev, R )
-CV_DEF_INIT_FUNC_TAB_2D( Mean_StdDev, CnCR )
-CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean_StdDev, MR )
-CV_DEF_INIT_FUNC_TAB_2D( Mean_StdDev, CnCMR )
-
-CV_IMPL void
-cvAvgSdv( const CvArr* img, CvScalar* _mean, CvScalar* _sdv, const void* mask )
-{
- CvScalar mean = {{0,0,0,0}};
- CvScalar sdv = {{0,0,0,0}};
-
- static CvBigFuncTable meansdv_tab;
- static CvFuncTable meansdvcoi_tab;
- static CvBigFuncTable meansdvmask_tab;
- static CvFuncTable meansdvmaskcoi_tab;
- static int inittab = 0;
-
- CV_FUNCNAME("cvMean_StdDev");
-
- __BEGIN__;
-
- int type, coi = 0;
- int mat_step, mask_step = 0;
- CvSize size;
- CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;
-
- if( !inittab )
- {
- icvInitMean_StdDevRTable( &meansdv_tab );
- icvInitMean_StdDevCnCRTable( &meansdvcoi_tab );
- icvInitMean_StdDevMRTable( &meansdvmask_tab );
- icvInitMean_StdDevCnCMRTable( &meansdvmaskcoi_tab );
- inittab = 1;
- }
-
- if( !CV_IS_MAT(mat) )
- CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
-
- type = CV_MAT_TYPE( mat->type );
-
- if( CV_MAT_CN(type) > 4 && coi == 0 )
- CV_ERROR( CV_StsOutOfRange, "The input array must have at most 4 channels unless COI is set" );
-
- size = cvGetMatSize( mat );
- mat_step = mat->step;
-
- if( !mask )
- {
- if( CV_IS_MAT_CONT( mat->type ))
- {
- size.width *= size.height;
- size.height = 1;
- mat_step = CV_STUB_STEP;
- }
-
- if( CV_MAT_CN(type) == 1 || coi == 0 )
- {
- CvFunc2D_1A2P func = (CvFunc2D_1A2P)(meansdv_tab.fn_2d[type]);
-
- if( !func )
- CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
-
- IPPI_CALL( func( mat->data.ptr, mat_step, size, mean.val, sdv.val ));
- }
- else
- {
- CvFunc2DnC_1A2P func = (CvFunc2DnC_1A2P)
- (meansdvcoi_tab.fn_2d[CV_MAT_DEPTH(type)]);
-
- if( !func )
- CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
-
- IPPI_CALL( func( mat->data.ptr, mat_step, size,
- CV_MAT_CN(type), coi, mean.val, sdv.val ));
- }
- }
- else
- {
- CV_CALL( matmask = cvGetMat( matmask, &maskstub ));
-
- mask_step = matmask->step;
-
- if( !CV_IS_MASK_ARR( matmask ))
- CV_ERROR( CV_StsBadMask, "" );
-
- if( !CV_ARE_SIZES_EQ( mat, matmask ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
-
- if( CV_IS_MAT_CONT( mat->type & matmask->type ))
- {
- size.width *= size.height;
- size.height = 1;
- mat_step = mask_step = CV_STUB_STEP;
- }
-
- if( CV_MAT_CN(type) == 1 || coi == 0 )
- {
- CvFunc2D_2A2P func = (CvFunc2D_2A2P)(meansdvmask_tab.fn_2d[type]);
-
- if( !func )
- CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
-
- IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
- mask_step, size, mean.val, sdv.val ));
- }
- else
- {
- CvFunc2DnC_2A2P func = (CvFunc2DnC_2A2P)
- (meansdvmaskcoi_tab.fn_2d[CV_MAT_DEPTH(type)]);
-
- if( !func )
- CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
-
- IPPI_CALL( func( mat->data.ptr, mat_step,
- matmask->data.ptr, mask_step,
- size, CV_MAT_CN(type), coi, mean.val, sdv.val ));
- }
- }
-
- __END__;
-
- if( _mean )
- *_mean = mean;
-
- if( _sdv )
- *_sdv = sdv;
-}
-
-
-/* End of file */
projects / opencv / blobdiff