---

packtree_base_int.cpp

Go to the documentation of this file.

#include "queue.h"
#include "packnode.h"
#include "packcontainer_int.h"
#include "packtree_base_int.h"


void packtree_base_int::newLevel( packnode<int>* top, 
                              bool freqCalc, 
                              bool reverse )
{
  if (top != 0) {
    const size_t len = top->length();
    if (len > 1) {
      // Create a new wavelet packet container for use in
      // calculating the wavelet transform.  Note that the
      // container is only used locally.
      packcontainer_int container( top );

      if (reverse) {
        // Calculate the reverse foward wavelet transform step, 
        // where the high pass result is stored in the upper half
        // of the container and the low pass result is stored
        // in the lower half of the container.
        waveObj->forwardStepRev( container, len );
      }
      else {
        // Calculate the foward wavelet transform step, where
        // the high pass result is stored in the upper half
        // of the container and the low pass result is stored
        // in the lower half of the container.
        waveObj->forwardStep( container, len );
      }

      packnode<int> *lhs = new packnode<int>(container.lhsData(), 
                                                   len/2,
                                                   packnode<int>::LowPass );
      packnode<int> *rhs = new packnode<int>(container.rhsData(), 
                                                   len/2,
                                                   packnode<int>::HighPass );

      // set the "mark" in the top node to false and
      // mark the two children to true.
      top->mark( false );
      lhs->mark( true );
      rhs->mark( true );

      top->lhsChild( lhs );
      top->rhsChild( rhs );

      // The transform on the left hand side always uses
      // the standard order (e.g., low pass filter result
      // goes in the lower half, high pass goes in the
      // upper half of the container).
      newLevel( lhs, freqCalc, false );

      if (freqCalc) {
        // wavelet packet frequency analysis reverses the
        // storage locations for the filter results in the
        // right hand child
        newLevel( rhs, freqCalc, true );
      }
      else { // freq == false
        // use standard filter location
        newLevel( rhs, freqCalc, false );
      }
    }
  }
} // newLevel



void packtree_base_int::breadthFirstPrint(const printKind kind)
{
  queue<int> Q;

  Q.addQueue( root, 0 );
  while (! Q.queueEmpty() ) {
    packnode<int> *node = Q.queueStart()->node;
    size_t indent = Q.queueStart()->indent;
    Q.deleteStart();
    
    if (indent > 0) {
      // print 'indent' spaces
      printf("%*c", indent, ' ');
    }

    switch (kind) {
    case printData: node->pr();
      break;
    case printCost: node->prCost();
      break;
    case printBestBasis: node->prBestBasis();
      break;
    default:
      assert( false );
      break;
    } // switch
    
    packnode<int> *lhs = node->lhsChild();
    packnode<int> *rhs = node->rhsChild();

    if (lhs != 0) {
      Q.addQueue( lhs, indent + 2 );
    }
    if (rhs != 0) {
      Q.addQueue( rhs, indent + 2 );
    }
  }
} // packtree_base_int::breadthFirstPrint




void packtree_base_int::pr()
{
  if (root != 0) {
    breadthFirstPrint(printData);
  }
} // pr

---