⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 cxdxt.cpp

📁 opencv库在TI DM6437上的移植,目前包括两个库cv.lib和cxcore.lib的工程
💻 CPP
📖 第 1 页 / 共 5 页
字号:
            double t1 = -dst[i+1].im;
            dst[i].im = (float)t0;
            dst[i+1].im = (float)t1;
        }

        if( i < n0 )
            dst[n0-1].im = -dst[n0-1].im;
    }

    return CV_OK;
}


/* FFT of real vector
   output vector format:
     re(0), re(1), im(1), ... , re(n/2-1), im((n+1)/2-1) [, re((n+1)/2)] OR ...
     re(0), 0, re(1), im(1), ..., re(n/2-1), im((n+1)/2-1) [, re((n+1)/2), 0] */
#define ICV_REAL_DFT( flavor, datatype )                                \
static CvStatus CV_STDCALL                                              \
icvRealDFT_##flavor( const datatype* src, datatype* dst,                \
                     int n, int nf, int* factors, const int* itab,      \
                     const CvComplex##flavor* wave, int tab_size,       \
                     const void* spec, CvComplex##flavor* buf,          \
                     int flags, double scale )                          \
{                                                                       \
    int complex_output = (flags & ICV_DFT_COMPLEX_INPUT_OR_OUTPUT) != 0;\
    int j, n2 = n >> 1;                                                 \
    dst += complex_output;                                              \
                                                                        \
    if( spec )                                                          \
    {                                                                   \
        icvDFTFwd_RToPack_##flavor##_p( src, dst, spec, buf );          \
        goto finalize;                                                  \
    }                                                                   \
                                                                        \
    assert( tab_size == n );                                            \
                                                                        \
    if( n == 1 )                                                        \
    {                                                                   \
        dst[0] = (datatype)(src[0]*scale);                              \
    }                                                                   \
    else if( n == 2 )                                                   \
    {                                                                   \
        double t = (src[0] + src[1])*scale;                             \
        dst[1] = (datatype)((src[0] - src[1])*scale);                   \
        dst[0] = (datatype)t;                                           \
    }                                                                   \
    else if( n & 1 )                                                    \
    {                                                                   \
        dst -= complex_output;                                          \
        CvComplex##flavor* _dst = (CvComplex##flavor*)dst;              \
        _dst[0].re = (datatype)(src[0]*scale);                          \
        _dst[0].im = 0;                                                 \
        for( j = 1; j < n; j += 2 )                                     \
        {                                                               \
            double t0 = src[itab[j]]*scale;                             \
            double t1 = src[itab[j+1]]*scale;                           \
            _dst[j].re = (datatype)t0;                                  \
            _dst[j].im = 0;                                             \
            _dst[j+1].re = (datatype)t1;                                \
            _dst[j+1].im = 0;                                           \
        }                                                               \
        icvDFT_##flavor##c( _dst, _dst, n, nf, factors, itab, wave,     \
                            tab_size, 0, buf, ICV_DFT_NO_PERMUTE, 1. ); \
        if( !complex_output )                                           \
            dst[1] = dst[0];                                            \
        return CV_OK;                                                   \
    }                                                                   \
    else                                                                \
    {                                                                   \
        double t0, t;                                                   \
        double h1_re, h1_im, h2_re, h2_im;                              \
        double scale2 = scale*0.5;                                      \
        factors[0] >>= 1;                                               \
                                                                        \
        icvDFT_##flavor##c( (CvComplex##flavor*)src,                    \
                            (CvComplex##flavor*)dst, n2,                \
                            nf - (factors[0] == 1),                     \
                            factors + (factors[0] == 1),                \
                            itab, wave, tab_size, 0, buf, 0, 1. );      \
        factors[0] <<= 1;                                               \
                                                                        \
        t = dst[0] - dst[1];                                            \
        dst[0] = (datatype)((dst[0] + dst[1])*scale);                   \
        dst[1] = (datatype)(t*scale);                                   \
                                                                        \
        t0 = dst[n2];                                                   \
        t = dst[n-1];                                                   \
        dst[n-1] = dst[1];                                              \
                                                                        \
        for( j = 2, wave++; j < n2; j += 2, wave++ )                    \
        {                                                               \
            /* calc odd */                                              \
            h2_re = scale2*(dst[j+1] + t);                              \
            h2_im = scale2*(dst[n-j] - dst[j]);                         \
                                                                        \
            /* calc even */                                             \
            h1_re = scale2*(dst[j] + dst[n-j]);                         \
            h1_im = scale2*(dst[j+1] - t);                              \
                                                                        \
            /* rotate */                                                \
            t = h2_re*wave->re - h2_im*wave->im;                        \
            h2_im = h2_re*wave->im + h2_im*wave->re;                    \
            h2_re = t;                                                  \
            t = dst[n-j-1];                                             \
                                                                        \
            dst[j-1] = (datatype)(h1_re + h2_re);                       \
            dst[n-j-1] = (datatype)(h1_re - h2_re);                     \
            dst[j] = (datatype)(h1_im + h2_im);                         \
            dst[n-j] = (datatype)(h2_im - h1_im);                       \
        }                                                               \
                                                                        \
        if( j <= n2 )                                                   \
        {                                                               \
            dst[n2-1] = (datatype)(t0*scale);                           \
            dst[n2] = (datatype)(-t*scale);                             \
        }                                                               \
    }                                                                   \
                                                                        \
finalize:                                                               \
    if( complex_output )                                                \
    {                                                                   \
        dst[-1] = dst[0];                                               \
        dst[0] = 0;                                                     \
        if( (n & 1) == 0 )                                              \
            dst[n] = 0;                                                 \
    }                                                                   \
                                                                        \
    return CV_OK;                                                       \
}


/* Inverse FFT of complex conjugate-symmetric vector
   input vector format:
      re[0], re[1], im[1], ... , re[n/2-1], im[n/2-1], re[n/2] OR
      re(0), 0, re(1), im(1), ..., re(n/2-1), im((n+1)/2-1) [, re((n+1)/2), 0] */
#define ICV_CCS_IDFT( flavor, datatype )                                \
static CvStatus CV_STDCALL                                              \
icvCCSIDFT_##flavor( const datatype* src, datatype* dst,                \
                     int n, int nf, int* factors, const int* itab,      \
                     const CvComplex##flavor* wave, int tab_size,       \
                     const void* spec, CvComplex##flavor* buf,          \
                     int flags, double scale )                          \
{                                                                       \
    int complex_input = (flags & ICV_DFT_COMPLEX_INPUT_OR_OUTPUT) != 0; \
    int j, k, n2 = (n+1) >> 1;                                          \
    double save_s1 = 0.;                                                \
    double t0, t1, t2, t3, t;                                           \
                                                                        \
    assert( tab_size == n );                                            \
                                                                        \
    if( complex_input )                                                 \
    {                                                                   \
        assert( src != dst );                                           \
        save_s1 = src[1];                                               \
        ((datatype*)src)[1] = src[0];                                   \
        src++;                                                          \
    }                                                                   \
                                                                        \
    if( spec )                                                          \
    {                                                                   \
        icvDFTInv_PackToR_##flavor##_p( src, dst, spec, buf );          \
        goto finalize;                                                  \
    }                                                                   \
                                                                        \
    if( n == 1 )                                                        \
    {                                                                   \
        dst[0] = (datatype)(src[0]*scale);                              \
    }                                                                   \
    else if( n == 2 )                                                   \
    {                                                                   \
        t = (src[0] + src[1])*scale;                                    \
        dst[1] = (datatype)((src[0] - src[1])*scale);                   \
        dst[0] = (datatype)t;                                           \
    }                                                                   \
    else if( n & 1 )                                                    \
    {                                                                   \
        CvComplex##flavor* _src = (CvComplex##flavor*)(src-1);          \
        CvComplex##flavor* _dst = (CvComplex##flavor*)dst;              \
                                                                        \
        _dst[0].re = src[0];                                            \
        _dst[0].im = 0;                                                 \
        for( j = 1; j < n2; j++ )                                       \
        {                                                               \
            int k0 = itab[j], k1 = itab[n-j];                           \
            t0 = _src[j].re; t1 = _src[j].im;                           \
            _dst[k0].re = (datatype)t0; _dst[k0].im = (datatype)-t1;    \
            _dst[k1].re = (datatype)t0; _dst[k1].im = (datatype)t1;     \
        }                                                               \
                                                                        \
        icvDFT_##flavor##c( _dst, _dst, n, nf, factors, itab, wave,     \
                            tab_size, 0, buf, ICV_DFT_NO_PERMUTE, 1. ); \
        dst[0] = (datatype)(dst[0]*scale);                              \
        for( j = 1; j < n; j += 2 )                                     \
        {                                                               \
            t0 = dst[j*2]*scale;                                        \
            t1 = dst[j*2+2]*scale;                                      \
            dst[j] = (datatype)t0;                                      \
            dst[j+1] = (datatype)t1;                                    \
        }                                                               \
    }                                                                   \
    else                                                                \
    {                                                                   \
        int inplace = src == dst;                                       \
        const CvComplex##flavor* w = wave;                              \
                                                                        \
        t = src[1];                                                     \
        t0 = (src[0] + src[n-1]);                                       \
        t1 = (src[n-1] - src[0]);                                       \
        dst[0] = (datatype)t0;                                          \
        dst[1] = (datatype)t1;                                          \
                                                                        \
        for( j = 2, w++; j < n2; j += 2, w++ )                          \
        {                                                               \
            double h1_re, h1_im, h2_re, h2_im;                          \
                                                                        \
            h1_re = (t + src[n-j-1]);                                   \
            h1_im = (src[j] - src[n-j]);                                \
                                                                        \
            h2_re = (t - src[n-j-1]);                                   \
            h2_im = (src[j] + src[n-j]);                                \
                                                                        \
            t = h2_re*w->re + h2_im*w->im;                              \
            h2_im = h2_im*w->re - h2_re*w->im;                          \
            h2_re = t;                                                  \
                                                                        \
            t = src[j+1];                                               \
            t0 = h1_re - h2_im;                                         \
            t1 = -h1_im - h2_re;                                        \
            t2 = h1_re + h2_im;                                         \
            t3 = h1_im - h2_re;                                         \
                                                                        \
            if( inplace )                                               \
            {                                                           \
                dst[j] = (datatype)t0;                                  \
                dst[j+1] = (datatype)t1;                                \
                dst[n-j] = (datatype)t2;                                \
                dst[n-j+1]= (datatype)t3;                               \
            }                                                           \
            else                                                        \
            {                                                           \
                int j2 = j >> 1;                                        \
                k = itab[j2];                                           \
                dst[k] = (datatype)t0;                                  \
                dst[k+1] = (datatype)t1;                                \
                k = itab[n2-j2];                                        \
                dst[k] = (datatype)t2;                                  \
                dst[k+1]= (datatype)t3;                                 \
            }                                                           \
        }                                                               \
                                                                        \
        if( j <= n2 )                                                   \
        {                                                               \
            t0 = t*2;                                                   \
            t1 = src[n2]*2;                                             \
                                                                        \
            if( inplace )                                               \
            {                                                           \
                dst[n2] = (datatype)t0;                                 \
                dst[n2+1] = (datatype)t1;                               \
            }                                                           \
            else                                                        \
            {                                                           \
                k = itab[n2];                                           \
                dst[k*2] = (datatype)t0;                                \
                dst[k*2+1] = (datatype)t1;                              \
            }                                                           \
        }                                                               \
                                                                        \
        factors[0] >>= 1;                                               \
        icvDFT_##flavor##c( (CvComplex##flavor*)dst,                    \
                            (CvComplex##flavor*)dst, n2,                \
                            nf - (factors[0] == 1),                     \
                            factors + (factors[0] == 1), itab,          \
                            wave, tab_size, 0, buf,                     \
                            inplace ? 0 : ICV_DFT_NO_PERMUTE, 1. );     \
        factors[0] <<= 1;                                               \
                                                                        \
        for( j = 0; j < n; j += 2 )                                     \
        {                                                               \
            t0 = dst[j]*scale;                                          \
            t1 = dst[j+1]*(-scale);                                     \
            dst[j] = (datatype)t0;                                      \
            dst[j+1] = (datatype)t1;                                    \
        }                                                               \
    }                                                                   \
                                                                        \
finalize:                                                               \
    if( complex_input )                                                 \
        ((datatype*)src)[0] = (datatype)save_s1;                        \
                                                                        \
    return CV_OK;                                                       \
}


ICV_REAL_DFT( 64f, double )
ICV_CCS_IDFT( 64f, double )
ICV_REAL_DFT( 32f, float )
ICV_CCS_IDFT( 32f, float )


static void
icvCopyColumn( const uchar* _src, int src_step,
               uchar* _dst, int dst_step,
               int len, int elem_size )
{
    int i, t0, t1;
    const int* src = (const int*)_src;
    int* dst = (int*)_dst;
    src_step /= sizeof(src[0]);
    dst_step /= sizeof(dst[0]

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -