cvderiv.cpp.svn-base

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

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

        tdst2 = dst;

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

            if( need_copy )
                tdst2 = tbufw;
            else
                CV_COPY( tbufw + width, dst + width, CV_MORPH_ALIGN, x );
        }

        trow = rows[ker_y];

        if( ker_height == 3 )
        {
            int *trow1 = rows[0], *trow2 = rows[2];

            if( y_type == ICV_1_2_1_KERNEL )
            {
                for( x = 0; x < width; x += CV_MORPH_ALIGN )
                {
                    int val0, val1;
                    val0 = trow[x]*2 + trow1[x] + trow2[x] -
                           trow[x+width]*2 + trow1[x+width] + trow2[x+width];
                    val1 = trow[x+1]*2 + trow1[x+1] + trow2[x+1] -
                           trow[x+1+width]*2 + trow1[x+1+width] + trow2[x+1+width];
            
                    tdst2[x + 0] = (short)val0;
                    tdst2[x + 1] = (short)val1;
            
                    val0 = trow[x+2]*2 + trow1[x+2] + trow2[x+2] -
                           trow[x+2+width]*2 + trow1[x+2+width] + trow2[x+2+width];
                    val1 = trow[x+3]*2 + trow1[x+3] + trow2[x+3] -
                           trow[x+3+width]*2 + trow1[x+3+width] + trow2[x+3+width];
            
                    tdst2[x + 2] = (short)val0;
                    tdst2[x + 3] = (short)val1;
                }
            }
            else
            {
                for( x = 0; x < width; x += CV_MORPH_ALIGN )
                {
                    int val0, val1;
                    val0 = trow[x] -
                           trow[x+width]*2 + trow1[x+width] + trow2[x+width];
                    val1 = trow[x+1] -
                           trow[x+1+width]*2 + trow1[x+1+width] + trow2[x+1+width];
            
                    tdst2[x + 0] = (short)val0;
                    tdst2[x + 1] = (short)val1;
            
                    val0 = trow[x+2] -
                           trow[x+2+width]*2 + trow1[x+2+width] + trow2[x+2+width];
                    val1 = trow[x+3] -
                           trow[x+3+width]*2 + trow1[x+3+width] + trow2[x+3+width];
            
                    tdst2[x + 2] = (short)val0;
                    tdst2[x + 3] = (short)val1;
                }
            }
        }
        else if( ker_height == 5 )
        {
            int *trow0 = rows[0], *trow1 = rows[1], *trow3 = rows[3], *trow4 = rows[4];

            for( x = 0; x < width; x += CV_MORPH_ALIGN )
            {
                int val0, val1;
                val0 = trow0[x] + trow4[x] + (trow1[x] + trow3[x])*4 + trow[x]*6 +
                       trow0[x+width] + trow4[x+width] - 2*trow[x+width];
                val1 = trow0[x+1] + trow4[x+1] + (trow1[x+1] + trow3[x+1])*4 + trow[x+1]*6 +
                       trow0[x+1+width] + trow4[x+1+width] - 2*trow[x+1+width];
            
                tdst2[x + 0] = (short)val0;
                tdst2[x + 1] = (short)val1;
            
                val0 = trow0[x+2] + trow4[x+2] + (trow1[x+2] + trow3[x+2])*4 + trow[x+2]*6 +
                       trow0[x+2+width] + trow4[x+2+width] - 2*trow[x+2+width];
                val1 = trow0[x+3] + trow4[x+3] + (trow1[x+3] + trow3[x+3])*4 + trow[x+3]*6 +
                       trow0[x+3+width] + trow4[x+3+width] - 2*trow[x+3+width];
            
                tdst2[x + 2] = (short)val0;
                tdst2[x + 3] = (short)val1;
            }
        }
        else
        {
            for( x = 0; x < width; x += CV_MORPH_ALIGN )
            {
                int val0, val1, val2, val3;

                val0 = trow[x]*fmY0 + trow[x + width]*fmX0;
                val1 = trow[x + 1]*fmY0 + trow[x + 1 + width]*fmX0;
                val2 = trow[x + 2]*fmY0 + trow[x + 2 + width]*fmX0;
                val3 = trow[x + 3]*fmY0 + trow[x + 3 + width]*fmX0;

                for( i = 1; i <= ker_y; i++ )
                {
                    int *trow1, *trow2;
                    int m0 = fmaskY[i], m1 = fmaskX[i];
                    trow1 = rows[ker_y - i];
                    trow2 = rows[ker_y + i];
                    val0 += (trow2[x] + trow1[x])*m0 +
                            (trow2[x+width] + trow1[x+width])*m1;
                    val1 += (trow2[x+1] + trow1[x+1])*m0 +
                            (trow2[x+1+width] + trow1[x+1+width])*m1;
                    val2 += (trow2[x+2] + trow1[x+2])*m0 +
                            (trow2[x+2+width] + trow1[x+2+width])*m1;
                    val3 += (trow2[x+3] + trow1[x+3])*m0 +
                            (trow2[x+3+width] + trow1[x+3+width])*m1;
                }

                tdst2[x + 0] = CV_CAST_16S(val0);
                tdst2[x + 1] = CV_CAST_16S(val1);
                tdst2[x + 2] = CV_CAST_16S(val2);
                tdst2[x + 3] = CV_CAST_16S(val3);
            }
        }

        if( width_rest )
        {
            if( need_copy )
                CV_COPY( dst, tbufw, width, x );
            else
                CV_COPY( dst + width, tbufw + width, CV_MORPH_ALIGN, x );
        }

        rows[ker_y] = saved_row;

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


IPCVAPI_IMPL( CvStatus, icvLaplace_8s16s_C1R,(
             const char* pSrc, int srcStep,
             short* dst, int dstStep, CvSize* roiSize,
             CvFilterState* state, int stage ))
{
    char* src = (char*)pSrc;
    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);
    short *tbufw = (short*)(state->tbuf);
    int *trow = 0;

    int* fmaskX = (int*)(state->ker0) + ker_x;
    int* fmaskY = (int*)(state->ker1) + ker_y;
    int fmX0 = fmaskX[0], fmY0 = fmaskY[0];

    int is_small_width = width < MAX( ker_x, ker_right );
    int starting_flag = 0;
    int width_rest = width & (CV_MORPH_ALIGN - 1);
    int y_type = ICV_Y_KERNEL_TYPE(state->kerType);

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

    dstStep /= sizeof(dst[0]);

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

        /* fill cyclic buffer - horizontal filtering */
        for( ; crows < ker_height; crows++ )
        {
            tsrc = src - ker_x;
            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*2, x );
                continue;
            }

            need_copy |= src_height == 1;

            {
                char* tbufc = (char*)tbufw;

                if( need_copy )
                {
                    tsrc = tbufc - ker_x;
                    CV_COPY( tbufc, src, width, x );
                }
                else
                {
                    CV_COPY( tbufc - ker_x, src - ker_x, ker_x, x );
                    CV_COPY( tbufc, src + width, ker_right, x );
                }

                /* make replication borders */
                {
                char 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 );
                }

                if( ker_width == 3 )
                {
                    if( y_type == ICV_1_2_1_KERNEL )
                    {
                        for( i = 0; i < width; i++ )
                        {
                            int t0 = tsrc[i] + tsrc[i+2] - tsrc[i+1]*2;
                            int t1 = tsrc[i] + tsrc[i+2] + tsrc[i+1]*2;
                            tdst[i] = t0;
                            tdst[i+width] = t1;
                        }
                    }
                    else
                    {
                        for( i = 0; i < width; i++ )
                        {
                            int t0 = tsrc[i] + tsrc[i+2] - tsrc[i+1]*2;
                            int t1 = tsrc[i+1];
                            tdst[i] = t0;
                            tdst[i+width] = t1;
                        }
                    }
                }
                else if( ker_width == 5 )
                {
                    for( i = 0; i < width; i++ )
                    {
                        int t0 = tsrc[i] + tsrc[i+4] - tsrc[i+2]*2;
                        int t1 = tsrc[i] + tsrc[i+4] + tsrc[i+2]*6 +
                                 (tsrc[i+1] + tsrc[i+3])*4;
                        tdst[i] = t0;
                        tdst[i+width] = t1;
                    }
                }
                else
                {
                    for( i = 0; i < width; i++ )
                    {
                        int j;
                        int t0 = tsrc[i + ker_x]*fmX0;
                        int t1 = tsrc[i + ker_x]*fmY0;

                        for( j = 1; j <= ker_x; j++ )
                        {
                            t0 += (tsrc[i+ker_x+j] + tsrc[i+ker_x-j])*fmaskX[j];
                            t1 += (tsrc[i+ker_x+j] + tsrc[i+ker_x-j])*fmaskY[j];
                        }

                        tdst[i] = t0;
                        tdst[i+width] = t1;
                    }
                }

                if( !need_copy )
                {
                    /* restore borders */
                    CV_COPY( src - ker_x, tbufc - ker_x, ker_x, x );
                    CV_COPY( src + width, tbufc, ker_right, x );
                }
            }

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

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

            for( i = 0; i < ker_y; i++ )
            {
                tdst = rows[i];
                CV_COPY( tdst, trow, width*2, x );
            }
        }

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

        tdst2 = dst;

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

            if( need_copy )
                tdst2 = tbufw;
            else
                CV_COPY( tbufw + width, dst + width, CV_MORPH_ALIGN, x );
        }

        trow = rows[ker_y];

        if( ker_height == 3 )
        {
            int *trow1 = rows[0], *trow2 = rows[2];

            if( y_type == ICV_1_2_1_KERNEL )
            {
                for( x = 0; x < width; x += CV_MORPH_ALIGN )
                {
                    int val0, val1;
                    val0 = trow[x]*2 + trow1[x] + trow2[x] -
                           trow[x+width]*2 + trow1[x+width] + trow2[x+width];
                    val1 = trow[x+1]*2 + trow1[x+1] + trow2[x+1] -
                           trow[x+1+width]*2 + trow1[x+1+width] + trow2[x+1+width];
            
                    tdst2[x + 0] = (short)val0;
                    tdst2[x + 1] = (short)val1;
            
                    val0 = trow[x+2]*2 + trow1[x+2] + trow2[x+2] -
                           trow[x+2+width]*2 + trow1[x+2+width] + trow2[x+2+width];
                    val1 = trow[x+3]*2 + trow1[x+3] + trow2[x+3] -
                           trow[x+3+width]*2 + trow1[x+3+width] + trow2[x+3+width];
            
                    tdst2[x + 2] = (short)val0;
                    tdst2[x + 3] = (short)val1;
                }
            }
            else
            {
                for( x = 0; x < width; x += CV_MORPH_ALIGN )
                {
                    int val0, val1;
                    val0 = trow[x] -
                           trow[x+width]*2 + trow1[x+width] + trow2[x+width];
                    val1 = trow[x+1] -