cxmeansdv.cpp

opencv库在TI DM6437上的移植,目前包括两个库cv.lib和cxcore.lib的工程

{                                                                   \
    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  */