cvdxt.cpp.svn-base

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

                                                                            \
    if( n % 2 == 0 )                                                        \
    {                                                                       \
        double s0 = 0, s1 = 0;                                              \
        real_datatype p, m;                                                 \
                                                                            \
        p = src[0] + src[n2];                                               \
        m = src[0] - src[n2];                                               \
                                                                            \
        for( i = 0; i < n; i += 2 )                                         \
        {                                                                   \
            double t0, t1;                                                  \
                                                                            \
            t0 = src[i];                                                    \
            t1 = src[i+1];                                                  \
                                                                            \
            s0 += t0 + t1;                                                  \
            s1 += t0 - t1;                                                  \
        }                                                                   \
                                                                            \
        dst[0] = (real_datatype)s0;                                         \
        for( i = 1; i <= n-5; i += 4 )                                      \
        {                                                                   \
            dst[i] = m;                                                     \
            dst[i+2] = p;                                                   \
        }                                                                   \
                                                                            \
        if( i < n-1 )                                                       \
            dst[i] = m;                                                     \
        dst[n-1] = (real_datatype)s1;                                       \
    }                                                                       \
    else                                                                    \
    {                                                                       \
        double s = 0;                                                       \
        real_datatype p = src[0];                                           \
                                                                            \
        for( i = 0; i < n; i++ )                                            \
            s += src[i];                                                    \
                                                                            \
        dst[0] = (real_datatype)s;                                          \
        for( i = 1; i < n; i += 2 )                                         \
            dst[i] = p;                                                     \
    }                                                                       \
                                                                            \
    for( i = 1; i < n - 1; i += 2 )                                         \
    {                                                                       \
        double s_re = dst[i], s_im = 0;                                     \
        double c = c0, s = s0, t;                                           \
                                                                            \
        for( j = 1; j < n2; j++ )                                           \
        {                                                                   \
            s_re += c*(src[j] + src[n-j]);                                  \
            s_im += s*(src[j] - src[n-j]);                                  \
                                                                            \
            t = c*c0 - s*s0;                                                \
            s = s*c0 + c*s0;                                                \
            c = t;                                                          \
        }                                                                   \
                                                                            \
        dst[i] = (real_datatype)s_re;                                       \
        dst[i+1] = (real_datatype)s_im;                                     \
                                                                            \
        t = c0*c00 - s0*s00;                                                \
        s0 = s0*c00 + c0*s00;                                               \
        c0 = t;                                                             \
    }                                                                       \
                                                                            \
    return CV_OK;                                                           \
}                                                                           \
                                                                            \
                                                                            \
/* simple (direct) inverse DFT of arbitrary size ccs vector */              \
static CvStatus icvDFT_inv_##flavor( const real_datatype* src,              \
                                     real_datatype* dst, int n, int )       \
{                                                                           \
    double scale = CV_PI*2/n;                                               \
    double c00 = cos(scale);                                                \
    double s00 = sin(scale);                                                \
    double c0 = c00, s0 = s00;                                              \
    int i, j, n2 = (n+1) >> 1;                                              \
                                                                            \
    if( n % 2 == 0 )                                                        \
    {                                                                       \
        double s0_re, s1_re;                                                \
        double p, m;                                                        \
                                                                            \
        p = src[0] + src[n-1];                                              \
        m = src[0] - src[n-1];                                              \
                                                                            \
        s0_re = 0;                                                          \
        s1_re = 0;                                                          \
                                                                            \
        for( i = 1; i <= n2-2; i += 2 )                                     \
        {                                                                   \
            double t0, t1;                                                  \
                                                                            \
            t0 = src[i*2-1];                                                \
            t1 = src[i*2+1];                                                \
                                                                            \
            s0_re += t1 + t0;                                               \
            s1_re += t1 - t0;                                               \
                                                                            \
            dst[i] = dst[n-i] = (real_datatype)m;                           \
            dst[i+1] = dst[n-i-1] = (real_datatype)p;                       \
        }                                                                   \
                                                                            \
        s0_re *= 2;                                                         \
        s1_re *= 2;                                                         \
                                                                            \
        if( i < n2 )                                                        \
        {                                                                   \
            s0_re += src[n-3]*2;                                            \
            s1_re += (src[n-1] - src[n-3])*2;                               \
            dst[n2-1] = dst[n2+1] = (real_datatype)m;                       \
        }                                                                   \
                                                                            \
        dst[0] = (real_datatype)(s0_re + p);                                \
        dst[n2] = (real_datatype)(s1_re + m);                               \
    }                                                                       \
    else                                                                    \
    {                                                                       \
        double s_re = 0;                                                    \
        double p0 = src[0];                                                 \
                                                                            \
        for( i = 1; i < n2; i++ )                                           \
        {                                                                   \
            s_re += src[i*2-1];                                             \
            dst[i] = dst[n-i] = (real_datatype)p0;                          \
        }                                                                   \
                                                                            \
        dst[0] = (real_datatype)(s_re*2 + p0);                              \
    }                                                                       \
                                                                            \
    for( i = 1; i < n2; i++ )                                               \
    {                                                                       \
        double s0_re = 0, s1_re = 0;                                        \
        double c = c0, s = s0, t;                                           \
                                                                            \
        for( j = 1; j < n-1; j += 2 )                                       \
        {                                                                   \
            double t0 = c*src[j];                                           \
            double t1 = s*src[j+1];                                         \
                                                                            \
            s0_re += t0 - t1;                                               \
            s1_re += t0 + t1;                                               \
                                                                            \
            t = c*c0 - s*s0;                                                \
            s = s*c0 + c*s0;                                                \
            c = t;                                                          \
        }                                                                   \
                                                                            \
        dst[i] += (real_datatype)(s0_re*2);                                 \
        dst[n-i] += (real_datatype)(s1_re*2);                               \
                                                                            \
        t = c0*c00 - s0*s00;                                                \
        s0 = s0*c00 + c0*s00;                                               \
        c0 = t;                                                             \
    }                                                                       \
                                                                            \
    return CV_OK;                                                           \
}


ICV_DFT_FUNCS( 32f, CvPoint2D32f, float )
ICV_DFT_FUNCS( 64f, CvPoint2D64f, double )

static void
icvConjugate( CvMat* mat )
{
    /*CV_FUNCNAME( "icvConjugate" );*/

    __BEGIN__;

    int j, cols = mat->cols*2, rows = mat->rows;

    if( CV_MAT_DEPTH(mat->type) == CV_32F )
    {
        int* data = (int*)mat->data.ptr;
        for( ; rows-- ; (char*&)data += mat->step )
        {
            for( j = 0; j <= cols - 4; j += 4 )
            {
                int t0 = data[j+1] ^ INT_MIN;
                int t1 = data[j+3] ^ INT_MIN;
                data[j+1] = t0;
                data[j+3] = t1;
            }

            if( j < cols )
                data[j+1] ^= INT_MIN;
        }
    }
    else
    {
        double* data = (double*)mat->data.ptr;
        for( ; rows-- ; (char*&)data += mat->step )
        {
            for( j = 0; j <= cols - 4; j += 4 )
            {
                double t0 = -data[j+1];
                double t1 = -data[j+3];
                data[j+1] = t0;
                data[j+3] = t1;
            }

            if( j < cols )
                data[j+1] = -data[j+1];
        }
    }

    __END__;
}


static void
icvScale( CvMat* mat, double _re_scale, double _im_scale )
{
    /*CV_FUNCNAME( "icvScale" );*/

    __BEGIN__;

    int j, cols = mat->cols*CV_MAT_CN(mat->type), rows = mat->rows;
    int is_1d = rows == 1 || (cols == 1 && CV_IS_MAT_CONT(mat->type));

    if( CV_MAT_DEPTH(mat->type) == CV_32F )
    {
        float re_scale = (float)_re_scale;
        float im_scale = (float)_im_scale;
        float* data = (float*)mat->data.ptr;

        if( is_1d )
        {
            int len = cols + rows - 1;

            if( CV_MAT_CN(mat->type) == 1 )
            {
                data[0] *= re_scale;
                if( len % 2 == 0 )
                    data[len-1] *= re_scale;
                data += 1;
                len = (len - 1) & -2;
            }

            for( j = 0; j < len; j += 2 )
            {
                float t0 = data[j]*re_scale;
                float t1 = data[j+1]*im_scale;

                data[j] = t0;
                data[j+1] = t1;
            }
        }
        else
        {
            int step = mat->step/sizeof(float);

            if( CV_MAT_CN(mat->type) == 1 )
            {
                data[0] *= re_scale;
                if( rows % 2 == 0 )
                    data[(rows-1)*step] *= re_scale;

                for( j = 1; j <= rows - 2; j += 2 )
                {
                    data[j*step] *= re_scale;
                    data[(j+1)*step] *= im_scale;
                }