marvin_Windows.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_MATHWINDOWS_H
#define MARVIN_MATHWINDOWS_H
#include <marvin/math/marvin_Math.h>
#include <marvin/library/marvin_Concepts.h>
#include <marvin/library/marvin_Literals.h>
#include <numbers>
#include <cmath>
namespace marvin::math::windows {

    enum class WindowType {
        Sine,
        Tukey,
        BlackmanHarris,
        CosineSum,
        Hann,
        Hamming
    };

    template <marvin::FloatType SampleType, size_t NumPoints>
    class PrecomputedWindow final {
    public:
        explicit PrecomputedWindow(std::array<SampleType, NumPoints>&& lut) : m_lut(std::move(lut)) {
        }

        [[nodiscard]] SampleType operator()(SampleType proportion) const {
            using namespace marvin::literals;
            const auto rescaled = proportion * (NumPoints - 1_sz);
            const auto truncated = std::trunc(rescaled);
            const auto delta = rescaled - truncated;
            const auto index0{ static_cast<size_t>(truncated) };
            const auto index1 = index0 + 1;
            const auto pointA = m_lut[index0];
            const auto pointB = m_lut[index1];
            const auto interpolated = marvin::math::lerp(pointA, pointB, delta);
            return interpolated;
        }
 
    private:
        std::array<SampleType, NumPoints> m_lut;
    };

    template <FloatType SampleType>
    [[nodiscard]] SampleType sine(SampleType n, SampleType N) {
        static constexpr auto pi = std::numbers::pi_v<SampleType>;
        const auto window = std::sin((pi * n) / (N - 1));
        return window;
    }

    template <FloatType SampleType>
    [[nodiscard]] SampleType tukey(SampleType n, SampleType NumPoints, SampleType alpha) {
        // 0.5 * (1 - cos(2pin/alphaN)), 0 <= n <= aN / 2
        // 1, aN/2 <= n <= N / 2
        // w[N - n] = w[n], 0 <= n <= N / 2
        const auto N{ NumPoints - 1 };
        const auto alphaN = alpha * N;
        const auto NOverTwo = N / static_cast<SampleType>(2.0);
        const auto aNOverTwo = alphaN / static_cast<SampleType>(2.0);
        if (n >= 0 && n <= aNOverTwo) {
            // 0.5 * (1 - cos(2pin / alphaN))
            constexpr static auto twoPi = static_cast<SampleType>(2.0) * std::numbers::pi_v<SampleType>;
            const auto cosine = std::cos((twoPi * n) / alphaN);
            const auto res = static_cast<SampleType>(0.5) * (static_cast<SampleType>(1.0 - cosine));
            return res;
        } else if (n > aNOverTwo && n <= NOverTwo) {
            return static_cast<SampleType>(1.0);
        } else {
            const auto reverseIndex = N - n;
            return tukey(reverseIndex, N, alpha);
        }
    }

    template <FloatType SampleType>
    [[nodiscard]] SampleType blackmanHarris(SampleType n, SampleType N) {
        constexpr static auto a0{ 0.35875 };
        constexpr static auto a1{ 0.48829 };
        constexpr static auto a2{ 0.14128 };
        constexpr static auto a3{ 0.01168 };
        constexpr static auto pi{ std::numbers::pi_v<double> };
        constexpr static auto twoPi{ pi * 2.0 };
        constexpr static auto fourPi{ pi * 4.0 };
        constexpr static auto sixPi{ pi * 6.0 };
        const auto position = static_cast<double>(n) / static_cast<double>(N - 1);
        const auto a1Term = a1 * std::cos(position * twoPi);
        const auto a2Term = a2 * std::cos(position * fourPi);
        const auto a3Term = a3 * std::cos(position * sixPi);
        const auto result = a0 - a1Term + a2Term - a3Term;
        return static_cast<SampleType>(result);
    }

    template <FloatType SampleType>
    [[nodiscard]] SampleType cosineSum(SampleType n, SampleType N, SampleType alpha) {
        // w[n] = a0 - (1 - a0) * cos(2pi * n/N)
        const auto a0 = alpha;
        const auto a1 = static_cast<SampleType>(1.0) - alpha;
        constexpr static auto twoPi = std::numbers::pi_v<SampleType> * static_cast<SampleType>(2.0);
        const auto ratio = n / (N - 1);
        const auto cosine = std::cos(twoPi * ratio);
        const auto a1Scaled = a1 * cosine;
        const auto res = a0 - a1Scaled;
        return res;
    }

    template <FloatType SampleType>
    [[nodiscard]] SampleType hann(SampleType n, SampleType N) {
        return cosineSum(n, N, static_cast<SampleType>(0.5));
    }

    template <FloatType SampleType>
    [[nodiscard]] SampleType hamming(SampleType n, SampleType N) {
        constexpr static auto alpha = static_cast<SampleType>(25.0 / 46.0);
        return cosineSum(n, N, alpha);
    }
} // namespace marvin::math::windows
#endif