图像福利叶变换没有反应，断点调试指向赋初值停止 [复制链接]

我想实现一幅位图的福利叶变换，可是点击按钮后没有反应，断点调试时，指向赋初值那步就停止了（就是w=1.h=1那步），哪位大神帮帮忙看看程序，谢谢啦，其他功能没有任何问题能正常运行
其中 biWidth    = image.width();
    biHeight   = image.height();
    biDataSize = image.byteCount();
    lLineBytes =image.bytesPerLine();
    depth=image.depth();
void ImageProcess::fft(QImage Image)
{
    

        // 中间变量
        double    dTemp;

        // 循环变量
        int    i;
        int    j;

        // 进行付立叶变换的宽度和高度（2的整数次方）
       int    w;
        int    h;

        int        wp;
        int        hp;
      
        BYTE *pByte;
        w = 1;//断点调试，指向这一步就停止了
        h= 1;
        wp = 0;
        hp = 0;

      
        while(w * 2 <=biWidth)
        {
            w *= 2;
            wp++;
        }

        while(h * 2 <= biHeight)
        {
            h *= 2;
            hp++;
        }

        // 分配内存
        std::complex<double> *TD = new std::complex<double>[w * h];
        std::complex<double> *FD = new std::complex<double>[w * h];

        // 行
        for(i = 0; i <  biHeight; i++)
        {
            // 列
            for(j = 0; j < biWidth; j++)
         {
                if(8 == depth) //采用了256色调色板，8位颜色索引
                {
                pByte = Image.bits() + i * lLineBytes + j;
                TD[j + w * i] = std::complex<double>(*(pByte), 0);
                }
                else if(32 == depth)//32位表示，数据格式为0xFFBBGGRR或0xAABBGGRR
                {
                pByte = Image.bits() + i * lLineBytes + j * 4;
                //根据RGB模式转化成YIQ色彩模式的方式，取Y作为灰度值
                BYTE pixelValue = (BYTE)(0.299 * (float)pByte[0] + 0.587 * (float)pByte[1]
                + 0.114 * (float)pByte[2]);
                 TD[j + w * i] = std::complex<double>( pixelValue, 0);
                }
                else
                {
                
                return;
                }
                memcpy(Image.bits(), pByte, biDataSize);

            }
        }

        for(i = 0; i <  biHeight; i++)
        {
            // 对y方向进行快速付立叶变换
            onfft(&TD[w * i], &FD[w * i], wp);
        }

        // 保存变换结果
        for(i = 0; i <  biHeight; i++)
        {
            for(j = 0; j <biWidth; j++)
            {
                TD[i + h * j] = FD[j + w * i];
            }
        }

        for(i = 0; i < biWidth; i++)
        {
            // 对x方向进行快速付立叶变换
            onfft(&TD[i * h], &FD[i * h], hp);
        }

        // 行
        for(i = 0; i < biHeight; i++)
        {
            // 列
            for(j = 0; j <  biWidth; j++)
            {
                // 计算频谱
                dTemp = sqrt(FD[j * h + i].real() * FD[j * h + i].real() +
                             FD[j * h + i].imag() * FD[j * h + i].imag()) / 100;

                // 判断是否超过255
                if (dTemp > 255)
                {
                    // 对于超过的，直接设置为255
                    dTemp = 255;
                }

  
               if(8 == depth) //采用了256色调色板，8位颜色索引
                {
                pByte = Image.bits() + i * lLineBytes + j;
                *pByte = dTemp;
                }
                else if(32 == depth)//32位表示，数据格式为0xFFBBGGRR或0xAABBGGRR
                {
                pByte = Image.bits() + i * lLineBytes + j * 4;
              
               pByte[0] = pByte[1] = pByte[2] = dTemp;
                }
                else
                {

                return;
                }


                // 更新源图像
              
               memcpy(Image.bits(), pByte, biDataSize);
            }
            
        }

        // 删除临时变量
        delete TD;
        delete FD;
      



}

void ImageProcess::onfft(const std:: complex<double> a[], std::complex<double> y[], int power)

{
    if(0 == power)
    {
    y[0] = a[0];
    return;
    }
    int n = 1 << power;
    double angle = 2 * PI / n;
    std::complex<double> wn(cos(angle), sin(angle));
    std::complex<double> w(1, 0);
    std::complex<double> *a0 = new std::complex<double>[n / 2];
    std::complex<double> *a1 = new std::complex<double>[n / 2];
    std::complex<double> *y0 = new std::complex<double>[n / 2];
    std::complex<double> *y1 = new std::complex<double>[n / 2];
    for(int i = 0; i < n / 2; i ++)
    {
    a0 = a[2 * i];
    a1 = a[2 * i + 1];
    }
    //分开成两个子fft过程
    onfft(a0, y0, power - 1);
    onfft(a1, y1, power - 1);
    std::complex<double> u;
    for(int k = 0; k < n / 2; k++) //蝶形算法
    {
    u = w * y1[k];
    y[k] = y0[k] + u;
    y[k + n / 2] = y0[k] - u;
    w = w * wn;
    }
    delete[] a0;
    delete[] a1;
    delete[] y0;
    delete[] y1;




}