// Wavelet Analysis Tool
//--------------------------------------------------------------------
// Implementation of 
// the Haar wavelet transform using lifting scheme 
// References:
//   A.Cohen, I.Daubechies, J.Feauveau Bases of compactly supported wavelets
//   Comm. Pure. Appl. Math. 45, 485-560, 1992
//   W. Sweldens - Building your own wavelets at home
//--------------------------------------------------------------------
//$Id: Haar.hh,v 0.2 2001/08/06 19:37:00 klimenko Exp $

#define BIORTHOGONAL_CC

#include "Haar.hh"

namespace datacondAPIwat {

// constructors

template<class DataType_t> Haar<DataType_t>::
Haar(const Wavelet &w) : 
WaveDWT<DataType_t>(w) 
{ 
   m_WaveType = HAAR;
}

template<class DataType_t> Haar<DataType_t>::
Haar(const Haar<DataType_t> &w) : 
WaveDWT<DataType_t>(w) 
{ 
   m_WaveType = HAAR;
}

template<class DataType_t> Haar<DataType_t>::
Haar(int tree=0) :
WaveDWT<DataType_t>(1,1,tree,B_CYCLE) 
{
  m_WaveType = HAAR;
}

// destructor
template<class DataType_t>
Haar<DataType_t>::~Haar()
{  }

// clone
template<class DataType_t>
Haar<DataType_t>* Haar<DataType_t>::Clone() const
{
  return new Haar<DataType_t>(*this);
}

// decompose function does one step of forward transformation.
// <level> input parameter is the level to be transformed
// <layer> input parameter is the layer to be transformed.
template<class DataType_t>
void Haar<DataType_t>::decompose(int level,int layer)
{
   level++;                           // increment level (next level now)
   const int nS = nWWS>>level;        // nS - number of samples in the layer
   register int stride = 1<<level;    // stride parameter

   int i;
   
   register DataType_t *dataA;
   register DataType_t *dataD; 

   dataA=pWWS+getOffset(level,layer<<1);     // pointer to approximation layer
   dataD=pWWS+getOffset(level,(layer<<1)+1); // pointer to detail layer

// predict
  for(i=0; i<nS; i+=stride) {
    *(dataD+i) -= *(dataA+i);
  }

// update
  for(i=0; i<nS; i+=stride) {
    *(dataA+i) += *(dataD+i) * 0.5;
  }
}

// reconstruct function does one step of inverse transformation.
// <level> input parameter is the level to be reconstructed
// <layer> input parameter is the layer to be reconstructed.
template<class DataType_t>
void Haar<DataType_t>::reconstruct(int level,int layer)
{
   level++;                             // increment level (next level now)
   const int nS = nWWS>>level;          // nS - number of samples in the layer
   register int stride = 1<<level;      // stride parameter

   int i;
   
   register DataType_t *dataA;
   register DataType_t *dataD; 

   dataA=pWWS+getOffset(level,layer<<1);     // pointer to approximation layer
   dataD=pWWS+getOffset(level,(layer<<1)+1); // pointer to detail layer

// undo update
  for(i=0; i<nS; i+=stride) {
    *(dataA+i) += *(dataD+i) * 0.5;
  }

// undo predict
  for(i=0; i<nS; i+=stride) {
    *(dataD+i) -= *(dataA+i);
  }
}

// instantiations

#define CLASS_INSTANTIATION(class_) template class Haar< class_ >;

CLASS_INSTANTIATION(float)
CLASS_INSTANTIATION(double)
//CLASS_INSTANTIATION(std::complex<float>)
//CLASS_INSTANTIATION(std::complex<double>)

#undef CLASS_INSTANTIATION

template Haar<float>::
Haar(const Haar<float> &);
template Haar<double>::
Haar(const Haar<double> &);

}  // end namespace datacondAPIwat