filter.hpp

Go to the documentation of this file.

/*
 * eDSP, A cross-platform Digital Signal Processing library written in modern C++.
 * Copyright (C) 2018 Mohammed Boujemaoui Boulaghmoudi, All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along width
 * this program.  If not, see <http://www.gnu.org/licenses/>
 *
 * File: filter.hpp
 * Author: Mohammed Boujemaoui
 * Date: 30/8/2018
 */
#ifndef EDSP_FILTER_HPP
#define EDSP_FILTER_HPP

#include <edsp/filter/biquad.hpp>
#include <edsp/filter/biquad_cascade.hpp>

#include <edsp/filter/internal/rbj_designer.hpp>
#include <edsp/filter/internal/zoelzer_designer.hpp>
#include <edsp/filter/internal/butterworth_designer.hpp>
#include <edsp/filter/internal/chebyshev_I_designer.hpp>
#include <edsp/filter/internal/chebyshev_II_designer.hpp>

#include <edsp/filter/moving_median_filter.hpp>
#include <edsp/filter/moving_average_filter.hpp>
#include <edsp/filter/moving_rms_filter.hpp>

namespace edsp { namespace filter {

    enum class DesignerType {
        RBJ,         
        Zolzer,      
        Butterworth, 
        ChebyshevI, 
        ChebyshevII, 
        Bessel,
        Elliptic, 
        Legendre  
    };

    template <typename T, DesignerType Designer, std::size_t MaxOrder>
    struct designer {};

    template <typename T, std::size_t MaxOrder>
    struct designer<T, DesignerType::RBJ, MaxOrder> {
        template <FilterType Type, typename... Args>
        constexpr biquad<T> design(T fc, T sample_rate, T Q, T gain_db = 1) const {
            return RBJFilterDesigner<T, Type>{}(fc, sample_rate, Q, gain_db);
        }
    };

    template <typename T, std::size_t MaxOrder>
    struct designer<T, DesignerType::Zolzer, MaxOrder> {
        template <FilterType Type, typename... Args>
        constexpr biquad<T> design(T fc, T sample_rate, T Q, T gain_db = 1) const {
            return ZoelzerFilterDesigner<T, Type>{}(fc, sample_rate, Q, gain_db);
        }
    };

    template <typename T, std::size_t MaxOrder>
    struct designer<T, DesignerType::Butterworth, MaxOrder> {
        template <FilterType Type, typename... Args>
        constexpr auto design(Args... arg) const -> decltype(ButterworthDesigner<T, Type, MaxOrder>{}(arg...)) {
            return ButterworthDesigner<T, Type, MaxOrder>{}.operator()(arg...);
        }
    };

    template <typename T, std::size_t MaxOrder>
    struct designer<T, DesignerType::ChebyshevI, MaxOrder> {
        template <FilterType Type, typename... Args>
        constexpr auto design(Args... arg) const
            -> decltype(ChebyshevIDesigner<T, Type, MaxOrder>{}(std::declval<Args&&>()...)) {
            return ChebyshevIDesigner<T, Type, MaxOrder>{}(arg...);
        }
    };

    template <typename T, std::size_t MaxOrder>
    struct designer<T, DesignerType::ChebyshevII, MaxOrder> {
        template <FilterType Type, typename... Args>
        constexpr auto design(Args... arg) const
            -> decltype(ChebyshevIIDesigner<T, Type, MaxOrder>{}(std::declval<Args&&>()...)) {
            return ChebyshevIIDesigner<T, Type, MaxOrder>{}(arg...);
        }
    };

    template <typename T, DesignerType Designer, FilterType Type, std::size_t MaxOrder, typename... Args>
    constexpr auto make_filter(Args... arg)
        -> decltype(designer<T, Designer, MaxOrder>{}.template design<Type>(std::declval<Args&&>()...)) {
        const auto creator = designer<T, Designer, MaxOrder>{};
        return creator.template design<Type>(arg...);
    }

}} // namespace edsp::filter

#endif // EDSP_FILTER_HPP