triskele/include/ArrayTree/triskeleArrayTreeBase.hpp

#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;

      /*! 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*/};

      enum treeType {
	minE,
	maxE,
	tosE,
	treeTypeCount
      };

      /*! Définit les noms des connectivités (utile pour le debug) */
      extern std::string connectivityName[];
  
      /*! Définit les noms des tileItem (utile pour le debug) */
      extern std::string tileItemName[];

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

      /*!
       * Opérateur de flux sur les connectivités
       */
      inline std::ostream &operator << (std::ostream &out, const Connectivity &c) {
	BOOST_ASSERT (c >= 0 && c < 4);
	return out << connectivityName[c];
      }

      /*!
       * Opérateur de flux sur les TileItem
       */
      inline std::ostream &operator << (std::ostream &out, const TileItem &t) {
	BOOST_ASSERT (t >= 0 && t < 3);
	return out << tileItemName[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) {
	Edge<WeightT> c = a;
	a = b;
	b = c;
      }

      /*! Opérateur de flux sur les voisins */
      template <typename WeightT>
      inline std::ostream &operator << (std::ostream &out, const Edge<WeightT> &edge) {
	return out << edge.points[0] << ":" << edge.points[1] << ":" << edge.weight;
      }
      template <typename WeightT>
      inline std::ostream &printEdge (std::ostream &out, const Edge<WeightT> &edge, const Size &size) {
	return out << edge.points[0] << ":" << edge.points[1] << ":" << edge.weight << ":"
		   << point2idx (size, edge.points[0]) << ":" << point2idx (size, edge.points[1]);
      }

      /*! Affiche tous les voisins d'un ensemble */
      template <typename Edge>
      inline std::ostream &printEdges (std::ostream &out, const std::vector<Edge> &edges) {
	for (int i = 0; i < edges.size (); ++i)
	  out << " " << edges [i];
	return out;
      }

      template <typename Edge>
      inline std::ostream &printEdges (std::ostream &out, const Edge edges[], const Size &size, const DimEdge edgesCount) {
	for (int i = 0; i < edgesCount; ++i)
	  printEdge (out, edges[i], size) << std::endl;
	return out;
      }

      /*! Affiche tous les voisins d'un ensembles à l'aide de leurs coordonnées */
      template <typename Edge>
      inline std::ostream &printEdges (std::ostream &out, const std::vector<Edge> &edges, const Size &size) {
	for (int i = 0; i < edges.size (); ++i)
	  out << " [" << point2idx (size, edges [i].points[0])
	      << " " << point2idx (size, edges [i].points[1])
	      << " " << edges [i].weight << "]";
	return out;
      }
    } // arrayTree
  } // triskele
} // otb



#endif //  _OTB_TRISKELE_ARRAY_TREE_BASE_HPP