cvmorph.cpp.svn-base

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

    int starting_flag = 0;
    int width_rest = width_n & (CV_MORPH_ALIGN - 1);

    /* initialize cyclic buffer when starting */
    if( stage == CV_WHOLE || stage == CV_START )
    {
        for( i = 0; i < ker_height; i++ )
        {
            rows[i] = (uchar *) (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
    {
        uchar *tsrc, *tdst;
        int need_copy = 0;

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

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

            src += srcStep;

            CV_COPY( tdst + ker_x_n, tsrc, width_n, x );

            /* make replication borders */
            if( channels == 1 )
            {
                uchar pix = tdst[ker_x];

                CV_SET( tdst, pix, ker_x, x );

                pix = tdst[width + ker_x - 1];
                CV_SET( tdst + width + ker_x, pix, ker_right, x );
            }
            else if( channels == 3 )
            {
                CvRGB8u pix = ((CvRGB8u *) tdst)[ker_x];

                CV_SET( (CvRGB8u *) tdst, pix, ker_x, x );

                pix = ((CvRGB8u *) tdst)[width + ker_x - 1];
                CV_SET( (CvRGB8u *) tdst + width + ker_x, pix, ker_right, x );
            }
            else                /* channels == 4 */
            {
                /* make replication borders */
                CvRGBA8u pix = ((CvRGBA8u *) tdst)[ker_x];

                CV_SET( (CvRGBA8u *) tdst, pix, ker_x, x );

                pix = ((CvRGBA8u *) tdst)[width + ker_x - 1];
                CV_SET( (CvRGBA8u *) tdst + width + ker_x, pix, ker_right, x );
            }
        }

        if( starting_flag )
        {
            starting_flag = 0;
            tsrc = rows[ker_y];

            for( i = 0; i < ker_y; i++ )
            {
                tdst = rows[i];
                CV_COPY( tdst, tsrc, width_n + ker_width_n, x );
            }
        }

        /* vertical convolution */
        if( crows < ker_height )
            break;

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

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

        if( channels == 1 )
        {
            for( x = 0; x < width_n; x += 4 )
            {
                int val0 = INIT_VAL, val1 = INIT_VAL, val2 = INIT_VAL, val3 = INIT_VAL;

                uchar *ker = ker_data;

                for( i = 0; i < ker_height; i++, ker += ker_width )
                {
                    int j = -ker_width;

                    tsrc = rows[i] + x - j;
                    do
                    {
                        int m = ker[j];
                        int t = tsrc[j] | m;

                        CV_CALC_MIN( val0, t );
                        t = tsrc[j + 1] | m;
                        CV_CALC_MIN( val1, t );
                        t = tsrc[j + 2] | m;
                        CV_CALC_MIN( val2, t );
                        t = tsrc[j + 3] | m;
                        CV_CALC_MIN( val3, t );
                    }
                    while( ++j < 0 );
                }

                tdst[x] = (uchar) val0;
                tdst[x + 1] = (uchar) val1;
                tdst[x + 2] = (uchar) val2;
                tdst[x + 3] = (uchar) val3;
            }
        }
        else if( channels == 3 )
        {
            for( x = 0; x < width_n; x += 3 )
            {
                int val0 = INIT_VAL, val1 = INIT_VAL, val2 = INIT_VAL;

                uchar *ker = ker_data;

                for( i = 0; i < ker_height; i++, ker += ker_width )
                {
                    int j = -ker_width;

                    tsrc = rows[i] + x - j * 3;
                    for( ; j < 0; j++ )
                    {
                        int m = ker[j];
                        int t = tsrc[j * 3] | m;

                        CV_CALC_MIN( val0, t );
                        t = tsrc[j * 3 + 1] | m;
                        CV_CALC_MIN( val1, t );
                        t = tsrc[j * 3 + 2] | m;
                        CV_CALC_MIN( val2, t );
                    }
                }

                tdst[x] = (uchar) val0;
                tdst[x + 1] = (uchar) val1;
                tdst[x + 2] = (uchar) val2;
            }
        }
        else
        {
            for( x = 0; x < width_n; x += 4 )
            {
                int val0 = INIT_VAL, val1 = INIT_VAL, val2 = INIT_VAL, val3 = INIT_VAL;

                uchar *ker = ker_data;

                for( i = 0; i < ker_height; i++, ker += ker_width )
                {
                    int j = -ker_width;

                    tsrc = rows[i] + x - j * 4;
                    for( ; j < 0; j++ )
                    {
                        int m = ker[j];
                        int t = tsrc[j * 4] | m;

                        CV_CALC_MIN( val0, t );
                        t = tsrc[j * 4 + 1] | m;
                        CV_CALC_MIN( val1, t );
                        t = tsrc[j * 4 + 2] | m;
                        CV_CALC_MIN( val2, t );
                        t = tsrc[j * 4 + 3] | m;
                        CV_CALC_MIN( val3, t );
                    }
                }

                tdst[x] = (uchar) val0;
                tdst[x + 1] = (uchar) val1;
                tdst[x + 2] = (uchar) val2;
                tdst[x + 3] = (uchar) val3;
            }
        }

        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 );
        }

        /* rotate buffer */
        {
            uchar *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;
#undef INIT_VAL
}


static CvStatus
icvErodeRC_32f( float *src, int srcStep,
                float *dst, int dstStep, CvSize * roiSize, CvMorphState * state, int stage )
{
    int width = roiSize->width;
    int src_height = roiSize->height;
    int dst_height = src_height;
    int x, y = 0, i;

    int ker_x = state->ker_x;
    int ker_y = state->ker_y;
    int ker_width = state->ker_width;
    int ker_height = state->ker_height;
    int ker_right = ker_width - ker_x - ((width & 1) == 0);

    int crows = state->crows;
    int **rows = (int **) (state->rows);
    int *tbuf = (int *) (state->tbuf);
    int *tbuf2 = (int *) (state->tbuf + state->buffer_step);

    int channels = state->channels;
    int ker_x_n = ker_x * channels;
    int ker_width_n = ker_width * channels;
    int width_n = width * channels;

    int starting_flag = 0;
    int width_rest = width_n & (CV_MORPH_ALIGN - 1);

    int is_cross = ICV_BINARY_KERNEL_SHAPE(state->kerType) == CV_SHAPE_CROSS;

    /* 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;

    srcStep /= sizeof_float;
    dstStep /= sizeof_float;

    do
    {
        int need_copy = 0;
        int *tsrc, *tdst;
        int *saved_row = rows[ker_y];

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

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

                for( x = 0; x < width_n; x++ )
                {
                    int t = tsrc[x];

                    tbuf2[x] = CV_TOGGLE_FLT( t );
                }
                tsrc = tbuf2 - ker_x_n;
            }
            else
            {
                /* convolve center line for cross-shaped element */
                tsrc = rows[ker_y] - ker_x_n;
                tdst = tbuf;
            }

            if( ker_width > 1 && (!is_cross || crows == ker_height) )
            {
                if( channels == 1 )
                {
                    /* make replication borders */
                    int 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 convolution loop */
                    for( i = 0; i < width_n; i += 2 )
                    {
                        int j;
                        int t, t0 = tsrc[i + 1];

                        for( j = 2; j < ker_width_n; j++ )
                        {
                            int t1 = tsrc[i + j];

                            CV_CALC_MIN( t0, t1 );
                        }

                        t = tsrc[i];
                        CV_CALC_MIN( t, t0 );
                        tdst[i] = (int) t;

                        t = tsrc[i + j];
                        CV_CALC_MIN( t, t0 );
                        tdst[i + 1] = (int) t;
                    }
                }
                else if( channels == 3 )
                {
                    /* make replication borders */
                    CvRGB32s pix = ((CvRGB32s *) tsrc)[ker_x];

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

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

                    /* horizontal convolution loop */
                    for( i = 0; i < width_n; i++ )
                    {
                        int j;
                        int t0 = tsrc[i];

                        for( j = 3; j < ker_width_n; j += 3 )
                        {
                            int t1 = tsrc[i + j];

                            CV_CALC_MIN( t0, t1 );
                        }

                        tdst[i] = (int) t0;
                    }
                }
                else            /* channels == 4 */
                {
                    /* make replication borders */
                    CvRGBA32s pix = ((CvRGBA32s *) tsrc)[ker_x];

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

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

                    /* horizontal convolution loop */
                    for( i = 0; i < width_n; i++ )
                    {
                        int j;
                        int t0 = tsrc[i];

                        for( j = 4; j < ker_width_n; j += 4 )
                        {
                            int t1 = tsrc[i + j];

                            CV_CALC_MIN( t0, t1 );
                        }

                        tdst[i] = (int) t0;
                    }
                }
            }
            else
            {
                CV_COPY( tdst, tsrc + ker_x_n, width_n, x );
            }

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

        if( starting_flag )
        {
            starting_flag = 0;
            tsrc = rows[ker_y];

            for( i = 0; i < ker_y; i++ )
            {
                tdst = rows[i];
                CV_COPY( tdst, tsrc, width_n, x );
            }
        }

        /* vertical convolution */