cvsmooth.cpp.svn-base

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

                        t2 += tsrc[i-1];
                        tdst[i-ker_width_n] = t0;
                        tdst[i-ker_width_n+1] = t1;
                        tdst[i-ker_width_n+2] = t2;
                        t0 -= tsrc[i - ker_width_n];
                        t1 -= tsrc[i - ker_width_n + 1];
                        t2 -= tsrc[i - ker_width_n + 2];
                    }
                }
                else            /* channels == 4 */
                {
                    /* make replication borders */
                    CvRGBA32f pix = ((CvRGBA32f *) tsrc)[ker_x];
                    float t0 = 0, t1 = 0, t2 = 0, t3 = 0;

                    CV_SET( (CvRGBA32f *) tsrc, pix, ker_x, x );

                    pix = ((CvRGBA32f *) tsrc)[width + ker_x - 1];
                    CV_SET( (CvRGBA32f *) tsrc + width + ker_x, pix, ker_right, x );

                    for( i = 0; i < ker_width_n - 4; i += 4 )
                    {
                        t0 += tsrc[i];
                        t1 += tsrc[i+1];
                        t2 += tsrc[i+2];
                        t3 += tsrc[i+3];
                    }

                    /* horizontal blurring */
                    for( i = ker_width_n; i < width_n + ker_width_n; i += 4 )
                    {
                        t0 += tsrc[i-4];
                        t1 += tsrc[i-3];
                        t2 += tsrc[i-2];
                        t3 += tsrc[i-1];
                        tdst[i-ker_width_n] = t0;
                        tdst[i-ker_width_n+1] = t1;
                        tdst[i-ker_width_n+2] = t2;
                        tdst[i-ker_width_n+3] = t3;
                        t0 -= tsrc[i - ker_width_n];
                        t1 -= tsrc[i - ker_width_n + 1];
                        t2 -= tsrc[i - ker_width_n + 2];
                        t3 -= tsrc[i - ker_width_n + 3];
                    }
                }

                if( !need_copy )
                {
                    /* restore borders */
                    CV_COPY( src - ker_x_n, tbuf - ker_x_n, ker_x_n, x );
                    CV_COPY( src + width_n, tbuf, ker_right_n, x );
                }
            }
            else
            {
                CV_COPY( tdst, tsrc + ker_x_n, width_n, x );
            }

            if( crows < ker_height )
                src += srcStep;
        }

        if( starting_flag )
        {
            starting_flag = 0;

            for( x = 0; x < width_n; x++ )
            {
                float t = rows[ker_y][x];
                for( i = 0; i < ker_y; i++ ) // copy border
                    rows[i][x] = t;

                t *= ker_y;
                for( i = ker_y; i < ker_height - 1; i++ ) // accumulate initial sum
                    t += rows[i][x];
                sumbuf[x] = t;
            }
        }

        /* vertical convolution */
        if( crows != ker_height )
            break;

        tdst2 = dst;

        if( width_rest )
        {
            need_copy = width_n < CV_MORPH_ALIGN || y == dst_height - 1;

            if( need_copy )
                tdst2 = tbuf;
            else
                CV_COPY( tbuf + width_n, dst + width_n, CV_MORPH_ALIGN, x );
        }

        trow = rows[0];
        trow2 = rows[ker_height-1];

        if( no_scale )
        {
            for( x = 0; x < width_n; x += CV_MORPH_ALIGN )
            {
                float val0, val1;

                val0 = sumbuf[x];
                val1 = sumbuf[x+1];
            
                val0 += trow2[x];
                val1 += trow2[x+1];

                tdst2[x] = (float)val0;
                tdst2[x+1] = (float)val1;

                sumbuf[x] = val0 - trow[x];
                sumbuf[x+1] = val1 - trow[x+1];

                val0 = sumbuf[x+2];
                val1 = sumbuf[x+3];
            
                val0 += trow2[x+2];
                val1 += trow2[x+3];

                tdst2[x+2] = (float)val0;
                tdst2[x+3] = (float)val1;

                sumbuf[x+2] = val0 - trow[x+2];
                sumbuf[x+3] = val1 - trow[x+3];
            }
        }
        else
        {
            for( x = 0; x < width_n; x += CV_MORPH_ALIGN )
            {
                float val0, val1, t0, t1;

                val0 = sumbuf[x];
                val1 = sumbuf[x+1];
            
                val0 += trow2[x];
                val1 += trow2[x+1];

                t0 = val0 * scale;
                t1 = val1 * scale;

                tdst2[x] = (float)t0;
                tdst2[x+1] = (float)t1;

                sumbuf[x] = val0 - trow[x];
                sumbuf[x+1] = val1 - trow[x+1];

                val0 = sumbuf[x+2];
                val1 = sumbuf[x+3];
            
                val0 += trow2[x+2];
                val1 += trow2[x+3];

                t0 = val0 * scale;
                t1 = val1 * scale;

                tdst2[x+2] = (float)t0;
                tdst2[x+3] = (float)t1;

                sumbuf[x+2] = val0 - trow[x+2];
                sumbuf[x+3] = val1 - trow[x+3];
            }
        }

        if( width_rest )
        {
            if( need_copy )
                CV_COPY( dst, tbuf, width_n, x );
            else
                CV_COPY( dst + width_n, tbuf + width_n, CV_MORPH_ALIGN, x );
        }

        rows[ker_y] = saved_row;

        /* rotate buffer */
        {
            float *t = rows[0];

            CV_COPY( rows, rows + 1, ker_height - 1, i );
            rows[i] = t;
            crows--;
            dst += dstStep;
        }
    }
    while( ++y < dst_height );

    roiSize->height = y;
    state->crows = crows;

    return CV_OK;
}


IPCVAPI_IMPL( CvStatus, icvBlurInitAlloc,(
    int roiWidth, int depth, int size,
    struct CvFilterState** filterState ))
{
    return icvSmoothInitAlloc( roiWidth, (CvDataType)depth, 1, cvSize(size,size),
                               CV_BLUR_NO_SCALE, filterState );
}


/****************************************************************************************\
                                    Gaussian Blur
\****************************************************************************************/


IPCVAPI( CvStatus,
     icvGaussianBlur_small_8u_CnR, ( uchar* src, int srcStep,
                                     uchar* dst, int dstStep, CvSize * roiSize,
                                     CvFilterState* state, int stage ));

IPCVAPI_IMPL( CvStatus,
     icvGaussianBlur_small_8u_CnR, ( uchar* src, int srcStep,
                                     uchar* dst, int dstStep, CvSize * roiSize,
                                     CvFilterState* state, int stage ))
{
    int width = roiSize->width;
    int src_height = roiSize->height;
    int dst_height = src_height;
    int x, y = 0, i;

    int ker_width = state->ker_width;
    int ker_height = state->ker_height;
    int ker_x = ker_width/2;
    int ker_y = ker_height/2;
    int ker_right = ker_width - ker_x;

    int crows = state->crows;
    int **rows = (int**)(state->rows);
    uchar *tbuf = (uchar*)(state->tbuf);
    int *trow = 0;

    int channels = state->channels;
    int ker_x_n = ker_x * channels;
    int ker_right_n = ker_right * channels;
    int width_n = width * channels;

    int is_small_width = width < MAX( ker_x, ker_right );
    int starting_flag = 0;
    int width_rest = width_n & (CV_MORPH_ALIGN - 1);
    int rshift = ker_width + ker_height - 2;
    int delta = 1 << (rshift - 1);

    assert( ker_width <= SMALL_GAUSSIAN_SIZE &&
            ker_height <= SMALL_GAUSSIAN_SIZE );

    /* initialize cyclic buffer when starting */
    if( stage == CV_WHOLE || stage == CV_START )
    {
        for( i = 0; i < ker_height; i++ )
            rows[i] = (int*)(state->buffer + state->buffer_step * i);

        crows = ker_y;
        if( stage != CV_WHOLE )
            dst_height -= ker_height - ker_y - 1;
        starting_flag = 1;
    }

    if( stage == CV_END )
        dst_height += ker_height - ker_y - 1;

    do
    {
        int need_copy = is_small_width | (y == 0);
        uchar *tsrc;
        int *tdst;
        uchar *tdst2;
        int *saved_row = rows[ker_y];

        /* fill cyclic buffer - horizontal filtering */
        for( ; crows < ker_height; crows++ )
        {
            tsrc = src - ker_x_n;
            tdst = rows[crows];

            if( src_height-- <= 0 )
            {
                if( stage != CV_WHOLE && stage != CV_END )
                    break;
                /* duplicate last row */
                trow = rows[crows - 1];
                CV_COPY( tdst, trow, width_n, x );
                continue;
            }

            need_copy |= src_height == 1;

            if( ker_width > 1 )
            {
                if( need_copy )
                {
                    tsrc = tbuf - ker_x_n;
                    CV_COPY( tbuf, src, width_n, x );
                }
                else
                {
                    CV_COPY( tbuf - ker_x_n, src - ker_x_n, ker_x_n, x );
                    CV_COPY( tbuf, src + width_n, ker_right_n, x );
                }

                if( channels == 1 )
                {
                    /* make replication borders */
                    uchar pix = tsrc[ker_x];
                    CV_SET( tsrc, pix, ker_x, x );

                    pix = tsrc[width + ker_x - 1];
                    CV_SET( tsrc + width + ker_x, pix, ker_right, x );

                    /* horizontal blurring */
                    if( ker_width == 3 )
                    {
                        for( i = 0; i < width_n; i++ )
                            tdst[i] = tsrc[i+1]*2 + tsrc[i] + tsrc[i + 2];
                    }
                    else if( ker_width == 5 )
                    {
                        for( i = 0; i < width_n; i++ )
                            tdst[i] = tsrc[i+2]*6 + (tsrc[i+1] + tsrc[i+3])*4 + 
                                      tsrc[i] + tsrc[i+4];
                    }
                    else if( ker_width == 7 )
                    {
                        for( i = 0; i < width_n; i++ )
                            tdst[i] = tsrc[i+3]*18 + (tsrc[i+2] + tsrc[i+4])*14 + 
                                (tsrc[i+1] + tsrc[i+5])*7 + (tsrc[i] + tsrc[i+6])*2;
                    }
                }
                else if( channels == 3 )
                {
                    /* make replication borders */
                    CvRGB8u pix = ((CvRGB8u *)tsrc)[ker_x];
                    CV_SET( (CvRGB8u *) tsrc, pix, ker_x, x );

                    pix = ((CvRGB8u *) tsrc)[width + ker_x - 1];
                    CV_SET( (CvRGB8u *) tsrc + width + ker_x, pix, ker_right, x );

                    /* horizontal blurring */
                    if( ker_width == 3 )
                    {
                        for( i = 0; i < width_n; i += 3 )
                        {
                            int t0 = tsrc[i + 3]*2 + tsrc[i] + tsrc[i+6];
                            int t1 = tsrc[i + 4]*2 + tsrc[i+1] + tsrc[i+7];
                            int t2 = tsrc[i + 5]*2 + tsrc[i+2] + tsrc[i+8];

                            tdst[i] = t0;
                            tdst[i+1] = t1;
                            tdst[i+2] = t2;
                        }
                    }
                    else if( ker_width == 5 )
                    {
                        for( i = 0; i < width_n; i += 3 )
                        {
                            int t0 = tsrc[i+6]*6 + (tsrc[i+3] + tsrc[i+9])*4 +
                                     tsrc[i]+tsrc[i+12];
                            int t1 = tsrc[i+7]*6 + (tsrc[i+4] + tsrc[i+10])*4 +
                                     tsrc[i+1]+tsrc[i+13];
                            int t2 = tsrc[i+8]*6 + (tsrc[i+5] + tsrc[i+11])*4 +
                                     tsrc[i+2]+tsrc[i+14];

                            tdst[i] = t0;
                            tdst[i+1] = t1;
                            tdst[i+2] = t2;
                        }
                    }
                    else
                    {
                        assert( ker_width == 7 );
                        for( i = 0; i < width_n; i += 3 )
                        {
                            int t0 = tsrc[i+9]*18 + (tsrc[i+6] + tsrc[i+12])*14 +
                                     (tsrc[i+3]+tsrc[i+15])*7 + (tsrc[i] + tsrc[i+18])*2;
                            int t1 = tsrc[i+10]*18 + (tsrc[i+7] + tsrc[i+13])*14 +
                                     (tsrc[i+4]+tsrc[i+16])*7 + (tsrc[i+1] + tsrc[i+19])*2;
                            int t2 = tsrc[i+11]*18 + (tsrc[i+8] + tsrc[i+14])*14 +
                                     (tsrc[i+5]+tsrc[i+17])*7 + (tsrc[i+2] + tsrc[i+20])*2;

                            tdst[i] = t0;
                            tdst[i+1] = t1;
                            tdst[i+2] = t2;
                        }
                    }
                }
                else   /* channels == 4 */
                {
                    /* make replication borders */