C++ C++；FFTW向前向后DFT值被包装

大家好，我的社区， 我对fftw库的dft算法有一个问题。 我所要做的就是向前和向后转换某个模式，以再次接收输入模式，当然稍后在转换之间会有某种过滤

所以，我的程序所做的是：

创建一个测试信号

用1.0或0.5的值对测试信号进行滤波或“窗口化”

将测试信号复制到fftw_复杂数据类型

执行向前和向后dft

计算震级，这里称为相位

复制和调整数据以便于显示，最后通过OpenCV显示图像

我的问题是，当不使用过滤时，我的后向变换图像以某种方式被包装，我无法计算正确的幅度，这应该与我的输入图像/测试信号一致。 当我将fitler/“window”的值设置为0.5时，后向变换可以很好地工作，但我的输入图像的亮度只有应有的一半

下图说明了我的问题：（从左上到右下） 1.输入信号，2。后向变换的实部，3。从后向变换数据计算出震级，4。输入信号乘以0.5，5。后向变换的实部，6。从向后转换的数据计算出震级。

有人知道dft为什么会这样运行吗？！有点奇怪

我的代码看起来像这个自动取款机：

/***** parameters **************************************************************************/
int     imSize                                          = 256;
int     imN                                             = imSize * imSize;

char*   interferogram                                   = new char[imN];
double* spectrumReal                                    = new double[imN];
double* spectrumImaginary                               = new double[imN];
double* outputReal                                      = new double[imN];
double* outputImaginary                                 = new double[imN];
double* phase                                           = new double[imN];

char*   spectrumRealChar                                = new char[imN];
char*   spectrumImaginaryChar                           = new char[imN];
char*   outputRealChar                                  = new char[imN];
char*   outputImaginaryChar                             = new char[imN];
char*   phaseChar                                       = new char[imN];

Mat     interferogramMat                                = Mat(imSize, imSize, CV_8U, interferogram);
Mat     spectrumRealCharMat                             = Mat(imSize, imSize, CV_8U, spectrumRealChar);
Mat     spectrumImaginaryCharMat                        = Mat(imSize, imSize, CV_8U, spectrumImaginaryChar);
Mat     outputRealCharMat                               = Mat(imSize, imSize, CV_8U, outputRealChar);
Mat     outputImaginaryCharMat                          = Mat(imSize, imSize, CV_8U, outputImaginaryChar);
Mat     phaseCharMat                                    = Mat(imSize, imSize, CV_8U, phaseChar);


/***** compute interferogram ****************************************************************/
fill_n(interferogram, imN, 0);
double value = 0;
double window = 0;

for (int y = 0; y < imSize; y++)
{
    for (int x = 0; x < imSize; x++)
    {
        value = 127.5 + 127.5 * cos((2*PI) / 10000 * (pow(double(x - imSize/2), 2) + pow(double(y - imSize/2), 2)));

        window = 1;
        value *= window;

        interferogram[y * imSize + x] = (unsigned char)value;
    }
}


/***** create fftw arays and plans **********************************************************/
fftw_complex*       input;
fftw_complex*       spectrum;
fftw_complex*       output;
fftw_plan           p_fw;
fftw_plan           p_bw;

input               = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * imN);
spectrum            = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * imN);
output              = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * imN);
p_fw                = fftw_plan_dft_2d(imSize, imSize, input, spectrum, FFTW_FORWARD, FFTW_ESTIMATE);
p_bw                = fftw_plan_dft_2d(imSize, imSize, spectrum, output, FFTW_BACKWARD, FFTW_ESTIMATE);


/***** copy data ****************************************************************************/
for (int i = 0; i < imN; i++)
{
    input[i][0] = double(interferogram[i]) / 255.;
    input[i][1] = 0.;
    spectrum[i][0] = 0.;
    spectrum[i][1] = 0.;
    output[i][0] = 0.;
    output[i][1] = 0.;
}


/***** FPS algorithm ************************************************************************/
fftw_execute(p_fw);

fftw_execute(p_bw);

for (int i = 0; i < imN; i++)
{
    phase[i] = sqrt(pow(output[i][0], 2) + pow(output[i][1], 2));
}


/***** copy data ****************************************************************************/
for (int i = 0; i < imN; i++)
{
    spectrumReal[i] = spectrum[i][0];
    spectrumImaginary[i] = spectrum[i][1];

    outputReal[i] = output[i][0] / imN;
    outputImaginary[i] = output[i][1];
}

SaveCharImage(interferogram, imN, "01_interferogram_512px_8bit.raw");
SaveDoubleImage(spectrumReal, imN, "02_spectrum_real_512px_64bit.raw");
SaveDoubleImage(spectrumImaginary, imN, "03_spectrum_imaginary_512px_64bit.raw");
SaveDoubleImage(outputReal, imN, "03_output_real_512px_64bit.raw");

DoubleToCharArray(spectrumReal, spectrumRealChar, imSize);
DoubleToCharArray(spectrumImaginary, spectrumImaginaryChar, imSize);

DoubleToCharArray(outputReal, outputRealChar, imSize);
DoubleToCharArray(outputImaginary, outputImaginaryChar, imSize);

DoubleToCharArray(phase, phaseChar, imSize);


/***** show images **************************************************************************/

imshow("interferogram", interferogramMat);
imshow("spectrum real", spectrumRealCharMat);
imshow("spectrum imaginary", spectrumImaginaryCharMat);
imshow("out real", outputRealCharMat);
imshow("out imaginary", outputImaginaryCharMat);
imshow("phase", phaseCharMat);

int key = waitKey(0);

/****参数**************************************************************************/
int imSize=256；
int imN=imSize*imSize；
字符*干涉图=新字符[imN]；
double*spectrumReal=新的double[imN]；
double*SpectrumMaginary=新双精度[imN]；
double*outputReal=新的double[imN]；
double*OutputMaginary=新的双精度[imN]；
双*相位=新双[imN]；
char*spectrumRealChar=新字符[imN]；
char*spectrumImaginaryChar=新字符[imN]；
char*outputRealChar=新字符[imN]；
char*outputImaginaryChar=新字符[imN]；
char*phaseChar=新字符[imN]；
Mat干涉图=Mat（imSize，imSize，CV_8U，干涉图）；
Mat spectrumRealCharMat=Mat（imSize，imSize，CV_8U，spectrumRealChar）；
Mat spectrumImaginaryCharMat=Mat（imSize，imSize，CV_8U，spectrumImaginaryChar）；
Mat outputRealCharMat=Mat（imSize，imSize，CV_8U，outputRealChar）；
Mat outputImaginaryCharMat=Mat（imSize，imSize，CV_8U，outputImaginaryChar）；
Mat phaseCharMat=Mat（imSize，imSize，CV_8U，phaseChar）；
/*****计算干涉图****************************************************************/
填充n（干涉图，imN，0）；
双值=0；
双窗口=0；
对于（int y=0；ychar*   interferogram  = new char[imN];
...
double value = 0;
double window = 0;

for (int y = 0; y < imSize; y++)
{
   for (int x = 0; x < imSize; x++)
   {
      value = 127.5 + 127.5 * cos((2*PI) / 10000 * (pow(double(x - imSize/2), 2) + pow(double(y - imSize/2), 2)));

      window = 1;
      value *= window;

      interferogram[y * imSize + x] = (unsigned char)value;
   }
}

outputReal[i] = output[i][0] / imN;
outputImaginary[i] = output[i][1];

outputReal[i] = output[i][0];
outputImaginary[i] = output[i][1];