cvmean.cpp.svn-base

来自「非结构化路识别」· SVN-BASE 代码 · 共 381 行 · 第 1/2 页

#define ICV_MEAN_ENTRY_FLT( sumtype ) \
    float  maskTab[] = { 1.f, 0.f }; \
    sumtype sum[4] = {0,0,0,0};      \
    int pix = 0


#define ICV_MEAN_EXIT(cn)                  \
{                                         \
    double scale = pix ? 1./pix : 0;      \
    for( int k = 0; k < cn; k++ )         \
        mean[k] = sum[k]*scale;           \
}                                         \
return CV_OK;


#define ICV_IMPL_MEAN_FUNC_2D( _mask_op_, _entry_, _exit_,          \
                              flavor, cn, srctype, sumtype, acctype)\
IPCVAPI_IMPL( CvStatus, icvMean_##flavor##_C##cn##MR,               \
                          ( const srctype* src, int step,           \
                            const uchar* mask, int maskStep,        \
                            CvSize size, double* mean ))            \
{                                                                   \
    _entry_( sumtype );                                             \
                                                                    \
    for( ; size.height--;                                           \
         (char*&)src += step, (char*&)mask += maskStep )            \
    {                                                               \
        ICV_IMPL_MEAN_1D_CASE_C##cn( _mask_op_, acctype, src, mask, \
                                    size.width, sum, pix );         \
    }                                                               \
                                                                    \
    _exit_(cn);                                                     \
}


#define ICV_IMPL_MEAN_FUNC_2D_COI( _mask_op_, _entry_, _exit_,      \
                                  flavor, srctype, sumtype, acctype)\
IPCVAPI_IMPL( CvStatus, icvMean_##flavor##_CnCMR,                   \
                      ( const srctype* src, int step,               \
                        const uchar* mask, int maskStep,            \
                        CvSize size, int cn, int coi, double* mean))\
{                                                                   \
    _entry_( sumtype );                                             \
    (src) += coi - 1;                                               \
                                                                    \
    for( ; size.height--;                                           \
         (char*&)src += step, (char*&)mask += maskStep )            \
    {                                                               \
        ICV_IMPL_MEAN_1D_CASE_COI( _mask_op_, acctype, src, mask,   \
                                  size.width, sum, pix, cn );       \
    }                                                               \
                                                                    \
    mean[0] = sum[0]*(pix ? 1./pix : 0);                            \
                                                                    \
    return CV_OK;                                                   \
}


#define ICV_IMPL_MEAN_ALL( flavor, srctype, sumtype, acctype )        \
    ICV_IMPL_MEAN_FUNC_2D( CV_AND, ICV_MEAN_ENTRY, ICV_MEAN_EXIT,     \
                           flavor, 1, srctype, sumtype, acctype )     \
    ICV_IMPL_MEAN_FUNC_2D( CV_AND, ICV_MEAN_ENTRY, ICV_MEAN_EXIT,     \
                           flavor, 2, srctype, sumtype, acctype )     \
    ICV_IMPL_MEAN_FUNC_2D( CV_AND, ICV_MEAN_ENTRY, ICV_MEAN_EXIT,     \
                           flavor, 3, srctype, sumtype, acctype )     \
    ICV_IMPL_MEAN_FUNC_2D( CV_AND, ICV_MEAN_ENTRY, ICV_MEAN_EXIT,     \
                           flavor, 4, srctype, sumtype, acctype )     \
    ICV_IMPL_MEAN_FUNC_2D_COI( CV_AND, ICV_MEAN_ENTRY, ICV_MEAN_EXIT, \
                               flavor, srctype, sumtype, acctype )


#define ICV_IMPL_MEAN_ALL_FLT( flavor, srctype, sumtype, acctype )              \
    ICV_IMPL_MEAN_FUNC_2D( CV_MULMASK1, ICV_MEAN_ENTRY_FLT, ICV_MEAN_EXIT,      \
                           flavor, 1, srctype, sumtype, acctype )               \
    ICV_IMPL_MEAN_FUNC_2D( CV_MULMASK1, ICV_MEAN_ENTRY_FLT, ICV_MEAN_EXIT,      \
                           flavor, 2, srctype, sumtype, acctype )               \
    ICV_IMPL_MEAN_FUNC_2D( CV_MULMASK1, ICV_MEAN_ENTRY_FLT, ICV_MEAN_EXIT,      \
                           flavor, 3, srctype, sumtype, acctype )               \
    ICV_IMPL_MEAN_FUNC_2D( CV_MULMASK1, ICV_MEAN_ENTRY_FLT, ICV_MEAN_EXIT,      \
                           flavor, 4, srctype, sumtype, acctype )               \
    ICV_IMPL_MEAN_FUNC_2D_COI( CV_MULMASK1, ICV_MEAN_ENTRY_FLT, ICV_MEAN_EXIT,  \
                               flavor, srctype, sumtype, acctype )

ICV_IMPL_MEAN_ALL( 8u, uchar, int64, int )
ICV_IMPL_MEAN_ALL( 8s, char, int64, int )
ICV_IMPL_MEAN_ALL( 16s, short, int64, int )
ICV_IMPL_MEAN_ALL( 32s, int, int64, int64 )
ICV_IMPL_MEAN_ALL_FLT( 32f, float, double, double )
ICV_IMPL_MEAN_ALL_FLT( 64f, double, double, double )

CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean, MR )
CV_DEF_INIT_FUNC_TAB_2D( Mean, CnCMR )

CV_IMPL  CvScalar
cvAvg( const void* img, const void* mask )
{
    CvScalar mean = {{0,0,0,0}};

    static CvBigFuncTable mean_tab;
    static CvFuncTable meancoi_tab;
    static int inittab = 0;

    CV_FUNCNAME("cvAvg");

    __BEGIN__;

    CvSize size;
    double scale;

    if( !mask )
    {
        CV_CALL( mean = cvSum(img));
        cvGetRawData( img, 0, 0, &size );

        size.width *= size.height;
        scale = size.width ? 1./size.width : 0;

        mean.val[0] *= scale;
        mean.val[1] *= scale;
        mean.val[2] *= scale;
        mean.val[3] *= scale;
    }
    else
    {
        int type, coi = 0;
        int mat_step, mask_step;

        CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;

        if( !inittab )
        {
            icvInitMeanMRTable( &mean_tab );
            icvInitMeanCnCMRTable( &meancoi_tab );
            inittab = 1;
        }

        CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
        CV_CALL( matmask = cvGetMat( matmask, &maskstub ));

        if( !CV_IS_MASK_ARR( matmask) )
            CV_ERROR( CV_StsBadMask, "" );

        if( !CV_ARE_SIZES_EQ( mat, matmask ) )
            CV_ERROR( CV_StsUnmatchedSizes, "" );

        type = CV_MAT_TYPE( mat->type );
        size = icvGetMatSize( mat );

        mat_step = mat->step;
        mask_step = matmask->step;

        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_2A1P func = (CvFunc2D_2A1P)(mean_tab.fn_2d[type]);

            if( !func )
                CV_ERROR( CV_StsBadArg, icvUnsupportedFormat );

            IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
                             mask_step, size, mean.val ));
        }
        else
        {
            CvFunc2DnC_2A1P func = (CvFunc2DnC_2A1P)(
                meancoi_tab.fn_2d[CV_MAT_DEPTH(type)]);

            if( !func )
                CV_ERROR( CV_StsBadArg, icvUnsupportedFormat );

            IPPI_CALL( func( mat->data.ptr, mat->step,
                             matmask->data.ptr, matmask->step,
                             size, CV_MAT_CN(type), coi, mean.val ));
        }
    }

    __END__;

    return  mean;
}

/*  End of file  */