#ifndef _OTB_TRISKELE_ARRAY_TREE_BORDER_HPP
#define _OTB_TRISKELE_ARRAY_TREE_BORDER_HPP

#include <algorithm>

#include "triskeleBase.hpp"
#include "triskeleArrayTreeBase.hpp"

namespace otb {
  namespace triskele {
    namespace arrayTree {

      /** Border */
      class Border {
      public:
	/*! Retourne le nombre de pixels à l'aide de la taille */
	static DimImg getPixelsCount (const Size &size) { return DimImg (size.width)*DimImg (size.height); }

	/*! Retourne la taille que doit faire le tableau simplifié */
	static DimImg getMapLength (DimImg pixelsCount) { return (pixelsCount+7)/8; }

	/*! Vérifie si un index est sur la map ou une bordure, en se basant sur le bit de l'index idx de la map */
	bool isBorder (DimImg idx) const { return map ? map[idx/8] & (1 << (idx%8)) : false; }

	/*! Vérifie si un point est sur la map ou une bordure en appelant la méthode précédente après avoir converti le point en index */
	bool isBorder (const Point &p) const { return map ? isBorder (pointToId (size, p)) : false; }

	/*! Supprime toutes les occurences de bordure à l'index idx */
	void clearBorder (DimImg idx) { map[idx/8] &= ~(1 << (idx%8)); }

	/*! Supprime toutes les occurences de bordure en appelant la méthode précédente après avoir converti le point en index */
	void clearBorder (const Point &p) { clearBorder (pointToId (size, p)); }

	/*! Rajoute une occurence de bordure à l'index indiqué */
	void setBorder (DimImg idx) { map[idx/8] |= (1 << (idx%8)); }

	/*! Rajoute une occurence de bordure en appelant la méthode précédente après avoir converti le point en index */
	void setBorder (const Point &p) { setBorder (pointToId (size, p)); }

	/*! Construit par défault sans aucune bordure */
	Border ()
	  : pixelsCount (0), mapLength (0), size (), map (NULL) {
	}

	/*! Construit Border, les valeurs de map dépendent de defaultVal */
	Border (const Size &size, bool defaultVal)
	  : pixelsCount (getPixelsCount (size)), mapLength (getMapLength (pixelsCount)), size (size) {
	  map = new uint8_t [mapLength];
	  reset (defaultVal);
	}
	~Border () { if (map) delete [] map; }

	void reset (bool defaultVal) {
	  std::fill_n (map, mapLength, defaultVal ? 0xFF : 0);
	  if (!(mapLength && defaultVal))
	    return;
	  map[mapLength-1] &= 0xFF >> (8-(pixelsCount%8))%8;
	}

	/*! Compte le nombre de pixels considérés comme de la bordure */
	DimImg borderCount () {
	  DimImg result = 0;
	  for (DimImg i = 0; i < mapLength; ++i)
	    result += bitCount[map[i]];
	  return result;
	}

    
      private:
	/*! Nombre de pixels dans l'image */
	DimImg pixelsCount;

	/*! Taille du tableau "simplifié" des pixels */
	DimImg mapLength;

	/*! Dimensions de l'image */
	Size size;

	/*! Tableau "simplifié" des pixels */
	uint8_t *map;
      };
  
  
    } //arrayTree
  } // triskele
} // otb

#endif // _OTB_TRISKELE_ARRAY_TREE_BORDER_HPP