filterbank.hpp

/*
 * filterbank.h
 *
 * Wavelet Filter Bank
 *
 * Contact:
 * - Jules Françoise <jules.francoise@ircam.fr>
 *
 * This code has been authored by <a href="http://julesfrancoise.com">Jules Françoise</a>
 * in the framework of the <a href="http://skatvg.iuav.it/">SkAT-VG</a> European project,
 * with <a href="frederic-bevilacqua.net">Frederic Bevilacqua</a>, in the
 * <a href="http://ismm.ircam.fr">Sound Music Movement Interaction</a> team of the
 * <a href="http://www.ircam.fr/stms.html?&L=1">STMS Lab</a> - IRCAM - CNRS - UPMC (2011-2015).
 *
 * Copyright (C) 2015 Ircam-Centre Pompidou.
 *
 * This File is part of Wavelet.
 *
 * Wavelet 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.
 *
 * Wavelet 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 with Wavelet.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef filterbank_h
#define filterbank_h

#include "wavelet.hpp"
#include "lowpass.hpp"
#include "../wavelets/morlet.hpp"
#include "../wavelets/paul.hpp"
#include <map>
#include <boost/circular_buffer.hpp>
#ifdef USE_ARMA
#include <armadillo>
#endif

namespace wavelet {
    enum Family : unsigned char {
        MORLET = 0,
        
        PAUL = 1
    };
    
    const Family DEFAULT_FAMILY = MORLET;
    
    class Filterbank : public AttributeHandler {
    public:
        enum Optimisation : unsigned char {
            NONE = 0,
            
            STANDARD = 1,
            
            AGRESSIVE = 2
        };
        
#pragma mark -
#pragma mark === Public Interface ===
#pragma mark > Constructors

        
        Filterbank(float samplerate,
                   float frequency_min,
                   float frequency_max,
                   float bands_per_octave);
        
        Filterbank(Filterbank const& src);
        
        Filterbank& operator=(Filterbank const& src);
        
        virtual ~Filterbank();
        
        
#pragma mark > Accessors

        
        template <typename T>
        void setAttribute(std::string attr_name,
                          T attr_value)
        {
            try {
                setAttribute_internal(attr_name, boost::any(attr_value));
            } catch(const boost::bad_any_cast &) {
                throw std::runtime_error("Argument value type does not match Attribute type");
            }
        }
        
        template <typename T>
        T getAttribute(std::string attr_name) const
        {
            try {
                return boost::any_cast<T>(getAttribute_internal(attr_name));
            } catch(const boost::bad_any_cast &) {
                throw std::runtime_error("Return value type does not match Attribute type");
            }
        }
        
        
#pragma mark > Online Estimation

        
        void update(float value);
        
        void reset();
        
        
#pragma mark > Offline Estimation
#ifdef USE_ARMA

        
        arma::cx_mat process(std::vector<double> values);
        
        arma::cx_mat process_online(std::vector<double> values);
        
#endif
        
#pragma mark > Utilities

        
        std::size_t size() const;
        
        std::string info() const;
        
        std::vector<int> delaysInSamples() const;
        
#ifdef SWIGPYTHON

        std::string __str__() {
            return info();
        }
#endif
        
        
#pragma mark -
#pragma mark === Public Attributes ===

        Attribute<float> frequency_min;
        
        Attribute<float> frequency_max;
        
        Attribute<float> bands_per_octave;
        
        Attribute<Optimisation> optimisation;
        
        Attribute<Family> family;
        
        std::vector<double> scales;
        
        std::vector<double> frequencies;
        
        std::vector<int> downsampling_factors;
        
        std::vector< std::complex<double> > result_complex;
        
        std::vector<double> result_power;
        
#ifndef WAVELET_TESTING
    protected:
#endif
#pragma mark -
#pragma mark === Protected Methods ===

        
        void init();
        
        virtual void onAttributeChange(AttributeBase* attr_pointer);
        
        virtual void setAttribute_internal(std::string attr_name,
                                           boost::any const& attr_value);
        
        virtual boost::any getAttribute_internal(std::string attr_name) const;
        
        
#pragma mark -
#pragma mark === Protected Attributes ===

        std::map<int, boost::circular_buffer<float>> data_;
        
        std::map<int, LowpassFilter> filters_;
        
        std::vector< std::shared_ptr<Wavelet> > wavelets_;
        
        std::shared_ptr<Wavelet> reference_wavelet_;
        
        int frame_index_;
        
    };
    
#pragma mark -
#pragma mark === Attribute Specializations ===
    template <>
    void checkLimits<Family>(Family const& value,
                             Family const& limit_min,
                             Family const& limit_max);
    
    template <>
    void checkLimits<Filterbank::Optimisation>(Filterbank::Optimisation const& value,
                                               Filterbank::Optimisation const& limit_min,
                                               Filterbank::Optimisation const& limit_max);
    
    template <>
    Family Attribute<Family>::default_limit_max();
    
    template <>
    Filterbank::Optimisation Attribute<Filterbank::Optimisation>::default_limit_max();
}

#endif