#ifndef _OTB_TRISKELE_ARRAY_TREE_BASE_HPP
#define _OTB_TRISKELE_ARRAY_TREE_BASE_HPP

#include <iostream>
#include <string>
#include <vector>
#include <boost/assert.hpp>
#include <climits>

#include "triskeleBase.hpp"

namespace otb {
  namespace triskele {
    namespace arrayTree {

      class GraphWalker;
      using namespace ::triskele;
      using namespace std;

      /*! Nombre de voisins */
      typedef uint32_t DimEdge;		// ~4*nbPixels (8-connectivity)

      /*! Type de connectivité possible pour le voisinage */
      enum Connectivity { C4 = 0, C6P = 1, C6N = 2, C8 = C6P | C6N };

      /*! Définit de quel type est la "sélection" */
      enum TileItem { Surface, Horizontal, Vertical };

      /* Définit le type d'arbre à construire */
      enum TreeType { MIN, MAX, TOS, ALPHA, TreeTypeCard};

      inline bool getDecrFromTreetype (TreeType treeType);
      
      /*! Définit les noms des connectivités (utile pour le debug) */
      extern string connectivityName[];
  
      /*! Définit les noms des tileItem (utile pour le debug) */
      extern string tileItemName[];

      /*! Définit les noms des arbres (utile pour le debug) */
      extern string treeTypeLabels[];

      /*!
       * Opérateur de flux sur les connectivités
       */
      inline ostream &operator << (ostream &out, const Connectivity &c);

      /*!
       * Opérateur de flux sur les TileItem
       */
      inline ostream &operator << (ostream &out, const TileItem &t);

      template <typename WeightT> struct Edge {
	Point points[2];
	WeightT weight;
      };

      /*! Effectue l'échange entre 2 Edge */
      template <typename WeightT>
      inline void swapEdge (Edge<WeightT> &a, Edge<WeightT> &b);

      /*! Opérateur de flux sur les voisins */
      template <typename WeightT>
      struct CPrintEdge {
	const Edge<WeightT> &edge;
	const Size &size;
	inline CPrintEdge (const Edge<WeightT> &edge, const Size &size);
	inline ostream &print (ostream &out) const;
      };
      template <typename WeightT>
      inline CPrintEdge<WeightT> printEdge (const Edge<WeightT> &edge, const Size &size);

      template <typename WeightT>
      inline ostream &operator << (ostream& out, const CPrintEdge<WeightT> &cpe) { return cpe.print (out); }

      template <typename WeightT>
      struct CPrintEdges {
	const Edge<WeightT> *edges;
	const Size &size;
	const DimEdge edgesCount;
	inline CPrintEdges (const Edge<WeightT> edges[], const Size &size, const DimEdge edgesCount);
	inline ostream &print (ostream &out) const;
      };
      template <typename WeightT>
      inline CPrintEdges<WeightT> printEdges (const Edge<WeightT> edges[], const Size &size, const DimEdge edgesCount);

      template <typename WeightT>
      inline ostream &operator << (ostream& out, const CPrintEdges<WeightT> &cpe) { return cpe.print (out); }

#include "triskeleArrayTreeBase.tpp"

    } // arrayTree
  } // triskele
} // otb


#endif //  _OTB_TRISKELE_ARRAY_TREE_BASE_HPP