modetrack.h

#ifndef MODETRACK_H
#define MODETRACK_H

//C System-Headers
//
//C++ System headers
#include <tuple>
#include <vector>
#include <map>
//Qt Headers
//
//OpenCV Headers
//
//Boost Headers
//
//Project specific headers
#include "../Generics/generics.h"
#include "mode_track_failure.h"

class ModeTrack {
  public:
    ModeTrack();
    ~ModeTrack();

    void SetBackground( const std::vector< data_triple< double > >& background_list );

    double GetPeaksGauss( const std::vector< data_triple< double > >& power_list, int mod_number );

    double GetPeaksBiLat( const std::vector< data_triple< double > >& power_list, int mod_number );

    double GetMaxPeak( const std::vector< data_triple< double > >& power_list );
    //
    void SetLowerBound( double frequency );
    //
    void SetUpperBound( double frequency );

  private:
    //
    enum Method { Gauss, BiLat };
    //
    double lower_bound = 0.0, upper_bound = 0.0;
    //
    double max_search_radius = 436.344;

    std::vector< double > background;

    //quadratic best-fit coeffecients for each of the four modes.
    //format is a*x^2+b*x+c and tuple is populated with (a,b,c)
    //first entry in vector corresponds to the first mode, etc.

    std::vector<std::tuple<double,double,double>> estimated_paths;

    std::vector<double> Derivative( const std::vector<double>& data_list );


    void PopulateBestFitCurves();

    //Compute the standard deviation of a list
    double StdDev( const std::vector<double>& data_list );

    std::vector<double> Normalize(const std::vector<double> &data_list);

    std::vector<double> Convolve(const std::vector<double> &signal, const std::vector<double> &kernel);

    //convolve list with a gaussian vector

    std::vector<double> GaussBlur(const std::vector<double> &data_list);

    std::vector<double> FindPeaks( const std::vector<double>& data_list, const ModeTrack::Method method );

    //Check to see if all identified peaks are close to an estimated peak
    //If an identified peak is not "close" to an estimated peak, fill value from estimation

    std::map<uint,double> CompareAndFill(const std::vector<double> &peak_list, const std::vector<data_triple<double> > &comparison_list);

    //Generate estimated peak position from best fit parameters

    double GenerateSpline(int mode_number, double length);

    //generate a gaussian kernel
    //used by 'GaussBlur' function
    std::vector<double> GaussKernel(int r);

    std::vector<double> BilateralFilter( const std::vector<double>& data_list, double sigma_s, double sigma_r );
    //
    uint FindMaxima( const std::vector<double>& data_list);
    //
    double GetPeaks( const std::vector<data_triple<double> > &data_str, int mode_number, Method filter_method);
    //
    bool CheckBounds(double frequency);

    std::vector< double > data_triples_to_power(const std::vector<data_triple<double> > &data_list );
};

#endif /* MODETRACK_H */