FFT

    void FFTHelper(std::valarray<std::complex<float>>& Data)
    {
        const size_t N = Data.size();
        if (N <= 1) return;

        std::valarray<std::complex<float>> even = Data[std::slice(0, N / 2, 2)];
        std::valarray<std::complex<float>> odd = Data[std::slice(1, N / 2, 2)];

        FFTHelper(even);
        FFTHelper(odd);

        for (size_t k = 0; k < N / 2; ++k)
        {
            std::complex<float> t = std::polar(1.0f, (float)(-2 * LUMINOS_PI * k / N)) * odd[k];
            Data[k] = even[k] + t;
            Data[k + N / 2] = even[k] - t;
        }
    }

    luminos_vector<std::complex<float>> FFT(luminos_vector<std::complex<float>> InputData, uint32_t Width, uint32_t Height)
    {
        luminos_vector<std::complex<float>> res;

        for (int i = 0; i < Height; i++)
        {
            std::valarray<std::complex<float>> Data(InputData.data() + i * Width, InputData.size() / Height);
            FFTHelper(Data);
            for (auto i : Data)
            {
                res.push_back(i);
            }
        }

        luminos_vector<std::complex<float>> tmp(Width * Height);
        for (int i = 0; i < Width * Height; i++)
        {
            tmp[i] = res[Width * Height - 1 - i];
        }
        res.clear();
        for (int i = 0; i < Height; i++)
        {
            std::valarray<std::complex<float>> Data(tmp.data() + i * Width, tmp.size() / Height);
            FFTHelper(Data);
            for (auto i : Data)
            {
                res.push_back(i);
            }
        }
        for (int i = 0; i < Width * Height; i++)
        {
            res.push_back(tmp[Width * Height - 1 - i]);
        }
        return res;
    }

    void IFFTHelper(std::valarray<std::complex<float>>& Data)
    {
        Data = Data.apply(std::conj);
        FFTHelper(Data);
        Data = Data.apply(std::conj);
        Data /= Data.size();
    }

    luminos_vector<std::complex<float>> IFFT(luminos_vector<std::complex<float>> InputData, uint32_t Width, uint32_t Height)
    {
        luminos_vector<std::complex<float>> res;
        luminos_vector<std::complex<float>> tmp;

        for (auto i = 0; i < Width * Height; i++)
        {
            res.push_back(InputData[Width * Height - 1 - i]);
        }

        for (auto i = 0; i < Height; i++)
        {
            std::valarray<std::complex<float>> Data(res.data() + (i * Width), res.size() / Height);
            IFFTHelper(Data);
            for (auto i : Data)
            {
                tmp.push_back(i);
            }
        }
        res.clear();

        for (auto i = 0; i < Width * Height; i++)
        {
            res.push_back(tmp[Width * Height - 1 - i]);
        }
        for (auto i = 0; i < Height; i++)
        {
            std::valarray<std::complex<float>> Data(res.data() + (i * Width), res.size() / Height);
            IFFTHelper(Data);
            for (auto i : Data)
            {
                tmp.push_back(i);
            }
        }

        return tmp;
    }