cvmorph.cpp.svn-base

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

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

                tdst[ker_x_n + x] = (int) CV_TOGGLE_FLT( t );
            }

            /* make replication borders */
            if( channels == 1 )
            {
                int 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 )
            {
                CvRGB32s pix = ((CvRGB32s *) tdst)[ker_x];

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

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

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

                pix = ((CvRGBA32s *) tdst)[width + ker_x - 1];
                CV_SET( (CvRGBA32s *) 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 = (int *) 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, (int *) (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;

                char *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];

                        if( m )
                        {
                            int t = tsrc[j];

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

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

                char *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];

                        if( m )
                        {
                            int t = tsrc[j * 3];

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

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

                char *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];

                        if( m )
                        {
                            int t = tsrc[j * 4];

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

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

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

        /* rotate buffer */
        {
            int *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
icvDilateRC_8u( uchar * src, int srcStep,
                uchar * 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;
    uchar **rows = (uchar **) (state->rows);
    uchar *tbuf = (uchar *) (state->tbuf);

    int channels = state->channels;
    int ker_x_n = ker_x * channels;
    int ker_width_n = ker_width * 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 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] = (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
    {
        int need_copy = is_small_width | (y == 0);
        uchar *tsrc, *tdst;
        uchar *saved_row = rows[ker_y];

        /* fill cyclic buffer - horizontal filtering */
        for( ; crows < ker_height + is_cross; crows++ )
        {
            if( crows < ker_height )
            {
                tsrc = src - ker_x_n;
                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;
                }

                need_copy |= src_height == 1;
            }
            else
            {
                /* convolve center line for cross-shaped element */
                tsrc = rows[ker_y] - ker_x_n;
                tdst = tbuf;

                need_copy = 0;
            }

            if( ker_width > 1 && (!is_cross || crows == ker_height) )
            {
                if( need_copy )
                {
                    tsrc = tbuf - ker_x_n;
                    CV_COPY( tbuf, src, width_n, x );
                }
                else if( !is_cross )
                {
                    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 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_MAX( t0, t1 );
                        }

                        t = tsrc[i];
                        CV_CALC_MAX( t, t0 );
                        tdst[i] = (uchar) t;

                        t = tsrc[i + j];
                        CV_CALC_MAX( t, t0 );
                        tdst[i + 1] = (uchar) t;
                    }
                }
                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 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_MAX( t0, t1 );
                        }

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

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

                    pix = ((CvRGBA8u *) tsrc)[width + ker_x - 1];
                    CV_SET( (CvRGBA8u *) 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_MAX( t0, t1 );
                        }

                        tdst[i] = (uchar) t0;
                    }
                }

                if( !need_copy && !is_cross )
                {
                    /* 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;
            tsrc = rows[ker_y];

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

        /* vertical convolution */
        if( crows != ker_height )
        {
            if( crows < ker_height )
                break;
            /* else it is cross-shaped element: change central line */
            rows[ker_y] = tbuf;
            crows--;
        }

        tdst = dst;

        if( width_rest )