cxnorm.cpp

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

ICV_DEF_NORM_FUNC_ALL_C( 8u, CV_NOP, CV_IABS, uchar, int )
ICV_DEF_NORM_FUNC_ALL_C( 16u, CV_NOP, CV_IABS, ushort, int )
ICV_DEF_NORM_FUNC_ALL_C( 16s, CV_IABS, CV_IABS, short, int )
// there is no protection from overflow
// (otherwise we had to do everything in int64's or double's)
ICV_DEF_NORM_FUNC_ALL_C( 32s, CV_IABS, CV_IABS, int, int )
ICV_DEF_NORM_FUNC_ALL_C( 32f, fabs, fabs, float, double )
ICV_DEF_NORM_FUNC_ALL_C( 64f, fabs, fabs, double, double )

#define ICV_DEF_NORM_FUNC_ALL_L1( flavor, _abs_, _abs_diff_, hintp_func, nohint_func,\
                                  arrtype, normtype, worktype, block_size )         \
                                                                                    \
ICV_DEF_NORM_##hintp_func##_FUNC_2D( icvNorm_L1_##flavor##_C1R,                     \
    _abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )                \
                                                                                    \
ICV_DEF_NORM_##nohint_func##_FUNC_2D_COI( icvNorm_L1_##flavor##_CnCR,               \
    _abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )                \
                                                                                    \
ICV_DEF_NORM_DIFF_##hintp_func##_FUNC_2D( icvNormDiff_L1_##flavor##_C1R,            \
    _abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )           \
                                                                                    \
ICV_DEF_NORM_DIFF_##nohint_func##_FUNC_2D_COI( icvNormDiff_L1_##flavor##_CnCR,      \
    _abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )           \
                                                                                    \
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D( icvNorm_L1_##flavor##_C1MR,              \
    _abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )                \
                                                                                    \
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D_COI( icvNorm_L1_##flavor##_CnCMR,         \
    _abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )                \
                                                                                    \
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D( icvNormDiff_L1_##flavor##_C1MR,     \
    _abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )           \
                                                                                    \
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D_COI( icvNormDiff_L1_##flavor##_CnCMR,\
    _abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )


ICV_DEF_NORM_FUNC_ALL_L1( 8u, CV_NOP, CV_IABS, NOHINT_BLOCK, NOHINT_BLOCK,
                          uchar, int64, int, 1 << 23 )
ICV_DEF_NORM_FUNC_ALL_L1( 16u, CV_NOP, CV_IABS, NOHINT_BLOCK, NOHINT_BLOCK,
                          ushort, int64, int, 1 << 15 )
ICV_DEF_NORM_FUNC_ALL_L1( 16s, CV_IABS, CV_IABS, NOHINT_BLOCK, NOHINT_BLOCK,
                          short, int64, int, 1 << 15 )
// there is no protection from overflow on abs() stage.
// (otherwise we had to do everything in int64's or double's)
ICV_DEF_NORM_FUNC_ALL_L1( 32s, fabs, fabs, NOHINT, NOHINT,
                          int, double, double, INT_MAX )
ICV_DEF_NORM_FUNC_ALL_L1( 32f, fabs, fabs, HINT, NOHINT,
                          float, double, double, INT_MAX )
ICV_DEF_NORM_FUNC_ALL_L1( 64f, fabs, fabs, NOHINT, NOHINT,
                          double, double, double, INT_MAX )


#define ICV_DEF_NORM_FUNC_ALL_L2( flavor, hintp_func, nohint_func, arrtype,         \
                                  normtype, worktype, block_size, sqr_macro )       \
                                                                                    \
ICV_DEF_NORM_##hintp_func##_FUNC_2D( icvNorm_L2_##flavor##_C1R,                     \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_##nohint_func##_FUNC_2D_COI( icvNorm_L2_##flavor##_CnCR,               \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_DIFF_##hintp_func##_FUNC_2D( icvNormDiff_L2_##flavor##_C1R,            \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_DIFF_##nohint_func##_FUNC_2D_COI( icvNormDiff_L2_##flavor##_CnCR,      \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D( icvNorm_L2_##flavor##_C1MR,              \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D_COI( icvNorm_L2_##flavor##_CnCMR,         \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D( icvNormDiff_L2_##flavor##_C1MR,     \
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )              \
                                                                                    \
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D_COI( icvNormDiff_L2_##flavor##_CnCMR,\
    sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )


ICV_DEF_NORM_FUNC_ALL_L2( 8u, NOHINT_BLOCK, NOHINT_BLOCK, uchar,
                          int64, int, 1 << 15, CV_SQR_8U )
ICV_DEF_NORM_FUNC_ALL_L2( 16u, NOHINT, NOHINT, ushort,
                          double, double, INT_MAX, CV_SQR )
ICV_DEF_NORM_FUNC_ALL_L2( 16s, NOHINT, NOHINT, short,
                          double, double, INT_MAX, CV_SQR )
// there is no protection from overflow on abs() stage.
// (otherwise we had to do everything in int64's or double's)
ICV_DEF_NORM_FUNC_ALL_L2( 32s, NOHINT, NOHINT, int,
                          double, double, INT_MAX, CV_SQR )
ICV_DEF_NORM_FUNC_ALL_L2( 32f, HINT, NOHINT, float,
                          double, double, INT_MAX, CV_SQR )
ICV_DEF_NORM_FUNC_ALL_L2( 64f, NOHINT, NOHINT, double,
                          double, double, INT_MAX, CV_SQR )


#define ICV_DEF_INIT_NORM_TAB_2D( FUNCNAME, FLAG )              \
static void icvInit##FUNCNAME##FLAG##Table( CvFuncTable* tab )  \
{                                                               \
    tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u_##FLAG;       \
    tab->fn_2d[CV_8S] = 0;                                      \
    tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_##FLAG;     \
    tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_##FLAG;     \
    tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s_##FLAG;     \
    tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_##FLAG;     \
    tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_##FLAG;     \
}

ICV_DEF_INIT_NORM_TAB_2D( Norm_Inf, C1R )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L1, C1R )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L2, C1R )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_Inf, C1R )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L1, C1R )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L2, C1R )

ICV_DEF_INIT_NORM_TAB_2D( Norm_Inf, CnCR )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L1, CnCR )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L2, CnCR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_Inf, CnCR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L1, CnCR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L2, CnCR )

ICV_DEF_INIT_NORM_TAB_2D( Norm_Inf, C1MR )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L1, C1MR )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L2, C1MR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_Inf, C1MR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L1, C1MR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L2, C1MR )

ICV_DEF_INIT_NORM_TAB_2D( Norm_Inf, CnCMR )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L1, CnCMR )
ICV_DEF_INIT_NORM_TAB_2D( Norm_L2, CnCMR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_Inf, CnCMR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L1, CnCMR )
ICV_DEF_INIT_NORM_TAB_2D( NormDiff_L2, CnCMR )


static void icvInitNormTabs( CvFuncTable* norm_tab, CvFuncTable* normmask_tab )
{
    icvInitNorm_InfC1RTable( &norm_tab[0] );
    icvInitNorm_L1C1RTable( &norm_tab[1] );
    icvInitNorm_L2C1RTable( &norm_tab[2] );
    icvInitNormDiff_InfC1RTable( &norm_tab[3] );
    icvInitNormDiff_L1C1RTable( &norm_tab[4] );
    icvInitNormDiff_L2C1RTable( &norm_tab[5] );

    icvInitNorm_InfCnCRTable( &norm_tab[6] );
    icvInitNorm_L1CnCRTable( &norm_tab[7] );
    icvInitNorm_L2CnCRTable( &norm_tab[8] );
    icvInitNormDiff_InfCnCRTable( &norm_tab[9] );
    icvInitNormDiff_L1CnCRTable( &norm_tab[10] );
    icvInitNormDiff_L2CnCRTable( &norm_tab[11] );

    icvInitNorm_InfC1MRTable( &normmask_tab[0] );
    icvInitNorm_L1C1MRTable( &normmask_tab[1] );
    icvInitNorm_L2C1MRTable( &normmask_tab[2] );
    icvInitNormDiff_InfC1MRTable( &normmask_tab[3] );
    icvInitNormDiff_L1C1MRTable( &normmask_tab[4] );
    icvInitNormDiff_L2C1MRTable( &normmask_tab[5] );

    icvInitNorm_InfCnCMRTable( &normmask_tab[6] );
    icvInitNorm_L1CnCMRTable( &normmask_tab[7] );
    icvInitNorm_L2CnCMRTable( &normmask_tab[8] );
    icvInitNormDiff_InfCnCMRTable( &normmask_tab[9] );
    icvInitNormDiff_L1CnCMRTable( &normmask_tab[10] );
    icvInitNormDiff_L2CnCMRTable( &normmask_tab[11] );
}


CV_IMPL  double
cvNorm( const void* imgA, const void* imgB, int normType, const void* mask )
{
    static CvFuncTable norm_tab[12];
    static CvFuncTable normmask_tab[12];
    static int inittab = 0;

    double  norm = 0, norm_diff = 0;

    CV_FUNCNAME("cvNorm");

    __BEGIN__;

    int type, depth, cn, is_relative;
    CvSize size;
    CvMat stub1, *mat1 = (CvMat*)imgB;
    CvMat stub2, *mat2 = (CvMat*)imgA;
    int mat2_flag = CV_MAT_CONT_FLAG;
    int mat1_step, mat2_step, mask_step = 0;
    int coi = 0, coi2 = 0;

    if( !mat1 )
    {
        mat1 = mat2;
        mat2 = 0;
    }

    is_relative = mat2 && (normType & CV_RELATIVE);
    normType &= ~CV_RELATIVE;

    switch( normType )
    {
    case CV_C:
    case CV_L1:
    case CV_L2:
    case CV_DIFF_C:
    case CV_DIFF_L1:
    case CV_DIFF_L2:
        normType = (normType & 7) >> 1;
        break;
    default:
        CV_ERROR( CV_StsBadFlag, "" );
    }

    /* light variant */
    if( CV_IS_MAT(mat1) && (!mat2 || CV_IS_MAT(mat2)) && !mask )
    {
        if( mat2 )
        {
            if( !CV_ARE_TYPES_EQ( mat1, mat2 ))
                CV_ERROR( CV_StsUnmatchedFormats, "" );

            if( !CV_ARE_SIZES_EQ( mat1, mat2 ))
                CV_ERROR( CV_StsUnmatchedSizes, "" );

            mat2_flag = mat2->type;
        }

        size = cvGetMatSize( mat1 );
        type = CV_MAT_TYPE(mat1->type);
        depth = CV_MAT_DEPTH(type);
        cn = CV_MAT_CN(type);

        if( CV_IS_MAT_CONT( mat1->type & mat2_flag ))
        {
            size.width *= size.height;

            if( size.width <= CV_MAX_INLINE_MAT_OP_SIZE && normType == 2 /* CV_L2 */ )
            {
                if( depth == CV_32F )
                {
                    const float* src1data = mat1->data.fl;
                    int size0 = size.width *= cn;
                
                    if( !mat2 || is_relative )
                    {
                        do
                        {
                            double t = src1data[size.width-1];
                            norm += t*t;
                        }
                        while( --size.width );
                    }

                    if( mat2 )
                    {
                        const float* src2data = mat2->data.fl;
                        size.width = size0;

                        do
                        {
                            double t = src1data[size.width-1] - src2data[size.width-1];
                            norm_diff += t*t;