---

polyHaar.h

Go to the documentation of this file.

#ifndef _POLY_H_
#define _POLY_H_


#include <vector>

#include "liftbase.h"
#include "polyinterp.h"


template<class T>
class polyHaar : public liftbase<T, double> {

public:
  polyHaar() {}
  ~polyHaar() {}
  // declare, but don't define to disallow copy constructor
  polyHaar(const polyHaar &rhs );

private:
  typedef enum { numPts = 4 } bogus;
  polyinterp fourPtInterp;

  void fill( T &vec, double d[], int N, int start )
  {
    int n = numPts;
    if (n > N)
      n = N;
    int end = start + n;
    int j = 0;

    for (int i = start; i < end; i++) {
      d[j] = vec[i];
      j++;
    }
  } // fill

protected:


   void update( T& vec, int N, transDirection direction)
   {
      int i;
      int half = N >> 1;
      int j = half;
      for (i = 0; i < half; i++) {
         if (direction == forward) {  // forward transform stage
            vec[i] = vec[i] + (vec[j]/2.0);
         }
         else if (direction == inverse) { // inverse transform step
            vec[i] = vec[i] - (vec[j]/2.0);
         }
         else {
           printf("update: bad direction value\n");
           break;
         }
         j++;
      } // for
   } // update


  void interp( T &vec, int N, transDirection direction )
  {
    int half = N >> 1;
    double d[4];

    for (int i = 0; i < half; i++) {
      double predictVal;

      if (i == 0) {
        if (half == 1) {
          // e.g., N == 2, and we use Haar interpolation
          predictVal = vec[0];
        }
        else {
          fill( vec, d, N, 0 );
          predictVal = fourPtInterp.interpPoint( 0.5, half, d );
        }
      }
      else if (i == 1) {
        predictVal = fourPtInterp.interpPoint( 1.5, half, d );
      }
      else if (i == half-2) {
        predictVal = fourPtInterp.interpPoint( 2.5, half, d );
      }
      else if (i == half-1) {
        predictVal = fourPtInterp.interpPoint( 3.5, half, d );
      }
      else {
        fill( vec, d, N, i-1);
        predictVal = fourPtInterp.interpPoint( 1.5, half, d );
      }

      int j = i + half;
      if (direction == forward) {
        vec[j] = vec[j] - predictVal;
      }
      else if (direction == inverse) {
        vec[j] = vec[j] + predictVal;
      }
      else {
        printf("interp: bad direction value\n");
        break;
      }
    } // for
  } // interp

   void predict( T& vec, int N, transDirection direction)
   {
      int i;
      int half = N >> 1;
      int j = 0;
      for (i = half; i < N; i++) {
         if (direction == forward) { // forward transform stage
           vec[i] = vec[i] - vec[j];
         }
         else if (direction == inverse ) { // inverse transform stage
           vec[i] = vec[i] + vec[j];
         }
         else {
           printf("predict: bad direction\n");
           break;
         }
         j++;
      }
   } // predict


public:

  void forwardStep( T& vec, const int n )
  {
    split( vec, n );
    predict( vec, n, forward );
    update( vec, n, forward );
    interp( vec, n, forward );
  } // forwardStep

  virtual void inverseStep( T& vec, const int n )
  {
    interp( vec, n, inverse );
    update( vec, n, inverse );
    predict( vec, n, inverse );
    merge( vec, n );
  }

}; // polyHaar


#endif

---