triskele/include/Tree.hpp

#ifndef _OTB_TRISKELE_TREE_HPP
#define _OTB_TRISKELE_TREE_HPP

#include <vector>
#include <map>
#include <string>
#include <numeric>

#include "triskeleBase.hpp"
#include "triskeleDebug.hpp"

namespace otb {
  namespace triskele {

    using namespace ::triskele;

    enum State {
      Void = 0,
      Initialized = 1,
      Constructed = 1 << 1
    };
  
    class Tree {
      friend class TreeBuilder;
    
    protected:
      /*! Info about the picture */
      Size size;

      /*! Number of pixels / leaf */
      DimImg leafCount, nodeCount;

      /*! Pointers on the parents of each leafs / nodes */
      DimNodeId *leafParents, *compParents;

      /*! Pointers on the children and count how many children a parents have */
      DimNodeId *children, *childCount;

      DimNodeId *newCompIndex;

      /*! State of the tree */
      State state;

      /*! Reset the tree and allocate the memory according to the size defined */
      void init ();

      /*! Allocate the size according to the size previously defined */
      void book ();

      /*! Free all the memory and set all pointers to nullptr */
      void reset ();

    public:
      // Constructors, destructor and resize method (does the same as the constructors)
    
      Tree (const DimImg &leafCount, const DimSideImg &width, const DimSideImg &height);
      Tree (const DimSideImg &width, const DimSideImg &height);
      Tree (const DimImg &leafCount = 0);
      ~Tree ();


      void resize (const DimImg &newLeafCount, const DimSideImg &w, const DimSideImg &h);
      void resize (const DimImg &newLeafCount);
      void resize (const DimSideImg &w, const DimSideImg &h);

      // Setter for nodeCount and size
      void setNodeCount (const DimImg &newNodeCount) { nodeCount = newNodeCount; }
      void setSize (const Size &newSize) { size = newSize; }
    
      // Get the tree state and the size
      State getState () const { return state; }
      Size getSize () const { return size; }

      // Getters for tree structure
      DimNodeId getRoot () const { return nodeCount-1; }
      DimNodeId getAbsRoot () const { return nodeCount-1+leafCount; }
      DimNodeId getCompCount () const { return nodeCount-leafCount; } // XXX

      DimNodeId getParent (const DimNodeId &idx) const { return leafParents[idx]; }
      DimNodeId getLeafParent (const DimNodeId &idx) const { return leafParents[idx]; }
      DimNodeId getCompParent (const DimNodeId &idx) const { return compParents[idx]; }

      std::vector<DimNodeId> getChildren (const DimImg &idx) const;

      DimNodeId getChildrenCount (const DimImg &idx) const { return childCount[idx]; }

      DimSideImg getLeafCount () const { return leafCount; }

      DimSideImg getNodeCount () const { return nodeCount; }

      // Functions to apply to specific entities
      template<typename FuncToApply>
      void forEachLeaf (const FuncToApply& f /* f(DimNodeId idx) */);

      template<typename FuncToApply>
      void forEachComp (const FuncToApply& f /* f(DimNodeId idx) */);

      template<typename FuncToApply>
      void forEachChild (const DimNodeId &idx, const FuncToApply& f /* f(DimNodeId idx) */);

#ifdef SMART_LOG
      // Print info about the tree
      void printTree (const Size &size, const bool &rec);
      void printNewCompIndex (const Size &size);
#endif
    };
  } // triskele
} // otb

#endif // _OTB_TRISKELE_TREE_HPP