Wavelet.h

Go to the documentation of this file.

/*
 * Begin the 17/04/2012
 *
 * Inspired by work of Ian Kaplan
 * http://www.bearcave.com
 *
 * dependent or not from ListDataStock ? advantage and disavantage !!
 * can be independent, for later test and create a class WaveletAPI, like TAlib
 *
 * if draw method, need ROOT header files in src_cpp...
 * to define in external file with compilation option ?
 */

#ifndef WAVELET_H_
#define WAVELET_H_

#include <iostream>
#include <vector>
#include <map>
//#include <stdio.h>
#include <string.h>

class WaveletBase {

  protected :
      //data should be in derived class ??
      //std::vector< float > vec_values;
      double *values;
      unsigned int size;
      unsigned int max_level;
      // map coefficient and average could be here..
      

  public :
      WaveletBase() { std::cout << "default WaveletBase constructor " << std::endl;
                      values = 0; size = 0; max_level = 0;}
      WaveletBase( double *values_in, unsigned int size_in );
      virtual ~WaveletBase() { delete[] values; values = 0; size = 0; max_level = 0;}

      double* GetValues() { return values;}
      unsigned int GetSize() { return size;}
      unsigned int GetMax_level() {return max_level;}

      // could extend first value which is a multiple of 2 up to a given level
      unsigned int getLevels( unsigned int size_in ); //, unsigned int &nb_level );
      //abstract may depend of the type of wavelet
      virtual void print_coeff() = 0;
      //global function, work for all, need to determine the correct size before
      virtual void print_values( bool only_first_last = false );

      //could be better friend or utils
      inline int isPowerOfTwo (unsigned int x) {
          return ((x != 0) && ((x & (~x + 1)) == x));}
};


class Haar: public WaveletBase {

  private :
      double haar_value; 
      // to store coefficient, could be a map or **vec_coeff, easy to find correct coefficient
      // std::vector< double > vec_coeff; //could be allocated in transform, keep c-style
      std::map <unsigned int, std::vector<double> > map_coeff;
      std::map <unsigned int, std::vector<double> > map_average;
      //store how many level have been computed, maybe to keep, change name
      unsigned int nb_level;

      // for inverse transform, map_coeff may be modified by a filter ( some coeff == 0 for instance )
      // easier to have a modified copy, accessible by InvCalc without passing as argument
      // limit, only one possible in memory
      std::map <unsigned int, std::vector<double> > map_coeff_filt;

      //called by Transform values not needed
      double CalcTransform ( double *values, unsigned int size, unsigned int level );
      double * CalcInvTransform ( double *values, unsigned int size, unsigned int level  );

  public :
      Haar(): haar_value(0.),nb_level(0) {}
      Haar( double *values_in, unsigned int size_in) : WaveletBase( values_in, size_in ) {
          haar_value = 0; nb_level = 0;}
      virtual ~Haar() { map_coeff.clear(); map_average.clear(); map_coeff_filt.clear();
                        haar_value = 0; nb_level = 0;}

      int GetSizeLevel ( const unsigned int level ) { return map_coeff[level].size(); }
      //maybe in base class later, here hust for test
      double GetCoeff( const unsigned int level, const unsigned int indice ) {return map_coeff[level][indice];}
      // main entry to compute Haar transformation
      int Transform ();
      // option for coefficient to include
      double * InvTransform ();
      //void Filter( std::string mode, int numb1=0, int numb2=0 );
      void Filter( const char *mode, int numb1, int numb2 );
      //need to redefine a pure virtual function
      virtual void print_coeff();
      // maybe separate
      virtual void Draw();
};

#endif // WAVELET_H_