cvminmaxloc.cpp.svn-base

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

            if( mask[x] != 0 )                                      \
            {                                                       \
                min_loc = max_loc = loc;                            \
                min_val = _cast_macro_((src)[x*(cn)]);              \
                min_val = max_val = _toggle_( min_val );            \
                goto stop_scan;                                     \
            }                                                       \
    }                                                               \
                                                                    \
    stop_scan:;




#define ICV_DEF_MINMAXLOC_MASK_FUNC_2D(_cast_macro_, _toggle_, _fin_cast_macro_,\
                                       _entry_, _exit_, flavor,                 \
                                       srctype, temptype, extrtype )            \
IPCVAPI_IMPL( CvStatus, icvMinMaxIndx_##flavor##_C1MR,                          \
                          ( const srctype* src, int step,                       \
                            const uchar* mask, int maskStep,                    \
                            CvSize size, extrtype* minVal, extrtype* maxVal,    \
                            CvPoint* minLoc, CvPoint* maxLoc ))                 \
{                                                                               \
    _entry_( _cast_macro_, _toggle_, srctype, temptype, 1 );                    \
                                                                                \
    for( ; y < size.height; y++, (char*&)src += step,                           \
                                 (char*&)mask += maskStep )                     \
    {                                                                           \
        for( ; x < width; x++, (loc)++ )                                        \
        {                                                                       \
            temptype val = _cast_macro_((src)[x]);                              \
            int m = (mask)[x] != 0;                                             \
            val = _toggle_(val);                                                \
                                                                                \
            if( val < (min_val) && m )                                          \
            {                                                                   \
                (min_val) = val;                                                \
                (min_loc) = (loc);                                              \
            }                                                                   \
            else if( val > (max_val) && m )                                     \
            {                                                                   \
                (max_val) = val;                                                \
                (max_loc) = (loc);                                              \
            }                                                                   \
        }                                                                       \
        x = 0;                                                                  \
    }                                                                           \
                                                                                \
    _exit_( _toggle_, _fin_cast_macro_ );                                       \
}


#define ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _cast_macro_, _toggle_, _fin_cast_macro_,\
                                     _entry_, _exit_, flavor,                   \
                                     srctype, temptype, extrtype )              \
IPCVAPI_IMPL( CvStatus, icvMinMaxIndx_##flavor##_CnCMR,                         \
                         ( const srctype* src, int step,                        \
                           const uchar* mask, int maskStep,                     \
                           CvSize size, int cn, int coi,                        \
                           extrtype* minVal, extrtype* maxVal,                  \
                           CvPoint* minLoc, CvPoint* maxLoc ))                  \
{                                                                               \
    (src) += coi - 1;                                                           \
    _entry_( _cast_macro_, _toggle_, srctype, temptype, cn );                   \
                                                                                \
    for( ; y < size.height; y++, (char*&)src += step,                           \
                                 (char*&)mask += maskStep )                     \
    {                                                                           \
        for( ; x < width; x++, (loc)++ )                                        \
        {                                                                       \
            temptype val = _cast_macro_((src)[x*(cn)]);                         \
            int m = (mask)[x] != 0;                                             \
            val = _toggle_(val);                                                \
                                                                                \
            if( val < (min_val) && m )                                          \
            {                                                                   \
                (min_val) = val;                                                \
                (min_loc) = (loc);                                              \
            }                                                                   \
            else if( val > (max_val) && m )                                     \
            {                                                                   \
                (max_val) = val;                                                \
                (max_loc) = (loc);                                              \
            }                                                                   \
        }                                                                       \
        x = 0;                                                                  \
    }                                                                           \
                                                                                \
    _exit_( _toggle_, _fin_cast_macro_ );                                       \
}



#define ICV_DEF_MINMAXLOC_MASK_ALL( flavor, srctype, temptype, extrtype )           \
                                                                                    \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D( CV_NOP, CV_NOP, CV_CAST_64F,                    \
                               CV_MINMAXLOC_MASK_ENTRY, CV_MINMAXLOC_EXIT,          \
                               flavor, srctype, temptype, extrtype )                \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( CV_NOP, CV_NOP, CV_CAST_64F,                \
                                   CV_MINMAXLOC_MASK_ENTRY, CV_MINMAXLOC_EXIT,      \
                                   flavor, srctype, temptype, extrtype )


#define ICV_DEF_MINMAXLOC_MASK_ALL_FLT( flavor, srctype, temptype,                  \
                                        _cast_macro_, _toggle_,                     \
                                        _fin_cast_macro_, extrtype )                \
                                                                                    \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _cast_macro_, _toggle_, _fin_cast_macro_,       \
                                    CV_MINMAXLOC_MASK_ENTRY, CV_MINMAXLOC_EXIT,     \
                                    flavor, srctype, temptype, extrtype )           \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _cast_macro_, _toggle_, _fin_cast_macro_,   \
                                       CV_MINMAXLOC_MASK_ENTRY, CV_MINMAXLOC_EXIT,  \
                                       flavor, srctype, temptype, extrtype )


ICV_DEF_MINMAXLOC_MASK_ALL( 8u, uchar, int, float )
ICV_DEF_MINMAXLOC_MASK_ALL( 8s, char, int, float )
ICV_DEF_MINMAXLOC_MASK_ALL( 16s, short, int, float )
ICV_DEF_MINMAXLOC_MASK_ALL( 32s, int, int, double )
ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 32f, float, int, _as_int_,
                                _toggle_float_, _as_float_, float )
ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 64f, double, int64, _as_int64_,
                                _toggle_double_, _as_double_, double )

CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1R )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCR )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1MR )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCMR )


CV_IMPL  void
cvMinMaxLoc( const void* img, double* minVal, double* maxVal,
             CvPoint* minLoc, CvPoint* maxLoc, const void* mask )
{
    static CvFuncTable minmax_tab, minmaxcoi_tab;
    static CvFuncTable minmaxmask_tab, minmaxmaskcoi_tab;
    static int inittab = 0;

    CV_FUNCNAME("cvMinMaxLoc");

    __BEGIN__;

    int type, depth, cn, coi = 0;
    int mat_step, mask_step = 0;
    CvSize size;
    CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;

    if( !inittab )
    {
        icvInitMinMaxIndxC1RTable( &minmax_tab );
        icvInitMinMaxIndxCnCRTable( &minmaxcoi_tab );
        icvInitMinMaxIndxC1MRTable( &minmaxmask_tab );
        icvInitMinMaxIndxCnCMRTable( &minmaxmaskcoi_tab );
        inittab = 1;
    }
    
    CV_CALL( mat = cvGetMat( mat, &stub, &coi ));

    type = CV_MAT_TYPE( mat->type );
    depth = CV_MAT_DEPTH( type );
    cn = CV_MAT_CN( type );
    size = icvGetMatSize( mat );

    if( cn > 1 && coi == 0 )
        CV_ERROR( CV_StsBadArg, "" );
    
    mat_step = mat->step;

    if( !mask )
    {
        if( size.height == 1 )
            mat_step = CV_STUB_STEP;

        if( CV_MAT_CN(type) == 1 || coi == 0 )
        {
            CvFunc2D_1A4P func = (CvFunc2D_1A4P)(minmax_tab.fn_2d[depth]);

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

            IPPI_CALL( func( mat->data.ptr, mat_step, size,
                             minVal, maxVal, minLoc, maxLoc ));
        }
        else
        {
            CvFunc2DnC_1A4P func = (CvFunc2DnC_1A4P)(minmaxcoi_tab.fn_2d[depth]);

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

            IPPI_CALL( func( mat->data.ptr, mat_step, size, cn, coi,
                             minVal, maxVal, minLoc, maxLoc ));
        }
    }
    else
    {
        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, "" );

        mask_step = matmask->step;

        if( size.height == 1 )
            mat_step = mask_step = CV_STUB_STEP;

        if( CV_MAT_CN(type) == 1 || coi == 0 )
        {
            CvFunc2D_2A4P func = (CvFunc2D_2A4P)(minmaxmask_tab.fn_2d[depth]);

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

            IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
                             mask_step, size,
                             minVal, maxVal, minLoc, maxLoc ));
        }
        else
        {
            CvFunc2DnC_2A4P func = (CvFunc2DnC_2A4P)(minmaxmaskcoi_tab.fn_2d[depth]);

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

            IPPI_CALL( func( mat->data.ptr, mat_step,
                             matmask->data.ptr, mask_step, size, cn, coi,
                             minVal, maxVal, minLoc, maxLoc ));
        }
    }

    if( depth < CV_32S || depth == CV_32F )
    {
        if( minVal )
            *minVal = *(float*)minVal;

        if( maxVal )
            *maxVal = *(float*)maxVal;
    }

    __END__;
}


/*  End of file  */