WindowFunctions.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_WINDOWFUNCTIONS_HPP
#define ECHOMAP_WINDOWFUNCTIONS_HPP
 
#include <algorithm>
#include <cstddef>
#include <ranges>
#include <string_view>
 
namespace echomap
{
 
template <class T>
concept WindowFunction =
        std::default_initializable<std::remove_cvref_t<T>> && requires(std::size_t index, std::size_t size) {
            { std::remove_cvref_t<T>{}(index, size) } -> std::convertible_to<float>;
        };

class WindowFunctions
{
public:
    template <
            class WindowT,
            class BuffersT,
            class InputT>
    static float apply_window(
            BuffersT& buffers,
            const InputT& input
    )
    {
        using Window = std::remove_cvref_t<WindowT>;
        static_assert(WindowFunction<Window>, "WindowT does not satisfy WindowFunction.");
 
        float scale_divisor = 0.0f;
 
        for (std::size_t index = 0; index < buffers.input_size; ++index) {
            const float window_value = Window{}(index, buffers.input_size);
            scale_divisor += window_value;
            buffers.input[index] = input[index] * window_value;
        }
 
        return scale_divisor;
    }

    struct Constant
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };

    struct Hann
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };

    struct Hamming
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };

    struct Bartlett
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };

    struct Blackman
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };

    struct BlackmanHarris
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };

    struct Welch
    {
        static float operator()(
                std::size_t index,
                std::size_t size
        ) noexcept;
    };
 
    using AllFunctions = std::variant<Constant, Hann, Hamming, Bartlett, Blackman, BlackmanHarris, Welch>;

    template <WindowFunction> static constexpr std::string_view get_window_name()
    {
        // ReSharper disable once CppStaticAssertFailure
        static_assert(false, "Missing window function name.");
        return {};
    }

    struct NameGetter
    {
        template <class T> static consteval std::string_view get()
        {
            return WindowFunctions::get_window_name<T>();
        }
    };
};
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::Constant>()
{
    return "Constant";
}
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::Hann>()
{
    return "Hann";
}
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::Hamming>()
{
    return "Hamming";
}
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::Bartlett>()
{
    return "Bartlett";
}
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::Blackman>()
{
    return "Blackman";
}
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::BlackmanHarris>()
{
    return "Blackman-Harris";
}
 
template <> constexpr std::string_view WindowFunctions::get_window_name<WindowFunctions::Welch>()
{
    return "Welch";
}
 
} // namespace echomap
 
#endif // ECHOMAP_WINDOWFUNCTIONS_HPP