cvpyramids.cpp.svn-base

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

            if( size.height > PU_SZ / 2 ) /* top */                                     \
                for( x = 0; x < Wdn; x++ )                                              \
                {                                                                       \
                    dst[x] = (type)_pu_scale_( PU_LT( row0[x], row1[x] ));              \
                    dst1[x] = (type)_pu_scale_( PU_LT_ZI( row0[x], row1[x] ));          \
                }                                                                       \
            else                /* size.height <= PU_SZ/2 */                            \
                for( x = 0; x < Wdn; x++ )                                              \
                {                                                                       \
                    dst[x] = (type)_pu_scale_( PU_SINGULAR( row0[x] ));                 \
                    dst1[x] = (type)_pu_scale_( PU_SINGULAR_ZI( row0[x] ));             \
                }                                                                       \
            fst = PU_SZ - 1;                                                            \
        }                                                                               \
                                                                                        \
        lst = y < size.height - PU_SZ/2 - 1 ? PU_SZ : size.height + PU_SZ/2 - y - 1;    \
    }                                                                                   \
                                                                                        \
    return CV_OK;                                                                       \
}


ICV_DEF_PYR_UP_FUNC( 8u, uchar, int, PU_SCALE_INT )
ICV_DEF_PYR_UP_FUNC( 8s, char, int, PU_SCALE_INT )
ICV_DEF_PYR_UP_FUNC( 32f, float, float, PU_SCALE_FLT )
ICV_DEF_PYR_UP_FUNC( 64f, double, double, PU_SCALE_FLT )



/****************************************************************************************\
                                     External functions
\****************************************************************************************/

#define ICV_DEF_PYR_FUNC( name, flavor, cn, arrtype )               \
IPCVAPI_IMPL( CvStatus, name##_Gauss5x5_##flavor##_C##cn##R,        \
( const arrtype* pSrc, int srcStep, arrtype* pDst, int dstStep,     \
  CvSize roiSize, void* pBuffer ))                                  \
{                                                                   \
    return name##G5x5_##flavor( pSrc, srcStep, pDst, dstStep,       \
                                    roiSize, pBuffer, cn );         \
}

ICV_DEF_PYR_FUNC( icvPyrUp, 8u, 1, uchar )
ICV_DEF_PYR_FUNC( icvPyrUp, 8u, 3, uchar )
ICV_DEF_PYR_FUNC( icvPyrUp, 8s, 1, char )
ICV_DEF_PYR_FUNC( icvPyrUp, 8s, 3, char )
ICV_DEF_PYR_FUNC( icvPyrUp, 32f, 1, float )
ICV_DEF_PYR_FUNC( icvPyrUp, 32f, 3, float )
ICV_DEF_PYR_FUNC( icvPyrUp, 64f, 1, double )
ICV_DEF_PYR_FUNC( icvPyrUp, 64f, 3, double )

ICV_DEF_PYR_FUNC( icvPyrDown, 8u, 1, uchar )
ICV_DEF_PYR_FUNC( icvPyrDown, 8u, 3, uchar )
ICV_DEF_PYR_FUNC( icvPyrDown, 8s, 1, char )
ICV_DEF_PYR_FUNC( icvPyrDown, 8s, 3, char )
ICV_DEF_PYR_FUNC( icvPyrDown, 32f, 1, float )
ICV_DEF_PYR_FUNC( icvPyrDown, 32f, 3, float )
ICV_DEF_PYR_FUNC( icvPyrDown, 64f, 1, double )
ICV_DEF_PYR_FUNC( icvPyrDown, 64f, 3, double )


IPCVAPI_IMPL( CvStatus, icvPyrUpGetBufSize_Gauss5x5, (int roiWidth, CvDataType dataType,
                                                      int channels, int *bufSize) )
{
    int bufStep;

    if( !bufSize )
        return CV_NULLPTR_ERR;
    *bufSize = 0;

    if( roiWidth < 0 )
        return CV_BADSIZE_ERR;
    if( channels != 1 && channels != 3 )
        return CV_UNSUPPORTED_CHANNELS_ERR;

    bufStep = 2*roiWidth*channels;

    switch( dataType )
    {
    case cv8u: case cv8s:
        bufStep *= sizeof(int);
        break;
    case cv32f:
        //bufStep *= sizeof(float);
        //break;
    case cv64f:
        bufStep *= sizeof(double);
        break;
    default:
        return CV_BADARG_ERR;
    }

    *bufSize = bufStep * PU_SZ;
    return CV_OK;
}


IPCVAPI_IMPL( CvStatus, icvPyrDownGetBufSize_Gauss5x5, ( int roiWidth, CvDataType dataType,
                                                         int channels, int *bufSize) )
{
    int bufStep;

    if( !bufSize )
        return CV_NULLPTR_ERR;
    *bufSize = 0;

    if( roiWidth < 0 || (roiWidth & 1) != 0 )
        return CV_BADSIZE_ERR;
    if( channels != 1 && channels != 3 )
        return CV_UNSUPPORTED_CHANNELS_ERR;

    bufStep = 2*roiWidth*channels;

    switch( dataType )
    {
    case cv8u: case cv8s:
        bufStep *= sizeof(int);
        break;
    case cv32f:
        bufStep *= sizeof(float);
        break;
    case cv64f:
        bufStep *= sizeof(double);
        break;
    default:
        return CV_BADARG_ERR;
    }

    *bufSize = bufStep * (PD_SZ + 1);
    return CV_OK;
}



/****************************************************************************************\
                        Downsampled image border completion
\****************************************************************************************/

#define ICV_DEF_PYR_BORDER_FUNC( flavor, arrtype, worktype, _pd_scale_ )                \
IPCVAPI_IMPL( CvStatus,                                                                 \
icvPyrDownBorder_##flavor##_CnR, ( const arrtype *src, int src_step, CvSize src_size,   \
                            arrtype *dst, int dst_step, CvSize dst_size, int channels ))\
{                                                                                       \
    worktype local_buffer[1 << 10];                                                     \
    worktype *buf = local_buffer, *buf0;                                                \
    const arrtype* src2;                                                                \
    arrtype* dst2;                                                                      \
    int buf_size;                                                                       \
    int i, j;                                                                           \
    int W = src_size.width, H = src_size.height;                                        \
    int Wd = dst_size.width, Hd = dst_size.height;                                      \
    int Wd_, Hd_;                                                                       \
    int bufW;                                                                           \
    int cols, rows; /* columns and rows to modify */                                    \
                                                                                        \
    buf_size = MAX(src_size.width,src_size.height) * sizeof(buf[0]) * 2 * channels;     \
    if( buf_size > (int)sizeof(local_buffer))                                           \
    {                                                                                   \
        buf = (worktype*) icvAlloc( buf_size );                                         \
        if( !buf )                                                                      \
            return CV_OUTOFMEM_ERR;                                                     \
    }                                                                                   \
                                                                                        \
    buf0 = buf;                                                                         \
                                                                                        \
    src_step /= sizeof(src[0]);                                                         \
    dst_step /= sizeof(dst[0]);                                                         \
                                                                                        \
    cols = (W & 1) + (Wd*2 > W);                                                        \
    rows = (H & 1) + (Hd*2 > H);                                                        \
                                                                                        \
    src2 = src + (H-1)*src_step;                                                        \
    dst2 = dst + (Hd - rows)*dst_step;                                                  \
    src += (W - 1)*channels;                                                            \
    dst += (Wd - cols)*channels;                                                        \
                                                                                        \
    /* part of row(column) from 1 to Wd_(Hd_) is processed using PD_FILTER macro */     \
    Wd_ = Wd - 1 + (cols == 1 && (W & 1) != 0);                                         \
    Hd_ = Hd - 1 + (rows == 1 && (H & 1) != 0);                                         \
                                                                                        \
    bufW = channels * cols;                                                             \
                                                                                        \
    /******************* STAGE 1. ******************/                                   \
                                                                                        \
    /* do horizontal convolution of the 1-2 right columns and write results to buffer */\
    if( cols > 0 )                                                                      \
    {                                                                                   \
        switch( W )                                                                     \
        {                                                                               \
        case 1:                                                                         \
        case 2:                                                                         \
            assert( Wd == 1 );                                                          \
            for( i = 0; i < H; i++, src += src_step, buf += channels )                  \
                for( j = 0; j < channels; j++ )                                         \
                    buf[j] = PD_SINGULAR( src[j-channels*(W-1)], src[j] );              \
            break;                                                                      \
        case 3:                                                                         \
            if( Wd == 1 )                                                               \
                for( i = 0; i < H; i++, src += src_step, buf += channels )              \
                    for( j = 0; j < channels; j++ )                                     \
                        buf[j] = PD_LT( src[j-channels*2], src[j-channels], src[j] );   \
            else                                                                        \