QT实现傅里叶变换动画

要实现傅里叶变换动画，需要使用以下步骤：

1. 生成需要进行傅里叶变换的信号：可以使用任何一段周期性的信号，比如正弦波、方波等。

2. 对信号进行傅里叶变换：可以使用C++中的FFTW库进行傅里叶变换，也可以手动实现傅里叶变换算法。

3. 将变换结果进行可视化：可以使用QT中的QGraphicsView类或者OpenGL进行可视化。将变换结果以动画的形式展示出来。

以下是一个简单的基于QT的傅里叶变换动画示例代码：

#include <QApplication>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QPainter>
#include <QTimer>
#include <complex>
#include <vector>
#include <fftw3.h>

const int kWidth = 800;
const int kHeight = 500;
const int kSampleRate = 800; // 采样率
const int kDuration = 5; // 信号持续时间

class SignalGenerator {
public:
    explicit SignalGenerator(int sample_rate) : sample_rate_(sample_rate) {}

    std::vector<double> GenerateSignal(double frequency) {
        std::vector<double> signal(sample_rate_ * kDuration);
        for (int i = 0; i < signal.size(); ++i) {
            signal[i] = sin(2 * M_PI * i * frequency / sample_rate_);
        }
        return signal;
    }

private:
    int sample_rate_;
};

class FourierTransformer {
public:
    FourierTransformer(int sample_rate) : sample_rate_(sample_rate) {}

    std::vector<std::complex<double>> Transform(const std::vector<double>& signal) {
        fftw_complex* in = reinterpret_cast<fftw_complex*>(fftw_malloc(sizeof(fftw_complex) * signal.size()));
        fftw_complex* out = reinterpret_cast<fftw_complex*>(fftw_malloc(sizeof(fftw_complex) * signal.size()));
        fftw_plan plan = fftw_plan_dft_r2c_1d(signal.size(), const_cast<double*>(signal.data()), out, FFTW_ESTIMATE);

        for (int i = 0; i < signal.size(); ++i) {
            in[i][0] = signal[i];
            in[i][1] = 0;
        }

        fftw_execute(plan);

        std::vector<std::complex<double>> result(signal.size() / 2 + 1);
        for (int i = 0; i < result.size(); ++i) {
            result[i].real(out[i][0]);
            result[i].imag(out[i][1]);
        }

        fftw_destroy_plan(plan);
        fftw_free(in);
        fftw_free(out);

        return result;
    }

private:
    int sample_rate_;
};

class FourierAnimation : public QGraphicsView {
public:
    FourierAnimation(QWidget* parent = nullptr) : QGraphicsView(parent) {
        setFixedSize(kWidth, kHeight);
        setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        setRenderHint(QPainter::Antialiasing);

        SignalGenerator generator(kSampleRate);
        signal_ = generator.GenerateSignal(100);

        FourierTransformer transformer(kSampleRate);
        spectrum_ = transformer.Transform(signal_);

        scene_ = new QGraphicsScene(this);
        setScene(scene_);

        timer_ = new QTimer(this);
        connect(timer_, &QTimer::timeout, this, &FourierAnimation::OnTimeout);
        timer_->start(20);
    }

    void DrawSignal() {
        QPainterPath path;
        path.moveTo(0, kHeight / 2);
        for (int i = 0; i < signal_.size(); ++i) {
            double x = i * kWidth / static_cast<double>(signal_.size());
            double y = signal_[i] * kHeight / 2 + kHeight / 2;
            path.lineTo(x, y);
        }

        scene_->addPath(path, QPen(Qt::blue));
    }

    void DrawSpectrum() {
        QPainterPath path;
        path.moveTo(0, kHeight / 2);

        double scale = kHeight / 2 / abs(spectrum_[1]);
        for (int i = 1; i < spectrum_.size(); ++i) {
            double x = i * kWidth / static_cast<double>(spectrum_.size());
            double y = abs(spectrum_[i]) * scale;
            path.lineTo(x, kHeight / 2 - y);
        }

        scene_->addPath(path, QPen(Qt::red));
    }

protected:
    void resizeEvent(QResizeEvent* event) override {
        fitInView(scene_->sceneRect(), Qt::KeepAspectRatio);
        QGraphicsView::resizeEvent(event);
    }

private:
    void OnTimeout() {
        scene_->clear();

        DrawSignal();

        DrawSpectrum();

        // 重构信号
        std::vector<std::complex<double>> new_spectrum(spectrum_.size());
        new_spectrum[1] = spectrum_[1];
        for (int i = 2; i < spectrum_.size(); ++i) {
            new_spectrum[i] = spectrum_[i] * exp(std::complex<double>(0, 2 * M_PI * i / static_cast<double>(spectrum_.size())));
        }

        FourierTransformer transformer(kSampleRate);
        std::vector<double> new_signal(signal_.size());
        std::vector<std::complex<double>> new_spectrum_full(spectrum_.size());
        new_spectrum_full[0] = spectrum_[0];
        for (int i = 1; i < new_spectrum.size(); ++i) {
            new_spectrum_full[i] = new_spectrum[i];
            new_spectrum_full[spectrum_.size() - i] = std::conj(new_spectrum[i]);
        }
        new_signal = transformer.TransformBack(new_spectrum_full);

        signal_ = new_signal;
        spectrum_ = new_spectrum_full;
    }

private:
    std::vector<double> signal_;
    std::vector<std::complex<double>> spectrum_;

    QGraphicsScene* scene_;
    QTimer* timer_;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    FourierAnimation animation;
    animation.show();

    return app.exec();
}

这个示例代码中，我们首先使用SignalGenerator类生成一个频率为100Hz的正弦波信号，然后使用FourierTransformer类对信号进行傅里叶变换。变换结果是一个复数向量，表示信号在频域上的幅度和相位信息。

然后我们使用QGraphicsView类创建一个动画窗口，然后在OnTimeout函数中，我们将信号和频谱可视化出来，并重构信号。重构信号的过程是将变换结果通过逆变换转换回时域信号，然后再将其中的高频成分去掉，最后再进行傅里叶变换。这个过程就是傅里叶变换动画的核心了。

最后，我们使用QApplication类创建一个QT应用程序，并显示我们的动画窗口。