last-svn-commit-48-g6ada0c4 Import annotating sources from milena green's sandbox.

15 Nov 2010

* README.green: New.
	* demo/annotating/bic/Makefile.am: New.
	* demo/annotating/bic/bic.cc: New.
	* demo/annotating/hsv/Makefile.am: New.
	* demo/annotating/hsv/hsv.cc: New.
	* demo/annotating/lep/Makefile.am: New.
	* demo/annotating/lep/lep.cc: New.
	* demo/annotating/nb_color/Makefile.am: New.
	* demo/annotating/nb_color/nb_color.cc: New.
	* demo/annotating/project/Makefile.am: New.
	* demo/annotating/project/project.cc: New.
	* demo/annotating/rgb_64/Makefile.am: New.
	* demo/annotating/rgb_64/rgb_64.cc: New.
	* demo/annotating/rgb_64_9/Makefile.am: New.
	* demo/annotating/rgb_64_9/rgb_64_9.cc: New.
	* demo/annotating/stddev_color/Makefile.am: New.
	* demo/annotating/stddev_color/stddev_color.cc: New.
	* demo/annotating/stddev_color_16/Makefile.am: New.
	* demo/annotating/stddev_color_16/stddev_color_16.cc: New.
	* exp/annotating/achromastism/Makefile.am: New.
	* exp/annotating/achromastism/achromastism.cc: New.
	* exp/annotating/achromastism/text-color.txt: New.
	* exp/annotating/achromastism/text-img.txt: New.
	* exp/annotating/achromastism/text-only.txt: New.
	* exp/annotating/bench/Makefile.am: New.
	* exp/annotating/bench/bench.cc: New.
	* exp/annotating/error/Makefile.am: New.
	* exp/annotating/error/error.cc: New.
	* exp/annotating/histo/Makefile.am: New.
	* exp/annotating/histo/histo.cc: New.
	* exp/annotating/hsv/Makefile.am: New.
	* exp/annotating/hsv/hsv.cc: New.
	* exp/annotating/hue/Makefile.am: New.
	* exp/annotating/hue/hue.cc: New.
	* exp/annotating/hue/text-color.txt: New.
	* exp/annotating/hue/text-img.txt: New.
	* exp/annotating/hue/text-only.txt: New.
	* exp/annotating/nb_color/Makefile.am: New.
	* exp/annotating/nb_color/nb_color.cc: New.
	* exp/annotating/saturation/Makefile.am: New.
	* exp/annotating/saturation/saturation.cc: New.
	* exp/annotating/saturation/text-color.txt: New.
	* exp/annotating/saturation/text-img.txt: New.
	* exp/annotating/saturation/text-only.txt: New.
	* exp/annotating/stddev_color/Makefile.am: New.
	* exp/annotating/stddev_color/stddev_color.cc: New.
	* exp/annotating/stddev_color_16/Makefile.am: New.
	* exp/annotating/stddev_color_16/stddev_color_16.cc: New.
	* exp/annotating/value/Makefile.am: New.
	* exp/annotating/value/text-color.txt: New.
	* exp/annotating/value/text-img.txt: New.
	* exp/annotating/value/text-only.txt: New.
	* exp/annotating/value/value.cc: New.
	* mln/clustering/kmean2d.hh: New.
	* mln/fun/p2b/achromatic.hh: New.
	* mln/fun/v2v/hue_concentration.hh: New.
	* mln/fun/v2v/rgb_to_achromatism_map.hh: New.
	* mln/fun/v2v/rgb_to_hsv.hh: New.
---
 scribo/sandbox/green/ChangeLog                     |   64 +
 scribo/sandbox/green/README.green                  |  507 +++++++-
 .../kmean1d => annotating/bic}/Makefile.am         |    0 
 scribo/sandbox/green/demo/annotating/bic/bic.cc    |  122 ++
 .../kmean1d => annotating/hsv}/Makefile.am         |    0 
 scribo/sandbox/green/demo/annotating/hsv/hsv.cc    |  721 ++++++++++
 .../kmean1d => annotating/lep}/Makefile.am         |    0 
 scribo/sandbox/green/demo/annotating/lep/lep.cc    |  127 ++
 .../kmean1d => annotating/nb_color}/Makefile.am    |    0 
 .../green/demo/annotating/nb_color/nb_color.cc     |  143 ++
 .../kmean1d => annotating/project}/Makefile.am     |    0 
 .../green/demo/annotating/project/project.cc       |  275 ++++
 .../kmean1d => annotating/rgb_64}/Makefile.am      |    0 
 .../sandbox/green/demo/annotating/rgb_64/rgb_64.cc |   80 ++
 .../kmean1d => annotating/rgb_64_9}/Makefile.am    |    0 
 .../green/demo/annotating/rgb_64_9/rgb_64_9.cc     |  132 ++
 .../stddev_color}/Makefile.am                      |    0 
 .../demo/annotating/stddev_color/stddev_color.cc   |  191 +++
 .../stddev_color_16}/Makefile.am                   |    0 
 .../annotating/stddev_color_16/stddev_color_16.cc  |  261 ++++
 .../achromastism}/Makefile.am                      |    0 
 .../exp/annotating/achromastism/achromastism.cc    |  179 +++
 .../exp/annotating/achromastism/text-color.txt     |    0 
 .../green/exp/annotating/achromastism/text-img.txt |    0 
 .../exp/annotating/achromastism/text-only.txt      |    0 
 .../bench}/Makefile.am                             |    0 
 scribo/sandbox/green/exp/annotating/bench/bench.cc | 1450 ++++++++++++++++++++
 .../error}/Makefile.am                             |    0 
 scribo/sandbox/green/exp/annotating/error/error.cc |  833 +++++++++++
 .../histo}/Makefile.am                             |    0 
 scribo/sandbox/green/exp/annotating/histo/histo.cc |  366 +++++
 .../hsv}/Makefile.am                               |    0 
 scribo/sandbox/green/exp/annotating/hsv/hsv.cc     |  912 ++++++++++++
 .../hue}/Makefile.am                               |    0 
 scribo/sandbox/green/exp/annotating/hue/hue.cc     |  402 ++++++
 .../green/exp/annotating/hue}/text-color.txt       |    0 
 .../sandbox/green/exp/annotating/hue}/text-img.txt |    0 
 .../green/exp/annotating/hue}/text-only.txt        |    0 
 .../nb_color}/Makefile.am                          |    0 
 .../green/exp/annotating/nb_color/nb_color.cc      |  171 +++
 .../saturation}/Makefile.am                        |    0 
 .../green/exp/annotating/saturation/saturation.cc  |  175 +++
 .../exp/annotating/saturation}/text-color.txt      |    0 
 .../green/exp/annotating/saturation}/text-img.txt  |    0 
 .../green/exp/annotating/saturation}/text-only.txt |    0 
 .../stddev_color}/Makefile.am                      |    0 
 .../exp/annotating/stddev_color/stddev_color.cc    |  216 +++
 .../stddev_color_16}/Makefile.am                   |    0 
 .../annotating/stddev_color_16/stddev_color_16.cc  |  277 ++++
 .../value}/Makefile.am                             |    0 
 .../green/exp/annotating/value}/text-color.txt     |    0 
 .../green/exp/annotating/value}/text-img.txt       |    0 
 .../green/exp/annotating/value}/text-only.txt      |    0 
 scribo/sandbox/green/exp/annotating/value/value.cc |  468 +++++++
 scribo/sandbox/green/mln/clustering/kmean2d.hh     |    4 +-
 scribo/sandbox/green/mln/fun/p2b/achromatic.hh     |   20 +-
 .../sandbox/green/mln/fun/v2v/hue_concentration.hh |   10 +
 .../green/mln/fun/v2v/rgb_to_achromatism_map.hh    |    5 +
 scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh     |   15 +-
 59 files changed, 8105 insertions(+), 21 deletions(-)
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/bic}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/bic/bic.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/hsv}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/hsv/hsv.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/lep}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/lep/lep.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/nb_color}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/nb_color/nb_color.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/project}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/project/project.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/rgb_64}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/rgb_64/rgb_64.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/rgb_64_9}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/rgb_64_9/rgb_64_9.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/stddev_color}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/stddev_color/stddev_color.cc
 copy scribo/sandbox/green/demo/{clustering/kmean1d => annotating/stddev_color_16}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/demo/annotating/stddev_color_16/stddev_color_16.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/achromastism}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/achromastism/achromastism.cc
 copy {milena => scribo}/sandbox/green/exp/annotating/achromastism/text-color.txt (100%)
 copy {milena => scribo}/sandbox/green/exp/annotating/achromastism/text-img.txt (100%)
 copy {milena => scribo}/sandbox/green/exp/annotating/achromastism/text-only.txt (100%)
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/bench}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/bench/bench.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/error}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/error/error.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/histo}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/histo/histo.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/hsv}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/hsv/hsv.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/hue}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/hue/hue.cc
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/hue}/text-color.txt (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/hue}/text-img.txt (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/hue}/text-only.txt (100%)
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/nb_color}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/nb_color/nb_color.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/saturation}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/saturation/saturation.cc
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/saturation}/text-color.txt (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/saturation}/text-img.txt (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/saturation}/text-only.txt (100%)
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/stddev_color}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/stddev_color/stddev_color.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/stddev_color_16}/Makefile.am (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/stddev_color_16/stddev_color_16.cc
 copy scribo/sandbox/green/exp/{regional_maxima => annotating/value}/Makefile.am (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/value}/text-color.txt (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/value}/text-img.txt (100%)
 copy {milena/sandbox/green/exp/annotating/achromastism => scribo/sandbox/green/exp/annotating/value}/text-only.txt (100%)
 create mode 100644 scribo/sandbox/green/exp/annotating/value/value.cc

diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index 5e4cb27..6210a79 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -1,3 +1,67 @@
+2010-09-08  Yann Jacquelet  <jacquelet@lrde.epita.fr>
+
+	Import annotating sources from milena green's sandbox.
+
+	* README.green: New.
+	* demo/annotating/bic/Makefile.am: New.
+	* demo/annotating/bic/bic.cc: New.
+	* demo/annotating/hsv/Makefile.am: New.
+	* demo/annotating/hsv/hsv.cc: New.
+	* demo/annotating/lep/Makefile.am: New.
+	* demo/annotating/lep/lep.cc: New.
+	* demo/annotating/nb_color/Makefile.am: New.
+	* demo/annotating/nb_color/nb_color.cc: New.
+	* demo/annotating/project/Makefile.am: New.
+	* demo/annotating/project/project.cc: New.
+	* demo/annotating/rgb_64/Makefile.am: New.
+	* demo/annotating/rgb_64/rgb_64.cc: New.
+	* demo/annotating/rgb_64_9/Makefile.am: New.
+	* demo/annotating/rgb_64_9/rgb_64_9.cc: New.
+	* demo/annotating/stddev_color/Makefile.am: New.
+	* demo/annotating/stddev_color/stddev_color.cc: New.
+	* demo/annotating/stddev_color_16/Makefile.am: New.
+	* demo/annotating/stddev_color_16/stddev_color_16.cc: New.
+	* exp/annotating/achromastism/Makefile.am: New.
+	* exp/annotating/achromastism/achromastism.cc: New.
+	* exp/annotating/achromastism/text-color.txt: New.
+	* exp/annotating/achromastism/text-img.txt: New.
+	* exp/annotating/achromastism/text-only.txt: New.
+	* exp/annotating/bench/Makefile.am: New.
+	* exp/annotating/bench/bench.cc: New.
+	* exp/annotating/error/Makefile.am: New.
+	* exp/annotating/error/error.cc: New.
+	* exp/annotating/histo/Makefile.am: New.
+	* exp/annotating/histo/histo.cc: New.
+	* exp/annotating/hsv/Makefile.am: New.
+	* exp/annotating/hsv/hsv.cc: New.
+	* exp/annotating/hue/Makefile.am: New.
+	* exp/annotating/hue/hue.cc: New.
+	* exp/annotating/hue/text-color.txt: New.
+	* exp/annotating/hue/text-img.txt: New.
+	* exp/annotating/hue/text-only.txt: New.
+	* exp/annotating/nb_color/Makefile.am: New.
+	* exp/annotating/nb_color/nb_color.cc: New.
+	* exp/annotating/saturation/Makefile.am: New.
+	* exp/annotating/saturation/saturation.cc: New.
+	* exp/annotating/saturation/text-color.txt: New.
+	* exp/annotating/saturation/text-img.txt: New.
+	* exp/annotating/saturation/text-only.txt: New.
+	* exp/annotating/stddev_color/Makefile.am: New.
+	* exp/annotating/stddev_color/stddev_color.cc: New.
+	* exp/annotating/stddev_color_16/Makefile.am: New.
+	* exp/annotating/stddev_color_16/stddev_color_16.cc: New.
+	* exp/annotating/value/Makefile.am: New.
+	* exp/annotating/value/text-color.txt: New.
+	* exp/annotating/value/text-img.txt: New.
+	* exp/annotating/value/text-only.txt: New.
+	* exp/annotating/value/value.cc: New.
+	* mln/clustering/kmean2d.hh: New.
+	* mln/fun/p2b/achromatic.hh: New.
+	* mln/fun/v2v/hue_concentration.hh: New.
+	* mln/fun/v2v/rgb_to_achromatism_map.hh: New.
+	* mln/fun/v2v/rgb_to_hsv.hh: New.
+
+
 2010-07-07  Yann Jacquelet  <jacquelet@lrde.epita.fr>
 
 	Import regional maxima sources from milena green's sandbox.
diff --git a/scribo/sandbox/green/README.green b/scribo/sandbox/green/README.green
index 7886914..5d6e147 100644
--- a/scribo/sandbox/green/README.green
+++ b/scribo/sandbox/green/README.green
@@ -685,21 +685,6 @@ rechercher dans les derniers répertoires mp00042c et mp00307c.
 * doc/labeling/mp00307c: Test sur la representativité des couleurs trouvées.
 
 
-Faire le changelog, il y a de l'aide dans git/doc/Changelog
-... et commiter
-
-
-XI ANNOTATING
---------------
-
-==> to do
-
-
-
-* doc/annotating
-
-
-
 XI AUTRES ASPECTS DOCUMENTAIRES
 -------------------------------
 
@@ -732,3 +717,495 @@ l'effort.
 * doc/formulae: LaTex directory.
 * doc/quick_tour: LaTex directory.
 
+
+XII ANNOTATING
+--------------
+
+Tout d'abord, voici les notes documentaires qui ont été réalisées sur
+la problématique d'annotation d'image. On trouvera un fichier
+class.txt qui a pour but de poser quelques réflexions sur les types de
+classes de document. Les informations ne sont pas abouties mais
+permettent de défricher un peu le terrain. Le document
+syntheseMillet2008 est un compte-rendu de lecture des parties
+relatives à nos travaux dans la thèse de Millet. Pour bien comprendre
+mon travail, il est impératif de lire les travaux de Millet, ou
+simplement ce compte-rendu. Le dernier document est moins intéressant,
+il s'agit d'une note de travail sur les indicateurs de Millet bruts de
+fonderie (testMillet2008). Cette note n'est ni achevée, ni
+aboutie. Elle conclue sur le fait que les indicateurs et les seuils
+donnés par Millet dans sa thèse sont complètement à revoir pour nos
+besoins. Notemment, des tests sur la détection des images par rapport
+aux cliparts nous ont convaincu que certaines images AFP contiennent
+des de grandes zones homogènes qui induisent des erreurs dans les
+prédicteurs de Millet. Néanmoins, les cas particuliers qui
+contredisent les aspects opérationnnels de Millet n'enlèvent pas sa
+réflexion: Les images noir/blanc (ou monochromes) ont une très faible
+saturation, et/ou une forte concentration de la teinte. Les cliparts
+ont une forte concentration de niveaux de gris autour d'un pic.
+
+* doc/annotating: La documentation relative à l'annotation.
+
+
+Après la lecture des descripteurs de Millet, un des premiers réflexe a
+été d'en implémenter plusieurs pour voir ce qu'ils pouvaient ressortir
+sur les images que nous avions. Le descripteur BIC sépare une image en
+deux ensembles de pixels, les points intérieurs et les points
+extérieurs. Les points intérieurs ont la propriété d'être de même
+couleur que leur 4-voisins. Attention, la couleur est évaluée dans un
+espace RGB à 3 bits.
+
+* demo/annotating/bic: Histogrammes des points intérieurs et extérieurs.
+
+
+Le descripteur LEP, lui, propose de seuiller par sobel l'image et de
+faire l'histogramme des configurations du voisinage des points
+seuillés. Pour ce faire, on utilise une convolution un peu spéciale
+qui va attribué un unique id en fonction du voisinage.
+
+* demo/annotating/lep: Histogramme des configurations des voisinages des pixels.
+
+
+Un autre descripteur simple est le nombre de couleur dans une
+image. Pour cela, il est possible de construire l'histogramme des
+couleurs et de compter les cellules pleines. On peut éventuellement
+appliquer une quantification sur l'espace des couleurs.  La
+compilation laisse place à d'étranges warnings sur une comparaison
+entre entiers signés et non signés, mais je n'ai pas la main dans mon
+code (ou je ne sais pas comment faire) pour enlever ces warnings. Ils
+sont récents, je n'avais pas souvenir de les avoir eu.
+
+* demo/annotating/nb_color: Compte le nombre de couleurs dans une image.
+* exp/annotating/nb_color: Adaptation pour fonctionner sur une base d'image.
+
+
+L'histogramme RGB-64 est un descripteur simple qui quantifie les
+couleurs sur 2 bits et réalise l'histogramme dans cet espace. C'est
+bien sûr une classification gros grain, mais ajouté au reste ... La
+version RGB-64-9 ajoute une phase de division de l'image en 9 sous
+images. De cette manière, l'histogramme RGB-64 est construit sur les 9
+sous images. Pour former le descripteur final, on fusionne les neufs
+histogrammes.
+
+* demo/annotating/rgb_64: Histogramme couleur dans l'espace RGB-64 (2 bits/axe).
+* demo/annotating/rgb_64_9: Histogramme RGB-64 sur les 9 sous images.
+
+
+Le descripteur de projection relaté par Millet est particulier. En
+premier lieu l'image est sous échantillonnée pour réduire sa dimension
+à 100 x 100 de manière à borner la taille des vecteurs obtenus au
+final. Puis l'image est seuillée par sobel (threshold = 100). L'image
+est d'abord divisée horizontalement en deux. Puis on établit la
+projecton perpendiculairement à la séparation de manière à obtenir
+deux vecteurs de 100 valeurs chacunes. On recommence l'opération en
+divisant maintenant l'image verticalement. L'union des 4 vecteurs
+forme le descripteur de projection. L'information condensée dans ces
+vecteurs est simplement la répartition des contours de manière
+horizontale ou verticale.
+
+* demo/annotating/project: Répartition des contours horizontaux et verticaux.
+
+
+La reconnaissance des cliparts s'appuie sur une analyse d'histogramme
+qui est fournie dans le code suivant. L'idée est de dire qu'une image
+de type clipart va être reconnaissable surtout à l'aide de ces
+contours. La couleur existe mais est très grossière. Le faitde
+dessiner à la main implique de simplifier énormément, de caricaturer,
+le remplissage. Du coup, une analyse en niveau de gris de
+l'histogramme révèle très peu de nuances. Il peut cependant en avoir
+un peu. Néanmoins, il existe des logiciels pour aider à la fabrication
+des cliparts qui proposent l'usage de dégradé, ce qui nuit à cette
+méthode de reconnaissance. Millet analyze l'histogramme normalisé
+(histogramme divisé par son pic) et regarde si son energie ne serait
+pas concentrée autour du pic (5 pixels de chaque côté
+maximum). Parfois cette méthode ne fonctionne pas correctement sur des
+photographies qui ont un cadre uniforme. La méthode trouve un pic (le
+cadre) et vérifie alors qu'une proportion non négligeable des pixels
+sont bien autour de ce pic (tout dépend de l'épaisseur du cadre). Pour
+palier à cet inconvénient, Millet propose d'utiliser ce test, non plus
+sur l'image entière, mais sur chacune des 16 sous images après un
+découpage géométrique régulier. De facto, la contribution du cadre
+diminue suffisemment pour repasser en dessous du seuil de
+reconnaissance.
+
+* demo/annotating/stddev_color: Descripteur utilisé reconnaitre des cliparts.
+* exp/annotating/stddev_color_16: Adaptation pour le travail sur base.
+* demo/annotating/stddev_color_16: Descripteur pour cliparts avec 16 imagettes.
+* exp/annotating/stddev_color: Adaptation pour le travail sur une base d'image.
+
+
+A partir de maintenant, tous les morceaux de codes réalisés préparent
+directement ou indirectement le résultat de la classification des
+bases (exp/annotating/bench).
+
+Plus de temps pour faire le code use correspondant aux fichiers
+librairies. Tout le code pour le faire est dans hsv. Rien de
+compliqué, mais allons à l'essentiel.
+
+Le but du code HSV est d'effectuer les tests de Millet ou des
+améliorations sur ces tests. Le premier test proposé par Millet est
+l'achromaticité. Il s'agit de regarder s'il existe une faible
+variation entre les trois canaux (R/G/B) pour un grand nombre de
+pixels. Si c'est le cas, c'est que l'image est presque en niveau de
+gris et peut être remplacée facilement par une image grisée sans trop
+de distorsions au niveau de la couleur. Nous avons essayer de
+généraliser un peu le test de manière à produire, non pas seulement
+une réponse sur l'achromaticité de l'image, mais aussi avoir une vue
+d'ensemble (sous forme d'image) des variations entre les cannaux pour
+chaque pixel. Il n'est pas utile d'analyser les différences sur chacun
+des canaux, prendre la différence absolue entre le canal min et le
+canal max suffit pour définir le test d'achromaticité.
+
+Les autres tests de Millet sont la faible saturation et la dominance
+de la teinte. Pour savoir si la saturation est faible, il faut
+utiliser un histogramme du canal dédié à la saturation. Si 95% des
+pixels sont en dessous de 100, alors l'image est faiblement saturée,
+elle est en noir et blanc. De la même manière, on regarde la dominance
+de la teinte. Pour ce faire, il faut voir si l'histogramme de la
+teinte ne possède pas un pic avec une très faible variance (tout
+rapproché autour du pic). Si c'est le cas, la dominance de la teinte
+est avérée et l'on peut calculé la couleur dominante. L'image est en
+niveau de gris, mais colorisé autour d'une couleur (par cepia, vert
+...).
+
+Ce programme est très très sujet à changements, il m'a servit de test
+et je ne peux pas juré qu'il est complètement sain au niveau du
+traitement. D'autres versions sont potentiellement plus
+stables. Notemment celle dans exp/annotating/hsv.
+
+* mln/fun/v2v/rgb_to_achromatism_map.hh : Distance pour l'achromaticité.
+* mln/fun/v2v/achromatic.hh : Define the achromatic map.
+* mln/fun/v2v/hue_concentration.hh : Define the distance hue/peak map.
+* mln/fun/p2b/achromatic.hh : Say if a site is achromatic.
+* demo/annotating/hsv: Code des différents tests de Millet.
+
+
+Dans le répertoire exp/annotating/hue, on trouve 3 fichiers textes qui
+rassemblent des classes d'images. Tout d'abord les images ICDAR
+n'ayant que du texte et des traces de couleurs (lettrine de couleur,
+trait, petit bandeau), un fichier où il n'y a que du texte noir &
+blanc et un fichier contenant les images couleurs (avec photographies
+ou dessins). Cette classification a été effectuée de manière manuelle.
+Le code hue test la proportion de pixels étant autour du pic de
+teinte. Il s'agit de savoir si la dominance d'une teinte est
+avérée. Le code renvoit la proportion de pixels agglomérés autour du
+pic. Le but est de généralisé les tests de millets pour qu'ils se
+ressemblent le plus possible.
+
+* exp/annotating/hue: Implémentation de la généralisation du test de Millet.
+* mln/fun/v2v/rgb_to_hue_map.hh : Construction de la map de teinte.
+
+
+On retrouve les trois fichiers permettant de classifier la base ICDAR
+en trois sous populations. Le test de saturation consiste simplement à
+regarder si une certaine quantité de la population de l'histogramme de
+saturation est en dessous d'un certain seuil. La généralisation du
+test ne porte pas sur le test en lui-même, mais sur la forme dans
+lequel le test est fait.
+
+* exp/annotating/saturation: Implémentation de la généralisation du test.
+* mln/fun/v2v/rgb_to_saturation_map.hh : Construction de la map de saturation.
+
+
+Le test de value a déjà été décrit précédemment dans
+stddev_color. L'idée est toujours la même, mais cette fois il est
+effectué dans l'espace des valeurs (HSV). Cela ne change pas grand
+chose, puisqu'il était utilisé sur des images en niveau de gris. C'est
+l'un des tests importants car il réagit à la différentiation entre une
+image type photographie et une image plus stylisée comme un
+clipart. Ce test a aussi des vertus pour la distinction entre du noir
+& blanc et de la couleur. Il s'avère que les images type photographie
+avec pleins de couleurs ont un histogramme moins sujet aux pics que
+les histogrammes noir & blanc. De facto, l'énergie de l'histogramme
+est distribué sur l'ensemble de la plage contrairement aux images noir
+& blanc où il y a une concentration de chaque côté de l'histogramme
+(bipolarité).
+
+* exp/annotating/value: Implémentation de la généralisation du test de Millet.
+* mln/fun/v2v/rgb_to_value_map.hh : Transformation d'espace.
+
+
+Le programme hsv reprend les tests préalablement élaborés auparavant
+sur les plans H, S puis V. Il combine tout en un seul programme pour
+avoir une vision plus synthétique de ce qui se passe sur les 3 espaces
+simultanément.
+
+Les tests incorpore mes transformations. C'est à dire que l'on
+effectue une série de test équivalent à ceux de Millet (au moins dans
+l'idée et le plus souvent, il s'agit d'une réecriture sous une autre
+forme) en partant des histogrammes normalisés. Un histogramme
+normalisé est un histogramme de flottant qui contient l'histogramme
+classique divisé par le nombre total de pixels. En faisant cela, on se
+déplace dans l'espace des distributions. Si l'histogramme n'a qu'un
+seul pic et que ce dernier contient tous les pixels (pic de dirac par
+exemple), alors l'histogramme normalisé donnera 1 comme valeur de
+proportion à ce pic. En fait, l'intégrale d'une distribution vaut
+1. Le but des distributions est de s'affranchir des caractéristiques
+de taille de l'image, ce qui permet de comparer les histogrammes entre
+eux. On peut ainsi comparer les histogrammes d'une photo AFP petit
+format avec celui d'une image grand format de la base ICDAR. Le but du
+jeu est de garder les idées de Millet dans ce nouvel espace. Les tests
+obtenus sont équivalents mais pas identiques.
+
+Pour la teinte, une fois l'histogramme normalisé obtenu, on cherche à
+savoir s'il existe un pic avec une forte proportion de l'histogramme
+autour de ce pic. Plutôt que le pic, nous prenons la moyenne qui est
+un opérateur un peu plus robuste et nous calculons la proportion de
+l'histogramme autour (un seuil donné en paramètre défini le périmètre
+du calcul). L'expression sous forme de proportion plutôt que sous la
+forme d'une variance rend le test homogène avec les autres tests.
+
+Pour la saturation, après normalisation, on regarde la proportion de
+l'histogramme en dessous d'un certain seuil. Il n'y a pas de
+changement significatif par rapport au test de Millet. Le seuil
+initialement proposé par Millet était 100, il a été adapté car nos
+bases sont différentes des siennes (le notre est à 25).
+
+Le test sur les valeurs (cliparts contre photos) a vraiment un intérêt
+au delà de ce cas d'utilisation. Il nous renseigne sur la
+concentration autour d'un pic de l'histogramme ou non. Nous préferrons
+la mesure de similarité à l'équi-répartition des densités, mais l'idée
+est exactement la même. Est-ce que notre histogramme est plat ou
+inversement, est-ce que les contributions sont rassemblées autour d'un
+pic? Si une image est noir et blanc, il existera un pic correspondant
+au fond et la densité s'éloignera fortement de la distribution
+équiprobable. Dans le cas maintenant d'une image couleur, la
+répartition est plus homogène, couvrant un large spectre dans le
+domaine de l'histogramme. Du coup, la distribution semblera davantage
+equi-répartie. On notera que nous prenons le test à l'envers de ce que
+propose Millet. Il essaye de voir si il y a un pic et calcule une
+forme de contribution normalisée autour de ce pic. Nous au contraire,
+on regarde l'absence de pic et on calcule la différence entre la
+densité et cette absence de pic. Notre avantage par rapport à Millet
+est démontré particulièrement dans les cas où il existe plusieurs
+grosses distributions. A contrario, notre test souffre des cas où il
+existe de nombreuses petites distributions.
+
+
+Voici un premier retour sur les expériementations:
+La discrimination entre la base AFP et la base ICDAR peut se faire en
+étudiant la forme des densités des niveaux de gris.  Les images
+naturelles semblent avoir un spectre recouvrant en général les 256
+niveaux de gris alors que les images de documents ont une présence
+importante du fond. Dans le cadre d'une densité, ce qui est alloué sur
+le fond ne peut se retrouver ailleurs. Une comparaison avec la densité
+équiprobable nous renseigne donc sur la nature des images.  Il semble
+néanmoins qu'un certain nombre d'images défient ce dispositif.  Par
+exemple des gros plans sur des zones mono-teintée (ski, voile,site
+web).
+
+* exp/annotating/hsv: Code unifiant les trois tests sur chacun des plans HSV.
+* mln/fun/v2v/rgb_to_hue_map.hh : Transformation d'espace.
+* mln/fun/v2v/rgb_to_saturation_map.hh : Transformation d'espace.
+* mln/fun/v2v/rgb_to_value_map.hh : Transformation d'espace.
+
+
+Le test sur l'achromatisme des images est décrit dans le code
+suivant. Il a été purement et simplement abandonné dans la mesure où
+c'est un cas très particulier qui est repris par une saturation très
+faible. La saturation s'exprime comme 1 - min(channel)/max(channel),
+mais dans le cas où le min(channel) == max(channel), la saturation
+vaut 0. Le problème vient plutôt du calcul de la teine qui ne peut pas
+admettre que le min soit égal au max. Pour ce calcul, on se débrouille
+pour gérer le cas et renvoyer une valeur standardisée, Millet
+proposait -1.
+
+* exp/annotating/achromatism: Détection d'image couleur en niveau de gris.
+* mln/fun/v2v/rgb_to_achromatism_map.hh : Transformation d'espace.
+
+
+Ce programme a pour but de créer les histogrammes normalisés en rafale
+pour les bases AFP et ICDAR. Il assure leur création dans les six
+plans possibles R,G,B,H,S,V. De cette manière il est possible de
+vérifier les corrélations éventuelles entre le canal B et G. Par
+ailleurs, après visionnement de tous les histogrammes, on note des
+spécificités dans les deux bases sur les plans S et V. Certaines
+images ont des réactions très fortes sur le plan H, mais ce n'est pas
+une caractéristique pour une base (seulement pour ces images en
+question). Les résultats ont déjà été sauvegardés dans le répertoire
+image du LRDE. Des infos sont notés à ce  sujet dans README.result. Le
+seul but de ce calcul est de maîtriser csujet dans README.result. Le
+seul but de ce calcul est de maîtriser ce qui se passe dans ces
+espaces, pas simplement de supposer ce qu'il pourrait s'y passer. La
+comparaison des images est rendu possible quelque soit la base
+d'origine par le fait qu'elles sont normalisées. Chaque fréquence des
+histogrammes est divisée par la somme des fréquences. On obtient donc
+une version discrète des densitées. La somme des nouvelles fréquences
+vaut 1.  On voit davantage si les densités se rapprochent d'une
+équi-répartition ou non. La négative implique un ou plusieurs pics. Le
+cas défavorable dans mon approche (qui existe pour certaines images)
+est une multitude de tout petits pics autour de l'équi-répartition. Ce
+n'est pas équi-répartie pour les calculs mais ce n'est clairement pas
+la manisfestation d'une concentration de l'énergie quelque part.
+
+* exp/annotating/histo: Creation des histogrammes normalisés.
+* mln/fun/v2v/rgb_to_hue_map.hh: Transformation d'espace.
+* mln/fun/v2v/rgb_to_saturation_map.hh: Transformation d'espace.
+* mln/fun/v2v/rgb_to_value_map.hh: Transformation d'espace.
+
+
+Dans le programme erreur, on teste l'idée de jonathan. Une référence à
+ce sujet peut être trouvée dans README.img. Les bases AFP et ICDAR
+sont retravaillées à l'aide de ImageMagick et de Gimp pour diminuer le
+nombre de couleurs initiales. On oblige à n'avoir que 30, 20 ou 10
+couleurs pour chaque base. Il y a donc 4 versions de chacune des bases
+en comptant la version originale des images. Les algorithmes utilisés
+par Gimp et ImageMagick sont très différents. L'idée de Jonathan était
+de dire que lorsqu'une image est couleur, plus on réduit le nombre de
+couleur, plus elle change vis-à-vis de l'image originale. Inversement,
+si une image possède peu de couleurs (noir & blanc), sa dégradation ne
+l'altérera pas tant que cela. Prenons une image d'un skieur de la base
+AFP, en réduisant le nombre de couleurs, la combinaison marron va
+devenir marron strictement homogène et la perception que nous en avons
+est visuellement très altérée. A contrario, une image en noir & blanc
+ne semble pas bouger d'un pouce. La comparaison avec la discrimination
+sur la saturation ou la valeur montrera des résultats un peu meilleur
+plus tard mais il impossible de préjuger a priori des résultats
+futurs. L'erreur entre l'image initiale et l'image dégradée est
+calculée avec le PNSNR (compression p278 Handbook Color). Le programme
+calcule la dégradation et essaie de trouver automatiquement des seuils
+de séparation pour les deux bases. 4 détection de seuils sont testées.
+Ces seuils sont calculées avec deux bases représentatives des bases à
+discriminer. En mode production, le seuil est vu comme une constante
+pour le programme. Les deux premières classifications renvoient un
+seuil calculée comme une moyenne pondérée des moyennes des populations
+à discriminer. Le premier détecteur pondère par la déviation standard
+et le second par la variance. Le troisième simule deux populations
+gaussiennes de variances différentes et résoud l'équation de second
+degré qui en résulte. Enfin, le dernier test ne préjuge pas des
+distributions statistiques et réalise la minimisation de l'erreur de
+classification. Pour cela, il suffit de compter le nombre d'images
+bien classées et mal classées sur les bases d'apprentissage des
+populations. On utilise pour cela la méthode Otsu. Le détecteur PNSRN
+renvoie une valeur. Pour chaque population (AFP, ICDAR), on construit
+l'histogramme de des valeurs obtenues. A noter, qu'il faut que les
+valeurs du PNSNR soient ramenées entre 0 et 255. En pratique ce n'est
+pas un problème, mais il faut le mettre en oeuvre, dans mon code, ce
+n'est pas fait (les valeurs ne posaient pas de problème). Donc, pour
+chaque seuil possible (de 0 à 256), on étudie la matrice de classement
+(groupe 1 - détecté groupe 1, groupe 1 - détecté groupe 2, groupe 2 -
+détecté groupe 1, groupe 2 - détecté groupe 2). L'erreur est
+simplement la somme des quantités groupe x - détecté groupe y avec x
+!= y. Finalement, pour chaque seuil, il est possible de connaitre
+l'erreur. Le processus de minimisation de l'erreur revient à chercher
+le seuil associé à l'erreur minimale. C'est ce dernier test que nous
+préconisons. Il faut mettre en lumière que ces quatre tests renvoient
+à peu près les mêmes seuils. La minimisation de l'erreur étant le
+meilleur de tous puisqu'il minimise directement l'erreur de
+classification et c'est ce que nous cherchions en fin de compte. Un
+cinquième test a été fait avec une analyse de fisher sur l'histogramme
+des populations mélangées, mais c'est une idée saugrenue car nous
+disposons à ce niveau des populations séparées et évidemment les
+résultats sont moins bons.
+
+Petit rappel. Un vieux problème a été mis à jour ici. Lorsqu'on
+calcule des informations sur un histogramme, le type temporaire qui
+contient les résultats ne doit pas être le type qui encode les valeurs
+des résultats. Par exemple, un histogramme de byte, un calcul de
+variance tout simple où il faut stocker la valeur des pixels au carré
+multiplié par leur occurrence tiendra facilement dans un long mais pas
+dans un byte. Le sucre avec les acesseurs des itérateurs tend à
+mélanger les genres. Une solution simple est de stocker la valeur de
+l'histogramme dans un type pouvant effectuer les calculs et ensuite
+retravailler avec ce type. Nous avions déjà discuté de ce problème et
+je ne sais pas si tu avais pu corriger le problème. Si la
+classification renvoit n'importe quoi, il se peut que cela provienne
+de ce problème. Le problème ne se voit pas sur des calculs de
+moyennes, il ne s'observe que sur certains calculs de variance (dépend
+de la formule utilisée).
+
+* exp/annotating/error: Test de l'idée de jonathan (dégradation des couleurs)
+
+
+Le travail dans bench.cc reprend toute sorte de travaux déjà réalisés
+dans d'autres fichiers. Il a pour but de comparer ensemble tous les
+descripteurs pour la reconnaissance de base de données entre l'AFP et
+l'ICDAR.
+
+Le travail commence avec un certain nombres de routines travaillant
+sur les histogrammes permettant de trouver le pic, la moyenne, la
+variance et d'autres éléments. Les routines étaient éparpillées dans
+le code, du coup je les ai regroupées au même endroit. Il y a des
+redondances de code correspondant à des copier/coller ou à différents
+essais. Prendre les versions les plus génériques et en faire des
+accumulateurs serait un riche idée.
+
+Huit détecteurs sont comparés ensembles:
+- hue1, détection d'un pic de teinte très dense par la méthode de Millet.
+- sat1, détection d'une densité importante dans les saturations basses (Millet).
+- lvl0, comptage du nombre de niveau de gris (idée de Millet).
+- hue0, détection d'un pic de teinte par la méthode des densités.
+- sat0, détection d'une forte basse saturation par la méthode des densités.
+- val0, détection d'un pic de niveau de gris par la méthode des densités.
+- val1, détection d'un pic de niveau de gris par la méthode de Millet.
+- err, PNSNR (idée de jonathan).
+
+FIXME: Attention, le PNSNR n'est pas borné, il faut le faire, il doit avoir
+au maximum 255 comme valeur.
+
+Tous les détecteurs ont été expliqués en large, en long et en travers
+dans les sources précédentes. LIRE le chapitre XII (ANNOTATING) de ce fichier
+en entier.
+
+Ensuite vient les séparateurs de population statistiques qui ont été
+déjà introduit dans le fichier error. Bien que tous soient présent,
+c'est la minimisation de l'erreur qui est utilisée.
+
+Enfin vient le front end, l'un des plus complexes que j'ai écrit cette
+année.  Le main lui même, n'est pas la partie la plus complexe. Il
+définit les actions fonctionnelles à réaliser et la structure de
+donnée réalisée pour garder la trace de tous les résultats.
+- File_name : Cette variable retient le nom des fichiers. C'est un tableau
+de la taille du nombre d'images rencontrées toute base confondue. Comme on
+ne parcourt qu'une fois les répertoires, il faut pouvoir retenir cette
+information qui servira éventuellement pour la nomenclature des dumps
+par la suite.
+- Result : Cette variable contient toutes les informations du traitement.
+C'est un tableau à deux dimensions, une pour les images et une autre pour
+les descripteurs. L'index d'image est le même que pour file_name.
+- Size : Cette variable contient le nombre d'images par database.
+- Threshold : Cette variable va stocker les seuils calculés sur chacun
+des descripteurs. Ces seuils sont sensés effectuer la séparation entre les
+deux bases.
+- Cxx : variables de comptage des images bien ou mal classées relativement
+à la position des seuils et à l'appartenance d'origine des images. Cette
+appartenance d'origine est calculée à l'aide Size qui contient le nombre
+d'image par base de données. Comme les images sont vues dans l'ordre, les X
+premières appartiennent à la base ICDAR et les Y suivantes à la base AFP.
+- histo : Variable servant à effectuer par database et par descripteur un
+histogramme utilisé ensuite lors de la discrimination des bases.
+
+La partie compute_descriptors a pour mission de passer une fois sur
+toutes les images et de calculer les descripteurs associés. A l'issue
+de cette passe file_name, result et size sont remplis et pourront être
+utilisés par les autres routines.
+
+La partie dump_descriptors a pour but de réaliser un tracé en gnuplot,
+avec une couleur différente pour chaque base. Le graphe montre les
+valeurs utilisées par chaque descripteur pour toutes les images de la
+base.
+
+La partie correction des descripteurs est optionnelle et force un
+certain nombre de valeurs pour être inférieures à 256. Le but était de
+pouvoir travaillé, même si les descripteurs n'étaient pas complètement
+opérationnels. Elle sert donc pour le debug.
+
+La partie calcul des histogrammes sert à obtenir la distribution des
+valeurs de chacun des descripteurs en fonction des bases
+utilisées. C'est une étape préliminaire à l'analyse des populations et
+au calcul des seuils.
+
+La partie calcul des seuils repose sur la minimisation des erreurs de
+classification. Cette méthode ne fonctionne bien si la classe zéro à
+une moyenne inférieure à la classe un. Du coup, il n'est pas possible
+de déterminer de manière simple si la classe 0 correspond à l'AFP ou à
+l'ICDAR. Pour chaque descripteur, les cartes sont rebattues.
+
+Enfin, tous les histogrammes sont sauvés pour pouvoir comprendre et
+visualiser les résultats.
+
+Le main2 ne sert à rien, juste pour des essais.
+
+Attention, modification VAL0/VAL1, vérifiez que le bon descripteur est
+au bon endroit dans le tableau.
+
+* exp/annotating/bench: Comparaison des détecteurs pour la classif. ICDAR/AFP.
\ No newline at end of file
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/bic/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/bic/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/bic/bic.cc b/scribo/sandbox/green/demo/annotating/bic/bic.cc
new file mode 100644
index 0000000..f63d260
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/bic/bic.cc
@@ -0,0 +1,122 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet BIC descriptor [millet.phd.2008.pdf]
+///
+/// This is an image descriptor. It quantifies the three channels on 3
+/// bits, then builds two histograms with the interior pixels and the
+/// exterior ones.  The interior pixels are those where color value is
+/// the same as their 4 neighbouring pixels. The descriptor is the
+/// fusion of the two histograms.
+
+#include <iostream>
+
+#include <mln/accu/stat/histo3d_rgb.hh>
+
+#include <mln/core/image/image2d.hh>
+#include <mln/core/alias/neighb2d.hh>
+#include <mln/core/routine/initialize.hh>
+#include <mln/core/var.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/convert.hh>
+#include <mln/data/transform.hh>
+#include <mln/data/fill.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/ppm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/literal/colors.hh>
+
+#include <mln/value/rgb.hh>
+#include <mln/value/rgb8.hh>
+
+/// \brief Main entry.
+///
+/// Load the images, compute the interior and the exterior with the
+/// predicate, then compute the two histograms separately.
+int main()
+{
+  typedef mln::value::rgb<3>                 t_rgb3;
+  typedef mln::value::rgb8                   t_rgb8;
+  typedef mln::neighb2d                      t_neighb2d;
+  typedef mln::image2d<t_rgb3>               t_image2d_rgb3;
+  typedef mln::image2d<t_rgb8>               t_image2d_rgb8;
+  typedef mln::image3d<unsigned>             t_histo3d;
+  typedef mln::fun::v2v::rgb8_to_rgbn<3>     t_rgb8_to_rgb3;
+  typedef mln::accu::meta::stat::histo3d_rgb t_histo3d_fun;
+
+  t_image2d_rgb8                             input_rgb8;
+  t_image2d_rgb3                             input_rgb3;
+  t_image2d_rgb3                             interior_rgb3;
+  t_image2d_rgb3                             exterior_rgb3;
+  t_histo3d                                  histo_exterior;
+  t_histo3d                                  histo_interior;
+
+  // IMAGE LOADING PHASE
+  std::cout << "Image loading phase ..." << std::endl;
+  mln::io::ppm::load(input_rgb8, ICDAR_50P_PPM_IMG_PATH"/mp00082c_50p.ppm");
+  input_rgb3 = mln::data::transform(input_rgb8, t_rgb8_to_rgb3());
+
+  mln::initialize(interior_rgb3, input_rgb3);
+  mln::initialize(exterior_rgb3, input_rgb3);
+
+  mln::data::fill(interior_rgb3, mln::literal::black);
+  mln::data::fill(exterior_rgb3, mln::literal::black);
+
+  mln_piter_(t_image2d_rgb3) p(input_rgb3.domain());
+  mln_niter_(t_neighb2d)     n(mln::c4(), p);
+
+  for_all(p)
+  {
+    bool is_interior = true;
+
+    for_all(n)
+      is_interior = is_interior && (input_rgb3(p) == input_rgb3(n));
+
+    if (is_interior)
+      interior_rgb3(p) = input_rgb3(p);
+    else
+      exterior_rgb3(p) = input_rgb3(p);
+  }
+
+  histo_interior = mln::data::compute(t_histo3d_fun(), interior_rgb3);
+  histo_exterior = mln::data::compute(t_histo3d_fun(), exterior_rgb3);
+
+  //mln::io::plot::save_image_sh(histo, "histo.sh");
+
+  // PRINTING PHASE
+  mln::debug::println(histo_interior);
+  mln::debug::println(histo_exterior);
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/hsv/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/hsv/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/hsv/hsv.cc b/scribo/sandbox/green/demo/annotating/hsv/hsv.cc
new file mode 100644
index 0000000..e87ab2d
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/hsv/hsv.cc
@@ -0,0 +1,721 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet HSV operator [millet.phd.2008.pdf]
+///
+/// This is the Millet code for moving from RGB space to HSV
+/// one. Formulae are classical, we can find them on the web.
+///
+// Val = max(R,G,B).
+// Sat = (max(R,G,B) - min(R,G,B))/max(R,G,B).
+// IF R = max(R,G,B) THEN Hue = 60 * [(V-B)/(max(R,G,B)-min(R,G,B))].
+// IF G = max(R,G,B) THEN Hue = 60 * [2 + (B-R)/(max(R,G,B)-min(R,G,B))].
+// IF B = max(R,G,B) THEN Hue = 60 * [4 + (R-G)/(max(R,G,B)-min(R,G,B))].
+///
+/// \fixme: This code is unstable. It was using to make a lot of tests.
+/// Don't use it, we have more stable version of it.
+#include <iostream>
+#include <fstream>
+
+#include <mln/accu/max_site.hh>
+#include <mln/accu/math/count.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/binarization/threshold.hh>
+
+#include <mln/core/alias/point1d.hh>
+#include <mln/core/alias/box1d.hh>
+#include <mln/core/concept/image.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/transform.hh>
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/literal/colors.hh>
+#include <mln/literal/grays.hh>
+
+#include <mln/fun/v2v/rgb_to_hsv.hh>
+#include <mln/fun/v2v/rgb_to_achromatism_map.hh>
+#include <mln/fun/v2v/achromatism.hh>
+#include <mln/fun/v2v/hue_concentration.hh>
+#include <mln/fun/p2b/component_equals.hh>
+#include <mln/fun/p2b/achromatic.hh>
+#include <mln/fun/v2v/component.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/io/plot/save_image_sh.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/pbm/save.hh>
+
+#include <mln/pw/cst.hh>
+#include <mln/pw/value.hh>
+//#include <mln/trace/quiet.hh>
+
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u8.hh>
+#include <mln/value/hsv.hh>
+
+
+/// \brief Classify a rgb a value with a color of reference.
+///
+/// \param[in] rgb a rgb8 value.
+///
+/// \return a rgb8 initialize with the selecting literal.
+///
+/// This classification of the RGB color space is based on the
+/// Millet's work.  It uses the hue wheel to do it and make new
+/// distinction as brown/orange for instance.
+mln::value::rgb8 label_color(const mln::value::rgb8 rgb)
+{
+  mln::value::hsv_f hsv = mln::fun::v2v::f_rgb_to_hsv_f(rgb);
+
+  mln::value::rgb8 result;
+
+  // Is it a gray level ?
+  if (0 == hsv.sat())
+  {
+    // which result one ?
+    if (82 > hsv.sat())
+      result = mln::literal::black;
+    else if (179 > hsv.sat())
+      result= mln::literal::medium_gray;
+    else
+      result = mln::literal::white;
+  }
+  // Is it a true result color ?
+  else if (14 > hsv.hue())
+    result = mln::literal::red;
+  else if (29 > hsv.hue())
+  {
+    // Is is brown or orange ?
+    unsigned dist_orange = mln::math::abs(hsv.sat() - 184)
+      + mln::math::abs(hsv.val() - 65);
+
+    unsigned dist_brown  = mln::math::abs(hsv.sat() - 255)
+      + mln::math::abs(hsv.val() - 125);
+
+    if (dist_orange < dist_brown)
+      result = mln::literal::orange;
+    else
+      result = mln::literal::brown;
+  }
+  else if (45 > hsv.hue())
+  {
+    // Is it green or yellow ?
+    if (80 > hsv.val())
+      result = mln::literal::green;
+    else
+      result = mln::literal::yellow;
+  }
+  else if (113 > hsv.hue())
+    result = mln::literal::green;
+  else if (149 > hsv.hue())
+    result = mln::literal::cyan;
+  else if (205 > hsv.hue())
+    result = mln::literal::blue;
+  else if (235 > hsv.hue())
+    result = mln::literal::violet;
+  else if (242 > hsv.hue())
+    result = mln::literal::pink;
+  else
+    result = mln::literal::red;
+
+  return result;
+}
+
+/// \brief Sum all the bins of the histogram.
+///
+/// \param[in] img the histogram based on image.
+///
+/// \return the sum of the overall bins.
+///
+/// Sum evry bins and return the result.
+template <typename I>
+unsigned count_histo(const mln::Image<I>& img_)
+{
+  const I& img = exact(img_);
+
+  mln_precondition(img.is_valid());
+
+  unsigned     result = 0;
+  mln_piter(I) p(img.domain());
+
+  for_all(p)
+    result += img(p);
+
+  return result;
+}
+
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+
+/// \brief Find the peak of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the bin which contains the greatest value.
+///
+/// Compute the position of the peak of the histogram. To do this, we
+/// view evrey bin and we maintain the maxima of the values and the
+/// position. At the end, we return the position which contains the
+/// greatest value.
+template <typename I>
+unsigned peak_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  return p_max;
+}
+
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] image the input image to analyze.
+///
+/// \return the deviation.
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it).
+// unsigned stddev_color(mln::image2d<mln::value::int_u8> input_int_u8,
+// 		      const char *name_histo,
+// 		      const char *name_image)
+// {
+//   typedef mln::point1d                                t_point1d;
+//   typedef mln::value::rgb8                            t_rgb8;
+//   typedef mln::value::int_u8                          t_int_u8;
+//   typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+//   typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+//   typedef mln::image1d<unsigned>                      t_histo1d;
+//   typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+//   typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+//   typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+//   t_histo1d                                           histo;
+
+//   std::cout << "histo : " << name_histo << std::endl;
+//   std::cout << "image : " << name_image << std::endl;
+
+//   histo        = mln::data::compute(t_histo1d_fun(), input_int_u8);
+
+//   mln::io::pgm::save(input_int_u8, name_image);
+//   mln::io::plot::save_image_sh(histo, name_histo);
+//   mln::debug::println(histo);
+
+//   // Find the peak of the histogram
+//   unsigned v_max = mln::opt::at(histo, 0);
+//   short    p_max = 0;
+
+//   mln_piter_(t_histo1d) p(histo.domain());
+
+//   for_all(p)
+//   {
+//     if (v_max < histo(p))
+//     {
+//       v_max = histo(p);
+//       p_max = p.ind();
+//     }
+//   }
+
+//   // Compute the specific stddev
+
+//   float stddev_low = 0.0;
+//   float stddev_up  = 0.0;
+//   float stddev     = 0.0;
+
+//   if (250 > p_max)
+//     for (short i = p_max+1; i < p_max+6; ++i)
+//       stddev_up += r(p_max, mln::opt::at(histo,p_max),
+// 		     i, mln::opt::at(histo,i));
+
+//   if (5 < p_max)
+//     for (short i = p_max-1; i > p_max-6; --i)
+//       stddev_low += r(p_max, mln::opt::at(histo,p_max),
+// 		      i, mln::opt::at(histo,i));
+
+//   stddev = (250 < p_max)? stddev_low : (5 > p_max)? stddev_up :
+//     (stddev_low + stddev_up)/2;
+
+//   std::cout << "max_site    : " << p_max << std::endl;
+//   std::cout << "h(max_site) : " << v_max << std::endl;
+//   std::cout << "stddev_up   : " << stddev_up << std::endl;
+//   std::cout << "stddev_low  : " << stddev_low << std::endl;
+//   std::cout << "stddev      : " << stddev << std::endl;
+
+//   return 0;
+// }
+
+
+// -------------------------------------
+// input image     <name>.ppm
+// map             <name>-<map>.pgm
+// thresholded map <name>-<map>.pbm
+// histogram       <name>-<map>.sh
+// decision        <name>-<map>.txt
+// -------------------------------------
+// Achromatism     <name>-achromatism.pgm
+// call achromatism(input_rgb8, 7, 99.0)
+
+
+/// \brief Decide if an image is achromatic or not [Millet].
+///
+/// \param[in] input_rgb8 the input image.
+/// \param[in] threshold  the distance threshold used for equality.
+/// \param[in] percentage the percentage of pixels that very the test.
+///
+/// This is an improving of the Millet test. The original test
+/// compares rgb values to each other and look at differences greater
+/// than the threshold.  If the number of pixel that pass the test are
+/// greater than 99.0, then the image is declared achromatic. In fact,
+/// there is few variations between the three channels, so we can say
+/// that it is like a grey image. We can with no too distortions
+/// replace the color image by the grey one. The improving is in first
+/// creating a map of the difference. As we can't keep the free
+/// differences between channels, we look at reducing the test and we
+/// find an equivalent one based on the difference between minima
+/// channel value and the maxima channel value. After the map is
+/// ready, we make binarization with the threshold. Then we compute
+/// the histogram 1d for every pixels of the map that are greater the
+/// threshold. Then, we count pixels in the histogram and traduce the
+/// count in percentage to compare to the second threshold. Details
+/// are saved in files and printed in the screen.
+void achromatism(mln::image2d<mln::value::rgb8> input_rgb8,
+		 mln::value::int_u8             threshold,
+		 float                          percentage)
+{
+  typedef mln::fun::v2v::rgb_to_achromatism_map<8> t_rgb_to_achromatism_map;
+
+  mln::image2d<mln::value::int_u8> map;
+  mln::image2d<mln::value::int_u8> view;
+  mln::image2d<bool>               mask;
+  mln::image1d<unsigned>           histo;
+  unsigned                         cnt1;
+  unsigned                         cnt2;
+  float                            prop;
+  bool                             result;
+
+
+  map    = mln::data::transform(input_rgb8, t_rgb_to_achromatism_map());
+  view   = mln::data::stretch(mln::value::int_u8(), map);
+  mask   = mln::binarization::threshold(map, threshold);
+  histo  = mln::data::compute(mln::accu::meta::stat::histo1d(),
+			      map | (mln::pw::value(mask) == true));
+  cnt1   = count_histo(histo);
+  cnt2   = mln::geom::nsites(input_rgb8);
+  prop   = (100.0 * (cnt2 - cnt1) / cnt2);
+  result = (prop > percentage);
+
+
+  std::ofstream txt_stream("achromatism.txt");
+  txt_stream << "Achromatism" << std::endl;
+
+  txt_stream << "Nbre pixels               : " << cnt2       << std::endl;
+  txt_stream << "Nbre pixels achromatiques : " << (cnt2-cnt1)<< std::endl;
+  txt_stream << "Percentage                : " << prop       << std::endl;
+  txt_stream << "Image achromatique        : " << result     << std::endl;
+  txt_stream << std::endl;
+
+  txt_stream.flush();
+  txt_stream.close();
+
+  mln::io::pgm::save(view, "achromatism.pgm");
+  mln::io::plot::save_image_sh(histo, "achromatism.sh");
+  mln::io::pbm::save(mask, "achromatism.pbm");
+}
+
+
+/// \brief Decide if an image is low saturate or not and so b/w [Millet].
+///
+/// \param[in] input_hsvf the input image in the HSV space.
+/// \param[in] achromatism_mask the mask to prevent computing bad saturation.
+/// \param[in] threshold  the distance threshold used for equality.
+/// \param[in] percentage the percentage of pixels that very the test.
+///
+/// As we are in the HSV space, we can just isolate saturation
+/// channel. The original idea of Millet is to build histogram bound
+/// to 256 for the saturation. If a great percentage (95%) of the
+/// population are under a threshold (100), then the image has got low
+/// saturation. So, it is b/w image. Low saturation is sometimes
+/// redundant with the achromatism test but not every time.
+
+// call low_saturation(input_rgb8, achromatism_mask, 100, 95.0)
+void low_saturation(mln::image2d<mln::value::hsv_f>  input_hsvf,
+		    mln::image2d<bool>               achromatism_mask,
+		    mln::value::int_u8               threshold,
+		    float                            percentage)
+{
+  typedef mln::value::hsv_f                   t_hsvf;
+  typedef mln::value::hsv_f::s_type           t_sat;
+  typedef mln::fun::v2v::component<t_hsvf,1>  t_component_s;
+
+  mln::image2d<t_sat>              map;
+  mln::image2d<mln::value::int_u8> view;
+  mln::image2d<bool>               mask;
+  mln::image1d<unsigned>           histo;
+  unsigned                         cnt1;
+  unsigned                         cnt2;
+  float                            prop;
+  bool                             result;
+
+
+  map    = mln::data::transform(input_hsvf, t_component_s());
+  view   = mln::data::stretch(mln::value::int_u8(), map);
+  histo  = mln::data::compute(mln::accu::meta::stat::histo1d(),
+			      view|(mln::pw::value(achromatism_mask) == true));
+  prop   = (100.0 * (cnt2 - cnt1) / cnt2);
+  result = (prop > percentage);
+
+  std::cout << "Saturation" << std::endl;
+
+  cnt1 = count_histo(histo | mln::box1d(mln::point1d(0),mln::point1d(100)));
+  cnt2= mln::geom::nsites(achromatism_mask|
+			  (mln::pw::value(achromatism_mask)==false));
+
+  std::ofstream txt_stream("saturation.txt");
+  txt_stream << "Saturation" << std::endl;
+
+  txt_stream << "Nbre pixels               : " << cnt2       << std::endl;
+  txt_stream << "Nbre p faiblement saturés : " << cnt1       << std::endl;
+  txt_stream << "Pourcentage               : " << prop       << std::endl;
+  txt_stream << "Image faiblement saturé   : " << result     << std::endl;
+  txt_stream << std::endl;
+
+  txt_stream.flush();
+  txt_stream.close();
+
+  mln::io::pgm::save(view, "saturation.pgm");
+  mln::io::plot::save_image_sh(histo, "saturation.sh");
+  mln::io::pbm::save(mask, "saturation.pbm");
+}
+
+/* This is a classification of the ICDAR base in 3 modalities.
+// COLOR
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00032c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00042c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00076c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00082c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00142c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00215c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00228c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00234c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00248c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00252c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00253c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00255c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00259c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00271c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00290c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00293c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00304c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00307c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00376c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00411c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00419c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00447c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00498c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00510c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00550c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00573c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00589c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00592c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00597c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00599c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00600c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00031c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00034c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00043c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00063c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00065c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00072c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00081c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00083c_20p.ppm");
+
+// BLACK AND WHITE
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00329c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00036c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00037c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00039c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00040c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00049c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00055c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00057c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00068c_20p.ppm");
+
+
+// A LITTLE BIT OF COLOR
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00262c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00263c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00311c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00319c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00440c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00608c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00630c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00631c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00028c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00046c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00073c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00089c_20p.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/ta00090c_20p.ppm");
+*/
+
+
+/// \brief The main entry and the whole processing routine
+///
+/// This is the routine which works on Millet test. First compute the
+/// achromatic mask. Then build the transfer between RGB and HSV. Then
+/// isolate each channel to work on it. Each separate channel is bound
+/// between 0 and 255. Then keep only pixels low saturated (< 100 in S
+/// canal) in a specefic map. Build the 3 histograms without the
+/// achromatic pixels based on the 3 separated channels (H/S/V). Build the
+/// 3 maps (hue_concentration, low_saturation and achromatism). Then do
+/// the 3 tests of Millet with the thow thresolded pass (threshold,percentage).
+int main()
+{
+  typedef mln::value::rgb8                                  t_rgb8;
+  typedef mln::value::int_u8                                t_int_u8;
+  typedef mln::value::hsv_f                                 t_hsvf;
+  typedef mln::value::hsv_f::h_type                         t_hue;
+  typedef mln::value::hsv_f::s_type                         t_sat;
+  typedef mln::value::hsv_f::v_type                         t_val;
+  typedef mln::image2d<t_hue>                               t_image2d_hue;
+  typedef mln::image2d<t_sat>                               t_image2d_sat;
+  typedef mln::image2d<t_val>                               t_image2d_val;
+  typedef mln::image2d<t_hsvf>                              t_image2d_hsvf;
+  typedef mln::image2d<t_rgb8>                              t_image2d_rgb8;
+  typedef mln::image2d<float>                               t_image2d_float;
+  typedef mln::image1d<unsigned>                            t_histo1d;
+  typedef mln::image2d<t_int_u8>                            t_image2d_int_u8;
+  typedef mln::image2d<bool>                                t_mask;
+  typedef mln::fun::v2v::f_rgb_to_hsv_f_t                   t_rgb8_to_hsv;
+  typedef mln::accu::math::count<t_hsvf>                    t_count;
+  typedef mln::fun::v2v::component<t_hsvf,0>                t_component_h;
+  typedef mln::fun::v2v::component<t_hsvf,1>                t_component_s;
+  typedef mln::fun::v2v::component<t_hsvf,2>                t_component_v;
+  typedef mln::fun::p2b::component_equals<t_image2d_hsvf,0> t_component_eq0;
+  typedef mln::fun::p2b::component_equals<t_image2d_hsvf,1> t_component_eq1;
+  typedef mln::fun::p2b::component_equals<t_image2d_hsvf,2> t_component_eq2;
+  typedef mln::fun::p2b::achromatic<t_rgb8>                 t_achromatic;
+
+  t_image2d_rgb8                                            input_rgb8;
+  t_image2d_hsvf                                            input_hsvf;
+
+  t_mask                                                    achromatic;
+  t_mask                                                    low_saturation;
+
+  t_image2d_float                                           achromatism1;
+  t_image2d_int_u8                                          achromatism2;
+  t_image2d_float                                           hue_concentration1;
+  t_image2d_int_u8                                          hue_concentration2;
+
+  t_image2d_hue                                             input_h;
+  t_image2d_hue                                             input_h2;
+  t_image2d_sat                                             input_s;
+  t_image2d_val                                             input_v;
+
+  t_image2d_int_u8                                          input_h8;
+  t_image2d_int_u8                                          input_s8;
+  t_image2d_int_u8                                          input_v8;
+
+  t_histo1d                                                 histo_h;
+  t_histo1d                                                 histo_s;
+  t_histo1d                                                 histo_v;
+
+  unsigned                                                  cnt1;
+  unsigned                                                  cnt2;
+  float                                                     percentage;
+  bool                                                      result;
+
+
+
+  // IMAGE LOADING PHASE
+  std::cout << "Image loading phase ..." << std::endl;
+//  mln::io::ppm::load(input_rgb8, ANNOTATING_1_BILL_IMG_PATH"/bill03.ppm");
+  mln::io::ppm::load(input_rgb8, ICDAR_20P_PPM_IMG_PATH"/mp00082c_20p.ppm");
+
+
+//  achromatism(input_rgb8,7,99.0);
+//  exit(-1);
+
+  // REPERAGE DES PIXELS ACHROMATICS
+  std::cout << "Init achromatic mask ..." << std::endl;
+  initialize(achromatic, input_rgb8);
+  mln::data::fill(achromatic, false);
+  mln::data::fill((achromatic | t_achromatic(input_rgb8, 0.03)).rw(), true);
+
+  mln::io::pbm::save(achromatic, "achromatic.pbm");
+
+  std::cout << "Achieve canal forking ..." << std::endl;
+  input_hsvf = mln::data::transform(input_rgb8, t_rgb8_to_hsv());
+  input_h    = mln::data::transform(input_hsvf, t_component_h());
+  input_s    = mln::data::transform(input_hsvf, t_component_s());
+  input_v    = mln::data::transform(input_hsvf, t_component_v());
+
+  // quid of achromatic pixels ???
+  input_h8   = mln::data::stretch(t_int_u8(), input_h);
+  input_s8   = mln::data::stretch(t_int_u8(), input_s);
+  input_v8   = mln::data::stretch(t_int_u8(), input_v);
+
+  // IDENTIFY LOW SATURATED PIXELS
+  std::cout << "Init low saturation mask ..." << std::endl;
+  initialize(low_saturation, input_s8);
+  mln::data::fill(low_saturation, false);
+  mln::data::fill((low_saturation|(mln::pw::value(input_s8) <
+				   mln::pw::cst(100u))).rw(), true);
+
+  mln::io::pbm::save(low_saturation, "low_saturation.pbm");
+
+  std::cout << "Compute histograms ..." << std::endl;
+  histo_h    = mln::data::compute(mln::accu::meta::stat::histo1d(),
+				  input_h8|(mln::pw::value(achromatic)==false));
+
+  histo_s    = mln::data::compute(mln::accu::meta::stat::histo1d(),
+				  input_s8|(mln::pw::value(achromatic)==false));
+
+  histo_v    = mln::data::compute(mln::accu::meta::stat::histo1d(),
+				  input_v8|(mln::pw::value(achromatic)==false));
+
+
+  // Study the maps
+  hue_concentration1=mln::data::transform(input_h,
+					  mln::fun::v2v::hue_concentration(histo_h));
+  achromatism1=mln::data::transform(input_rgb8,mln::fun::v2v::achromatism());
+
+  hue_concentration2= mln::data::stretch(t_int_u8(), hue_concentration1);
+  achromatism2= mln::data::stretch(t_int_u8(), achromatism1);
+
+  mln::io::pgm::save(achromatism2,       "achromatism_map.pgm");
+  mln::io::pgm::save(hue_concentration2, "hue_concentration_map.pgm");
+  mln::io::pgm::save(input_s8,           "saturation_map.pgm");
+
+//  cnt1 = mln::data::compute(t_count(),
+//			   (input_hsvf|t_component_eq0(input_hsvf,-1)).rw());
+
+
+  // (I)   ACHROMATISM
+  std::cout << "Achromatism" << std::endl;
+  cnt1 = count_histo(histo_h);
+  cnt2 = mln::geom::nsites(input_h);
+
+  percentage = (100.0 * (cnt2 - cnt1) / cnt2);
+  result     = percentage > 99.0;
+
+  std::cout << "Nbre pixels               : " << cnt2       << std::endl;
+  std::cout << "Nbre pixels achromatiques : " << (cnt2-cnt1)<< std::endl;
+  std::cout << "Percentage                : " << percentage << std::endl;
+  std::cout << "Image achromatique        : " << result     << std::endl;
+  std::cout << std::endl;
+
+  // (II)  LOW SATURATION
+  std::cout << "Saturation" << std::endl;
+
+  cnt1 = count_histo(histo_s | mln::box1d(mln::point1d(0),mln::point1d(100)));
+
+  cnt2= mln::geom::nsites(achromatic | (mln::pw::value(achromatic)==false));
+
+  percentage = (100.0 * cnt1 / cnt2);
+  result     = percentage > 95.0;
+
+  std::cout << "Nbre pixels               : " << cnt2       << std::endl;
+  std::cout << "Nbre p faiblement saturés : " << cnt1       << std::endl;
+  std::cout << "Percentage                : " << percentage << std::endl;
+  std::cout << "Image faiblement saturé   : " << result     << std::endl;
+  std::cout << std::endl;
+
+  // (III) HIGH HUE CONCENTRATION
+  mln::debug::println(histo_h);
+  unsigned peak = peak_histo(histo_h);
+
+  cnt1 = count_histo(histo_h | mln::box1d(mln::point1d(peak-20),
+					  mln::point1d(peak+20)));
+
+  cnt2= count_histo(histo_h);
+
+  percentage = (100.0 * cnt1 / cnt2);
+  result     = percentage > 95.0;
+
+  std::cout << "Position du pic           : " << peak       << std::endl;
+  std::cout << "Nbre pixels               : " << cnt2       << std::endl;
+  std::cout << "Nbre pixels proches pic   : " << cnt1       << std::endl;
+  std::cout << "Percentage                : " << percentage << std::endl;
+  std::cout << "Image fortement teintée   : " << result     << std::endl;
+  std::cout << std::endl;
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/lep/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/lep/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/lep/lep.cc b/scribo/sandbox/green/demo/annotating/lep/lep.cc
new file mode 100644
index 0000000..981a369
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/lep/lep.cc
@@ -0,0 +1,127 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet LEP descriptor [millet.phd.2008.pdf]
+///
+/// This is an image descriptor. It works on grey level image. First,
+/// Sobel is applied on the image. Then a specific window is build to
+/// be convolved on the image. The aim of the convolution is to mark
+/// the configuration of the neighbouring for this thresholded image.
+/// Histogram of the configuration is then created and that's all.
+
+#include <iostream>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/binarization/threshold.hh>
+
+#include <mln/core/alias/w_window2d_int.hh>
+#include <mln/core/image/image2d.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/convert.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/io/pgm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/linear/ch_convolve.hh>
+#include <mln/linear/convolve.hh>
+#include <mln/linear/sobel_2d.hh>
+
+#include <mln/make/w_window2d.hh>
+
+#include <mln/value/rgb.hh>
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u8.hh>
+
+#include <mln/core/var.hh>
+
+/// \brief Main entry.
+///
+/// Load the pgm image. Threshold it. Identifie the pixel
+/// configuration with specific convolution filter. Build 1d histogram.
+
+int main()
+{
+  using namespace mln;
+
+  typedef mln::w_window2d_int                t_win2d;
+  typedef mln::value::int_u8                 t_int_u8;
+  typedef mln::value::int_u<9>               t_int_u9;
+  typedef mln::image2d<t_int_u8>             t_image2d_int_u8;
+  typedef mln::image2d<t_int_u9>             t_image2d_int_u9;
+  typedef mln::image2d<int>                  t_image2d_int;
+  typedef mln::image2d<unsigned>             t_image2d_unsigned;
+  typedef mln::image2d<float>                t_image2d_float;
+  typedef mln::image2d<double>               t_image2d_double;
+  typedef mln::image2d<bool>                 t_image2d_bool;
+  typedef mln::image1d<unsigned>             t_histo1d;
+  typedef mln::accu::meta::stat::histo1d     t_histo1d_fun;
+
+  t_image2d_int_u8                           input_int_u8;
+  t_image2d_int                              input_int;
+  t_image2d_unsigned                         input_unsigned;
+  t_image2d_float                            sobel;
+  t_image2d_bool                             thresh_bool;
+  t_image2d_int_u8                           thresh_int_u8;
+  t_image2d_float                            conf_float;
+  t_image2d_int_u9                           conf_int_u9;
+  t_histo1d                                  histo;
+
+  // IMAGE LOADING PHASE
+  std::cout << "Image loading phase ..." << std::endl;
+  mln::io::pgm::load(input_int_u8,ICDAR_50P_PGM_IMG_PATH"/mp00082c_50p.pgm");
+
+  sobel = mln::linear::sobel_2d_l1_norm(input_int_u8);
+
+  //mln::io::plot::save_image_sh(sobel, "sobel.sh");
+  thresh_bool   = mln::binarization::threshold(sobel, 100);
+  thresh_int_u8 = mln::data::convert(mln::value::int_u8(), thresh_bool);
+  //mln::io::plot::save_image_sh(thresh, "thresh.sh");
+
+  int ws[] = { 1, 2, 4,
+	       8, 256, 16,
+	       32, 64, 128 };
+
+  t_win2d win2d = mln::make::w_window2d(ws);
+  conf_float    = mln::linear::convolve(thresh_int_u8, win2d);
+  conf_int_u9   = mln::data::convert(t_int_u9(), conf_float);
+  histo         = mln::data::compute(t_histo1d_fun(), conf_int_u9);
+
+  mln::io::plot::save_image_sh(histo, "histo.sh");
+
+  // PRINTING PHASE
+  mln::debug::println(histo);
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/nb_color/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/nb_color/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/nb_color/nb_color.cc b/scribo/sandbox/green/demo/annotating/nb_color/nb_color.cc
new file mode 100644
index 0000000..acc64e9
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/nb_color/nb_color.cc
@@ -0,0 +1,143 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Compute the number of colors in an image.
+///
+/// Build histogram of colors and count the bins different from zero.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/math/sum.hh>
+#include <mln/accu/math/count.hh>
+#include <mln/accu/stat/histo3d_rgb.hh>
+#include <mln/accu/stat/mean.hh>
+#include <mln/accu/stat/variance.hh>
+
+#include <mln/algebra/vec.hh>
+
+#include <mln/arith/diff_abs.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/core/routine/initialize.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/fill.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/io/pgm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/io/ppm/save.hh>
+
+#include <mln/labeling/regional_maxima.hh>
+#include <mln/labeling/mean_values.hh>
+#include <mln/labeling/compute.hh>
+
+#include <mln/literal/colors.hh>
+
+#include <mln/morpho/opening/volume.hh>
+#include <mln/morpho/elementary/dilation.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/pw/cst.hh>
+
+#include <mln/util/array.hh>
+#include <mln/util/timer.hh>
+
+#include <mln/value/label_8.hh>
+#include <mln/value/rgb8.hh>
+#include <mln/value/rgb.hh>
+#include <mln/value/int_u.hh>
+
+/// \brief Count the colors.
+///
+/// \param[in] image the name of the image to process.
+///
+/// \return the number of colors.
+///
+/// Count the color by building histogram. Quantification is done to
+/// reduce the size of the histogram.
+///
+/// \fixme: Strange compilation warning, I don't know how to solve it!
+
+// n < 8, n is the degree of quantification
+template <unsigned n>
+unsigned count_image_color(const std::string& image)
+{
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::rgb<n>                          t_rgbn;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_rgbn>                        t_image2d_rgbn;
+  typedef mln::image3d<unsigned>                      t_histo3d;
+  typedef mln::fun::v2v::rgb8_to_rgbn<n>              t_rgb8_to_rgbn;
+  typedef mln::accu::meta::stat::histo3d_rgb          t_histo3d_fun;
+  typedef mln::accu::meta::math::count                t_count_fun;
+
+  t_image2d_rgb8                                      input_rgb8;
+  t_image2d_rgbn                                      input_rgbn;
+  t_image2d_rgbn                                      output_rgbn;
+  t_histo3d                                           histo;
+  t_histo3d                                           opened;
+
+  mln::io::ppm::load(input_rgb8, image.c_str());
+
+//  unsigned nb_pixel   = input_rgb8.ncols() * input_rgb8.nrows();
+//   unsigned min_volume = (unsigned)(nb_pixel * 0.054);
+  unsigned nb_color   = 0;
+
+  input_rgbn = mln::data::transform(input_rgb8, t_rgb8_to_rgbn());
+  histo      = mln::data::compute(t_histo3d_fun(), input_rgbn);
+  nb_color   = mln::data::compute(t_count_fun(),
+				  (histo | (mln::pw::value(histo) != 0)).rw());
+
+  return nb_color;
+}
+
+
+/// \brief Main entry.
+///
+/// Print the number of colors.
+int main()
+{
+  unsigned val=count_image_color<8>(ANNOTATING_1_PHOTO_IMG_PATH "/photo01.ppm");
+
+  std::cout << "nb color : " << val << std::endl;
+
+  return 0;
+}
+
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/project/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/project/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/project/project.cc b/scribo/sandbox/green/demo/annotating/project/project.cc
new file mode 100644
index 0000000..4cab73c
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/project/project.cc
@@ -0,0 +1,275 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet PROJECT descriptor [millet.phd.2008.pdf]
+///
+/// This is an image descriptor. It works a grey level image. First,
+/// we make subsampling of the image to the size 100x100. Then Sobel
+/// is applied. After that, we divide the image in 2 sub-images with
+/// horizontal or vertical splitting. Projection (summing along a
+/// direction) is done in a way that preserves a vector of size
+/// 100. Finally, it results 4 vector of size 100 which are concatened
+/// to build the descriptor.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/accu/image/init.hh>
+#include <mln/accu/image/take.hh>
+#include <mln/accu/image/to_result.hh>
+#include <mln/accu/stat/mean.hh>
+
+#include <mln/binarization/threshold.hh>
+
+#include <mln/core/alias/box2d.hh>
+#include <mln/core/alias/point2d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/core/routine/initialize.hh>
+#include <mln/core/image/dmorph/unproject_image.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/convert.hh>
+#include <mln/data/paste.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/fun/v2v/projection.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/io/pgm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/pbm/save.hh>
+
+#include <mln/linear/sobel_2d.hh>
+
+#include <mln/opt/at.hh>
+
+/// \brief get the sub-image name.
+///
+/// \param[in] base the common part of the name.
+/// \param[in] i    the column.
+/// \param[in] j    the line.
+///
+/// \result the complete name of the sub-image.
+///
+/// This function builds the complete name of a sub-image by making
+/// explicit its position in the array.
+const char *get_name(const char *base, const unsigned i, const unsigned j)
+{
+  std::ostringstream name;
+
+  name << base;
+  name << i;
+  name << "_";
+  name << j;
+  name << ".ppm";
+
+  return name.str().c_str();
+}
+
+
+/// \brief Project row data.
+///
+/// \param[in] img the binary image converted to u_int8.
+///
+/// \ return a vector.
+///
+/// This routine "eats" one dimension of the image by making a
+/// projection. The projection sums the pixel along a specific
+/// direction. It results a vector.
+mln::image1d<mln::value::int_u8>
+project_row(const mln::image2d<mln::value::int_u8>& img)
+{
+  typedef mln::accu::math::sum<mln::value::int_u8,mln::value::int_u8> t_sum;
+  typedef mln::fun::v2v::projection<mln::point2d,0> t_projection;
+
+  mln::image1d<t_sum> img_accu(img.ncols());
+
+  mln::accu::image::init(img_accu);
+
+  mln::accu::image::take(unproject(img_accu,
+			      img.domain(),
+			      t_projection()).rw(),
+		    img);
+
+  return mln::accu::image::to_result(img_accu);
+}
+
+
+/// \brief Project column data.
+///
+/// \param[in] img the binary image converted to u_int8.
+///
+/// \ return a vector.
+///
+/// This routine "eats" one dimension of the image by making a
+/// projection. The projection sums the pixel along a specific
+/// direction. It results a vector.
+mln::image1d<mln::value::int_u8>
+project_col(const mln::image2d<mln::value::int_u8>& img)
+{
+  typedef mln::accu::math::sum<mln::value::int_u8,mln::value::int_u8> t_sum;
+  typedef mln::fun::v2v::projection<mln::point2d,1> t_projection;
+
+  mln::image1d<t_sum> img_accu(img.nrows());
+
+  mln::accu::image::init(img_accu);
+
+  mln::accu::image::take(unproject(img_accu,
+			      img.domain(),
+			      t_projection()).rw(),
+		    img);
+
+  return mln::accu::image::to_result(img_accu);
+}
+
+
+/// \brief The image processing routine.
+///
+/// Describe the processing chain. First subsample the input image to
+/// 100x100. This is done by splitting the image and then compute the
+/// mean of the subimage. The result is a pixel of the subsample
+/// image.  Then apply Sobel and threshold. Then split in two
+/// (vertically or horizontally), it results 4 images. Finally, make
+/// the projection.
+int main()
+{
+  typedef mln::value::int_u8                      t_int_u8;
+  typedef mln::algebra::vec<3,float>              t_vec3f;
+  typedef mln::algebra::vec<3,unsigned>           t_vec3u;
+  typedef mln::image2d<float>                     t_image2d_float;
+  typedef mln::image2d<bool>                      t_image2d_bool;
+  typedef mln::image2d<t_int_u8>                  t_image2d_int_u8;
+  typedef mln::accu::meta::stat::mean             t_mean_fun;
+  typedef mln::accu::math::sum<t_int_u8,t_int_u8> t_sum;
+  typedef mln::image1d<t_int_u8>                  t_image1d_int_u8;
+
+  t_image2d_int_u8                                input_int_u8;
+  t_image2d_float                                 sobel;
+  t_image2d_bool                                  thresh_bool;
+  t_image2d_int_u8                                thresh_int_u8;
+
+  // IMAGE LOADING PHASE
+  std::cout << "Image loading phase ..." << std::endl;
+  mln::io::pgm::load(input_int_u8,ICDAR_50P_PGM_IMG_PATH"/mp00082c_50p.pgm");
+
+
+  // IMAGE SPLITTING PHASE
+  t_image2d_int_u8 subimg_int_u8(mln::box2d(mln::point2d(0,0),
+					    mln::point2d(100,100)));
+
+  mln::box2d     domain = input_int_u8.domain();
+  mln::point2d   pmin   = domain.pmin();
+  mln::point2d   pmax   = domain.pmax();
+
+  unsigned       sz_row = (pmax.row() - pmin.row())/ 100;
+  unsigned       sz_col = (pmax.col() - pmin.col())/ 100;
+
+  std::cout << domain << std::endl;
+
+  // Subsampling in 100x100
+  // FIXME Test that is it a subsampling, not a upsampling!
+  for (unsigned i = 0; i < 100; ++i)
+    for (unsigned j = 0; j < 100; ++j)
+    {
+      mln::point2d min(pmin.row()+sz_row*i,pmin.col()+sz_col*j);
+      mln::point2d max(pmin.row()+sz_row*(i+1),pmin.col()+sz_col*(j+1));
+      mln::box2d   dom(min,max);
+
+      std::cout << dom << std::endl;
+
+      // Save it
+      t_image2d_int_u8 input_part_int_u8(dom);
+
+      mln::data::paste(input_int_u8 | dom, input_part_int_u8);
+      //mln::io::pgm::save(input_part_int_u8, get_name("output",i,j));
+      float    mean     = mln::data::compute(t_mean_fun(), input_part_int_u8);
+      t_int_u8 val      = static_cast<t_int_u8>(mean);
+      mln::opt::at(subimg_int_u8, i,j) = val;
+    }
+
+  mln::io::pgm::save(subimg_int_u8, "subimg.pgm");
+
+  sobel         = mln::linear::sobel_2d_l1_norm(subimg_int_u8);
+  thresh_bool   = mln::binarization::threshold(sobel, 100);
+  thresh_int_u8 = mln::data::convert(t_int_u8(), thresh_bool);
+
+  mln::io::pbm::save(thresh_bool, "subimg.pbm");
+
+  // Define img_up, img_down, img_left, img_right
+  t_image2d_int_u8 img_up(mln::box2d(mln::point2d(0,0),
+				     mln::point2d(49,99)));
+
+  mln::data::paste(thresh_int_u8 | img_up.domain(), img_up);
+
+
+  t_image2d_int_u8 img_down(mln::box2d(mln::point2d(50,0),
+				       mln::point2d(99,99)));
+
+  mln::data::paste(thresh_int_u8 | img_down.domain(), img_down);
+
+  t_image2d_int_u8 img_left(mln::box2d(mln::point2d(0,0),
+				       mln::point2d(99,49)));
+
+  mln::data::paste(thresh_int_u8 | img_left.domain(), img_left);
+
+
+  t_image2d_int_u8 img_right(mln::box2d(mln::point2d(0,50),
+					mln::point2d(99,99)));
+
+  mln::data::paste(thresh_int_u8 | img_right.domain(), img_right);
+
+
+  // Define project_up, project_down, project_left, project_right
+  t_image1d_int_u8 project_up    = project_row(img_up);
+  t_image1d_int_u8 project_down  = project_row(img_down);
+  t_image1d_int_u8 project_left  = project_col(img_left);
+  t_image1d_int_u8 project_right = project_col(img_right);
+
+  mln::io::pgm::save(img_up, "up.pgm");
+  mln::io::pgm::save(img_down, "down.pgm");
+  mln::io::pgm::save(img_left, "left.pgm");
+  mln::io::pgm::save(img_right, "right.pgm");
+
+  // PRINTING PHASE
+
+  std::cout << std::endl << "UP" << std::endl;
+  mln::debug::println(project_up);
+
+  std::cout << std::endl << "DOWN" << std::endl;
+  mln::debug::println(project_down);
+
+  std::cout << std::endl << "LEFT" << std::endl;
+  mln::debug::println(project_left);
+
+  std::cout << std::endl << "RIGHT" << std::endl;
+  mln::debug::println(project_right);
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/rgb_64/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/rgb_64/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/rgb_64/rgb_64.cc b/scribo/sandbox/green/demo/annotating/rgb_64/rgb_64.cc
new file mode 100644
index 0000000..b49f979
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/rgb_64/rgb_64.cc
@@ -0,0 +1,80 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet RGB-64 descriptor [millet.phd.2008.pdf]
+///
+/// This is an image descriptor. It works by making 2 bits
+/// quantification on each channel. It result a processing in RGB-64
+/// space. Then we build the color histogram.
+
+#include <iostream>
+
+#include <mln/accu/stat/histo3d_rgb.hh>
+
+#include <mln/core/image/image2d.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/io/ppm/load.hh>
+
+#include <mln/value/rgb.hh>
+#include <mln/value/rgb8.hh>
+
+/// \brief Main entry.
+///
+/// Loading, Quantifiying in two bits each channel, then building
+/// color histogram.
+int main()
+{
+  typedef mln::fun::v2v::rgb8_to_rgbn<2>     t_rgb8_to_rgb2;
+  typedef mln::value::rgb8                   t_rgb8;
+  typedef mln::value::rgb<2>                 t_rgb2;
+  typedef mln::image2d<t_rgb8>               t_image2d_rgb8;
+  typedef mln::image2d<t_rgb2>               t_image2d_rgb2;
+  typedef mln::image3d<unsigned>             t_histo3d;
+  typedef mln::accu::meta::stat::histo3d_rgb t_histo3d_fun;
+
+  t_image2d_rgb8                             input_rgb8;
+  t_image2d_rgb2                             input_rgb2;
+  t_histo3d                                  histo;
+
+  // IMAGE LOADING PHASE
+  std::cout << "Image loading phase ..." << std::endl;
+  mln::io::ppm::load(input_rgb8, ICDAR_50P_PPM_IMG_PATH"/mp00082c_50p.ppm");
+  input_rgb2 = mln::data::transform(input_rgb8, t_rgb8_to_rgb2());
+  histo      = mln::data::compute(t_histo3d_fun(), input_rgb2);
+
+  // PRINTING PHASE
+  mln::debug::println(histo);
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/rgb_64_9/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/rgb_64_9/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/rgb_64_9/rgb_64_9.cc b/scribo/sandbox/green/demo/annotating/rgb_64_9/rgb_64_9.cc
new file mode 100644
index 0000000..355cbfd
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/rgb_64_9/rgb_64_9.cc
@@ -0,0 +1,132 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet RGB-64 descriptor [millet.phd.2008.pdf]
+///
+/// This is an image descriptor. It works by making 2 bits
+/// quantification on each channel. It result a processing in RGB-64
+/// space. Then we build the color histogram.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/accu/stat/histo3d_rgb.hh>
+
+#include <mln/core/alias/box2d.hh>
+#include <mln/core/alias/point2d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/core/routine/initialize.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/paste.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/ppm/save.hh>
+
+#include <mln/value/rgb.hh>
+#include <mln/value/rgb8.hh>
+
+/// \brief Get the sub image name.
+///
+/// \return the name of the ith/jth sub image of the array.
+const char *get_name(const char *base, const unsigned i, const unsigned j)
+{
+  std::ostringstream name;
+
+  name << base;
+  name << i;
+  name << "_";
+  name << j;
+  name << ".ppm";
+
+  return name.str().c_str();
+}
+
+/// \brief Same code as rgb-64 but divide the wall image in nine.
+///
+/// Adding a splitting phase for image rgb-64 code reference.
+int main()
+{
+  typedef mln::fun::v2v::rgb8_to_rgbn<2>     t_rgb8_to_rgb2;
+  typedef mln::value::rgb8                   t_rgb8;
+  typedef mln::value::rgb<2>                 t_rgb2;
+  typedef mln::image2d<t_rgb8>               t_image2d_rgb8;
+  typedef mln::image2d<t_rgb2>               t_image2d_rgb2;
+  typedef mln::image3d<unsigned>             t_histo3d;
+  typedef mln::accu::meta::stat::histo3d_rgb t_histo3d_fun;
+
+  t_image2d_rgb8                             input_rgb8;
+  t_image2d_rgb2                             input_rgb2;
+  t_histo3d                                  histo;
+
+  // IMAGE LOADING PHASE
+  std::cout << "Image loading phase ..." << std::endl;
+  mln::io::ppm::load(input_rgb8, ICDAR_50P_PPM_IMG_PATH"/mp00082c_50p.ppm");
+
+  input_rgb2 = mln::data::transform(input_rgb8, t_rgb8_to_rgb2());
+
+  // IMAGE SPLITTING PHASE
+  mln::box2d     domain = input_rgb2.domain();
+  mln::point2d   pmin   = domain.pmin();
+  mln::point2d   pmax   = domain.pmax();
+
+  unsigned       sz_row = (pmax.row() - pmin.row())/ 3;
+  unsigned       sz_col = (pmax.col() - pmin.col())/ 3;
+
+  std::cout << domain << std::endl;
+
+  // Divide the domain in nine sub-domains.
+  for (unsigned i = 0; i < 3; ++i)
+    for (unsigned j = 0; j < 3; ++j)
+    {
+      mln::point2d min(pmin.row()+sz_row*i,pmin.col()+sz_col*j);
+      mln::point2d max(pmin.row()+sz_row*(i+1),pmin.col()+sz_col*(j+1));
+      mln::box2d   dom(min,max);
+
+      std::cout << dom << std::endl;
+
+      // Save it
+      t_image2d_rgb2 input_1o9_rgb2(dom);
+
+      mln::data::paste(input_rgb2 | dom, input_1o9_rgb2);
+      mln::io::ppm::save(input_1o9_rgb2, get_name("output",i,j));
+
+      histo      = mln::data::compute(t_histo3d_fun(), input_1o9_rgb2);
+
+      // PRINTING PHASE
+      mln::debug::println(histo);
+    }
+
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/stddev_color/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/stddev_color/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/stddev_color/stddev_color.cc b/scribo/sandbox/green/demo/annotating/stddev_color/stddev_color.cc
new file mode 100644
index 0000000..549834f
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/stddev_color/stddev_color.cc
@@ -0,0 +1,191 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet clipart detection [millet.phd.2008.pdf]
+///
+/// The aim of this descriptor is to recognize clipart. To do this, we
+/// assume that clipart have their histogram concentrated around their
+/// mode. This is particularly true if the clipart is design by hand,
+/// because a very small number of grey tones or colors are used to
+/// draw it. But sometimes, computer assists their creation and we can
+/// find some continuous set of tones and this artefact create noise
+/// for the detection technique describe bellow.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/max_site.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/fill.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb8_to_int_u8.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/math/sqr.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u.hh>
+
+
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] image the input image to analyze.
+///
+/// \return the deviation.
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it).
+unsigned stddev_color(const std::string& image)
+{
+  typedef mln::point1d                                t_point1d;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+  typedef mln::image1d<unsigned>                      t_histo1d;
+  typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+  typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+  typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+  t_image2d_rgb8                                      input_rgb8;
+  t_image2d_int_u8                                    input_int_u8;
+  t_histo1d                                           histo;
+  t_point1d                                           max_site;
+
+  mln::io::ppm::load(input_rgb8, image.c_str());
+  input_int_u8 = mln::data::transform(input_rgb8, t_rgb8_to_int_u8());
+  histo        = mln::data::compute(t_histo1d_fun(), input_int_u8);
+
+  mln::io::pgm::save(input_int_u8, "tmp.pgm");
+  mln::io::plot::save_image_sh(histo, "histo.sh");
+  mln::debug::println(histo);
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter_(t_histo1d) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  // Compute the specific stddev
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float stddev     = 0.0;
+
+  if (250 > p_max)
+    for (short i = p_max+1; i < p_max+6; ++i)
+      stddev_up += r(p_max, mln::opt::at(histo,p_max),
+		     i, mln::opt::at(histo,i));
+
+  if (5 < p_max)
+    for (short i = p_max-1; i > p_max-6; --i)
+      stddev_low += r(p_max, mln::opt::at(histo,p_max),
+		      i, mln::opt::at(histo,i));
+
+  stddev = (250 < p_max)? stddev_low : (5 > p_max)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  std::cout << "max_site    : " << p_max << std::endl;
+  std::cout << "h(max_site) : " << v_max << std::endl;
+  std::cout << "stddev_up   : " << stddev_up << std::endl;
+  std::cout << "stddev_low  : " << stddev_low << std::endl;
+  std::cout << "stddev      : " << stddev << std::endl;
+
+  return 0;
+}
+
+
+/// \brief Main entry.
+///
+/// Front end for image processing.
+int main()
+{
+//   unsigned val = stdev_color(ANNOTATING_1_PHOTO_IMG_PATH "/photo01.ppm");
+  unsigned val = stddev_color(ANNOTATING_1_LOGO_IMG_PATH "/logo06.ppm");
+
+//   std::cout << "nb color : " << val << std::endl;
+
+  return 0;
+}
+
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/demo/annotating/stddev_color_16/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/demo/annotating/stddev_color_16/Makefile.am
diff --git a/scribo/sandbox/green/demo/annotating/stddev_color_16/stddev_color_16.cc b/scribo/sandbox/green/demo/annotating/stddev_color_16/stddev_color_16.cc
new file mode 100644
index 0000000..98d94fd
--- /dev/null
+++ b/scribo/sandbox/green/demo/annotating/stddev_color_16/stddev_color_16.cc
@@ -0,0 +1,261 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet clipart detection [millet.phd.2008.pdf]
+///
+/// The aim of this descriptor is to recognize clipart. To do this, we
+/// assume that clipart have their histogram concentrated around their
+/// mode. This is particularly true if the clipart is design by hand,
+/// because a very small number of grey tones or colors are used to
+/// draw it. But sometimes, computer assists their creation and we can
+/// find some continuous set of tones and this artefact create noise
+/// for the detection technique describe bellow. When photographies
+/// has some large uniform border, the detection can fail. To improve
+/// the method, Millet decide to subdivise the image in 16 sub images
+/// on which it applies the test.
+#include <iostream>
+#include <sstream>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/max_site.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/fill.hh>
+#include <mln/data/transform.hh>
+#include <mln/data/paste.hh>
+
+#include <mln/fun/v2v/rgb8_to_int_u8.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/math/sqr.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u.hh>
+
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] input_int_u8 the 8 bits input image to analyze.
+/// \param[in] name_histo   the name of the output histogram.
+/// \param[in] name_image   the name of the ouput sub image.
+///
+/// \return the deviation, but at this time nothing..
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it).
+unsigned stddev_color(mln::image2d<mln::value::int_u8> input_int_u8,
+		      const char *name_histo,
+		      const char *name_image)
+{
+  typedef mln::point1d                                t_point1d;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+  typedef mln::image1d<unsigned>                      t_histo1d;
+  typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+  typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+  typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+  t_histo1d                                           histo;
+
+  std::cout << "histo : " << name_histo << std::endl;
+  std::cout << "image : " << name_image << std::endl;
+
+  histo        = mln::data::compute(t_histo1d_fun(), input_int_u8);
+
+  mln::io::pgm::save(input_int_u8, name_image);
+  mln::io::plot::save_image_sh(histo, name_histo);
+  mln::debug::println(histo);
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter_(t_histo1d) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  // Compute the specific stddev
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float stddev     = 0.0;
+
+  if (250 > p_max)
+    for (short i = p_max+1; i < p_max+6; ++i)
+      stddev_up += r(p_max, mln::opt::at(histo,p_max),
+		     i, mln::opt::at(histo,i));
+
+  if (5 < p_max)
+    for (short i = p_max-1; i > p_max-6; --i)
+      stddev_low += r(p_max, mln::opt::at(histo,p_max),
+		      i, mln::opt::at(histo,i));
+
+  stddev = (250 < p_max)? stddev_low : (5 > p_max)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  std::cout << "max_site    : " << p_max << std::endl;
+  std::cout << "h(max_site) : " << v_max << std::endl;
+  std::cout << "stddev_up   : " << stddev_up << std::endl;
+  std::cout << "stddev_low  : " << stddev_low << std::endl;
+  std::cout << "stddev      : " << stddev << std::endl;
+
+  return 0;
+}
+
+
+/// \brief Divide the image in 16 sub images.
+///
+/// \param[in] image the input image.
+///
+/// \result nothing.
+///
+/// Divive the input image in 16 by uniform and geometrical
+/// method. When a sub image is ready, call the stddev routine to show
+/// stats on it.
+unsigned stddev_color_16(const std::string& image)
+{
+  typedef mln::point1d                                t_point1d;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+  typedef mln::image1d<unsigned>                      t_histo1d;
+  typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+  typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+  typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+  t_image2d_rgb8                                      input_rgb8;
+  t_image2d_int_u8                                    input_int_u8;
+
+  mln::io::ppm::load(input_rgb8, image.c_str());
+  input_int_u8 = mln::data::transform(input_rgb8, t_rgb8_to_int_u8());
+
+  // IMAGE SPLITTING PHASE
+  mln::box2d     domain = input_int_u8.domain();
+  mln::point2d   pmin   = domain.pmin();
+  mln::point2d   pmax   = domain.pmax();
+
+  unsigned       sz_row = (pmax.row() - pmin.row())/ 4;
+  unsigned       sz_col = (pmax.col() - pmin.col())/ 4;
+
+  std::cout << domain << std::endl;
+
+  // Divide the domain in nine sub-domains.
+  for (unsigned i = 0; i < 4; ++i)
+    for (unsigned j = 0; j < 4; ++j)
+    {
+      mln::point2d min(pmin.row()+sz_row*i,pmin.col()+sz_col*j);
+      mln::point2d max(pmin.row()+sz_row*(i+1),pmin.col()+sz_col*(j+1));
+      mln::box2d   dom(min,max);
+
+      std::cout << dom << std::endl;
+
+      // Save it
+      t_image2d_int_u8   input_1o16_int_u8(dom);
+      std::ostringstream name_histo("");
+      std::ostringstream name_image("");
+
+      name_histo << "histo" << i << "_" << j << ".sh";
+      name_image << "image" << i << "_" << j << ".ppm";
+
+      mln::data::paste(input_int_u8 | dom, input_1o16_int_u8);
+
+      stddev_color(input_1o16_int_u8,
+		   name_histo.str().c_str(),
+		   name_image.str().c_str());
+    }
+
+  return 0;
+}
+
+
+/// \brief Main entry.
+///
+/// Just a front end for image processing routine.
+int main()
+{
+//   unsigned val = stddev_color_16(ANNOTATING_1_PHOTO_IMG_PATH "/photo01.ppm");
+  unsigned val = stddev_color_16(ANNOTATING_1_LOGO_IMG_PATH "/logo06.ppm");
+
+//   std::cout << "nb color : " << val << std::endl;
+
+  return 0;
+}
+
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/achromastism/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/achromastism/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/achromastism/achromastism.cc b/scribo/sandbox/green/exp/annotating/achromastism/achromastism.cc
new file mode 100644
index 0000000..3486b20
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/achromastism/achromastism.cc
@@ -0,0 +1,179 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+
+/// \file
+///
+/// \brief Implement the Millet achromatism operator [millet.phd.2008.pdf]
+///
+/// An image is said to be achromatic when have the RGB channel which
+/// are quite identicals.
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/fun/v2v/rgb_to_achromatism_map.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/rgb8.hh>
+
+
+/// \brief Sum all the bins of the histogram.
+///
+/// \param[in] img the histogram based on image.
+///
+/// \return the sum of the overall bins.
+///
+/// Sum evry bins and return the result.
+template <typename I>
+unsigned count_histo(const mln::Image<I>& img_)
+{
+  const   I& img = exact(img_);
+
+  mln_precondition(img.is_valid());
+
+  unsigned     result = 0;
+
+  mln_piter(I) p(img.domain());
+
+  for_all(p)
+    result += img(p);
+
+  return result;
+}
+
+/// \brief Decide if an image is achromatic or not [Millet].
+///
+/// \param[in] input the input image.
+/// \param[in] output the histogram of the achromatic map.
+/// \param[in] threshold  the distance threshold used for equality.
+///
+/// This is an improving of the Millet test. The original test
+/// compares rgb values to each other and look at differences greater
+/// than the threshold.  If the number of pixel that pass the test are
+/// greater than 99.0, then the image is declared achromatic. In fact,
+/// there is few variations between the three channels, so we can say
+/// that it is like a grey image. We can with no too distortions
+/// replace the color image by the grey one. The improving is in first
+/// creating a map of the difference. As we can't keep the free
+/// differences between channels, we look at reducing the test and we
+/// find an equivalent one based on the difference between minima
+/// channel value and the maxima channel value. After the map is
+/// ready, we make binarization with the threshold. Then we compute
+/// the histogram 1d for every pixels of the map that are greater the
+/// threshold. Then, we count pixels in the histogram and traduce the
+/// count in percentage to compare to the second threshold. Details
+/// are saved in files and printed in the screen.
+float achromatism_test(const std::string input,
+		       const std::string output,
+		       const unsigned threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_achromatism_map<8>   t_rgb_to_achromatism_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  unsigned                         cnt1;
+  unsigned                         cnt2;
+  float                            prop;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map    = mln::data::transform(input_rgb8, t_rgb_to_achromatism_map());
+  histo  = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  cnt1   = count_histo(histo | mln::box1d(mln::point1d(0),
+					  mln::point1d(threshold)));
+  cnt2   = mln::geom::nsites(input_rgb8);
+  prop   = ((100.0 * cnt1) / cnt2);
+
+  mln::io::plot::save_image_sh(histo, output.c_str());
+
+  return prop;
+}
+
+
+/// \brief The main entry.
+///
+/// Deal with boost library for walking over image database
+/// directories. Call the image processing routine and compute some
+/// stats on the result.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ICDAR_20P_PPM_IMG_PATH)};
+
+  for (int i = 0; i < 1; ++i)
+  {
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float             prop = 0.0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	// concatenation de chaine
+	t_path directory(ANNOTATING_RET_PATH);
+	t_path leaf = dir_iter->path().leaf();
+	t_path output = change_extension(directory / leaf, ".sh");
+
+	prop = achromatism_test(dir_iter->path().string(),
+				output.string(),
+				11);
+
+	std::cout << output << " : " << prop << std::endl;
+	std::cerr << output << " : " << prop << std::endl;
+      }
+    }
+  }
+
+  return 0;
+}
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-color.txt b/scribo/sandbox/green/exp/annotating/achromastism/text-color.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-color.txt
copy to scribo/sandbox/green/exp/annotating/achromastism/text-color.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-img.txt b/scribo/sandbox/green/exp/annotating/achromastism/text-img.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-img.txt
copy to scribo/sandbox/green/exp/annotating/achromastism/text-img.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-only.txt b/scribo/sandbox/green/exp/annotating/achromastism/text-only.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-only.txt
copy to scribo/sandbox/green/exp/annotating/achromastism/text-only.txt
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/bench/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/bench/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/bench/bench.cc b/scribo/sandbox/green/exp/annotating/bench/bench.cc
new file mode 100644
index 0000000..102a896
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/bench/bench.cc
@@ -0,0 +1,1450 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// This file is the final work to differentiate between the two image
+/// databases AFP and ICDAR. Several tests are used to show
+/// improvement of detection. The jonathan's tests are put together to
+/// compare them to the others (in fact, to the low saturation one).
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/algebra/vec.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/mean.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/arith/minus.hh>
+#include <mln/arith/times.hh>
+#include <mln/arith/diff_abs.hh>
+#include <mln/arith/div.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/core/alias/point1d.hh>
+#include <mln/core/alias/box1d.hh>
+
+#include <mln/data/transform.hh>
+#include <mln/data/compute.hh>
+#include <mln/data/convert.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/fill.hh>
+
+#include <mln/fun/v2v/component.hh>
+#include <mln/fun/v2v/rgb_to_hue_map.hh>
+#include <mln/fun/v2v/rgb_to_saturation_map.hh>
+#include <mln/fun/v2v/rgb_to_value_map.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/literal/zero.hh>
+
+#include <mln/math/ceil.hh>
+#include <mln/math/floor.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/trait/value_.hh>
+
+#include <mln/value/rgb8.hh>
+
+
+#include <mln/value/int_u8.hh>
+
+/// Histogram part.
+///
+/// We regroup here the routines that work on histogram, count_histo,
+/// sum_frequency_histo, peak_histo, count_null_frequency_histo,
+/// cmp_equi_frequency_histo and others (variance
+/// operators). count_histo and sum_frequency_histo count the overall
+/// frequency in the domain.  peak_histo find the peak of the
+/// histogram.  count_null_frequency_histo compute the number of non
+/// grey levels.  cmp_equi_frequency_histo compare a histogram with
+/// the one with the same frequency everywhere.
+/// \{
+template <typename I>
+mln_value(I) count_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) result = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    result += histo(p);
+
+  return result;
+}
+
+
+template <typename I>
+mln_value(I) sum_frequency_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    sum += histo(p);
+
+  return sum;
+}
+
+
+template <typename I>
+mln_coord(mln_site_(I)) peak_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the peak of the histogram
+  mln_value(I)            v_max = mln::opt::at(histo, mln::literal::zero);
+  mln_coord(mln_site_(I)) p_max = mln::literal::zero;
+  mln_piter(I)            p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  return p_max;
+}
+
+template <typename I>
+mln_value(I) count_null_frequency_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) count = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    if (0 == histo(p))
+      count++;
+
+  return count;
+}
+
+template <typename I>
+float cmp_equi_frequency_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  float sum   = 0;
+  float var   = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum ++;
+    var += mln::math::sqr(histo(p) - (1/256.0));
+  }
+
+  var = var / sum;
+
+  return var;
+}
+
+template <typename I>
+mln_value(I) cnt_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum += histo(p);
+  }
+
+  return sum;
+}
+
+template <typename I>
+mln_value(I) sum_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    sum += pos*histo(p);
+  }
+
+  return sum;
+}
+
+template <typename I>
+mln_value(I) avg_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    cnt += histo(p);
+    sum += pos*histo(p);
+  }
+
+  return (0 == cnt)? 0 : sum/cnt;
+}
+
+template <typename I>
+mln_value(I) var3_histo(const mln::Image<I>& histo_, float mean)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    cnt += histo(p);
+    sum += (mln::math::sqr(p.ind()-mean)*histo(p));
+  }
+
+  return (0 == cnt)? 0 : sum/cnt;
+}
+
+template <typename I>
+mln_value(I) var2_histo(const mln::Image<I>& histo_, float mean)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) sqr = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_value(I) dlt = mln::literal::zero;
+  mln_value(I) mxt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    cnt += (histo(p));
+    sum += (histo(p)*pos);
+    mxt += (histo(p)*pos*mean);
+    sqr += (histo(p)*mln::math::sqr(pos));
+    dlt += (histo(p)*mln::math::sqr(pos - mean));
+
+    std::cout << "p          = " << pos                       << std::endl;
+    std::cout << "p²         = " << mln::math::sqr(pos)       << std::endl;
+    std::cout << "p*mean     = " << (pos*mean)                << std::endl;
+    std::cout << "p-mean     = " << (pos-mean)                << std::endl;
+    std::cout << "(p-mean)²  = " << mln::math::sqr(pos-mean)  << std::endl;
+    std::cout << "histo(p)   = " << histo(p)                  << std::endl;
+    std::cout << "histo(p)*p = " << (pos*histo(p))            << std::endl;
+    std::cout << "histo(p)*p²= " << (mln::math::sqr(pos)*histo(p))
+	      << std::endl;
+    std::cout << "cnt        = " << cnt      << std::endl;
+    std::cout << "sum        = " << sum      << std::endl;
+    std::cout << "sqr        = " << sqr      << std::endl;
+    std::cout << "dlt        = " << dlt      << std::endl;
+    std::cout << "mxt        = " << mxt      << std::endl;
+    std::cout << std::endl;
+  }
+
+  std::cout << "sqr/cnt      = " << (sqr/cnt)               << std::endl;
+  std::cout << "sum/cnt      = " << (sum/cnt)               << std::endl;
+  std::cout << "(sum/cnt)²   = " << mln::math::sqr(sum/cnt) << std::endl;
+  std::cout << "dlt/cnt      = " << dlt/cnt                 << std::endl;
+  std::cout << "mxt/cnt      = " << mxt/cnt                 << std::endl;
+  std::cout << std::endl;
+
+  std::cout << "sqr                     = "
+	    << (sqr)                                          << std::endl;
+  std::cout << "dlt                     = "
+	    << (dlt)                                          << std::endl;
+  std::cout << "cnt*avg²                = "
+	    << (mln::math::sqr(sum/cnt)*cnt)                  << std::endl;
+  std::cout << "2*mxt                   = "
+	    << (2*mxt)                                        << std::endl;
+  std::cout << "sqr - cnt*avg²          = "
+	    << (sqr/cnt - mln::math::sqr(sum/cnt))            << std::endl;
+  std::cout << "(sqr -2*mxt + cnt*avg²) = "
+	    <<  ((sqr - 2*mxt + mln::math::sqr(sum/cnt))/cnt) << std::endl;
+  std::cout << std::endl;
+  return (0 == cnt)? 0 : sqr/cnt - mln::math::sqr(sum/cnt);
+}
+
+template <typename I>
+mln_value(I) var_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) sqr = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    cnt += (histo(p));
+    sum += (histo(p)*pos);
+    sqr += (histo(p)*mln::math::sqr(pos));
+  }
+
+  return (0 == cnt)? 0 : sqr/cnt - mln::math::sqr(sum/cnt);
+}
+
+template <typename I>
+mln_value(I) sqr_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    sum += (mln::math::sqr(p.ind())*histo(p));
+
+  return sum;
+}
+/// \}
+
+
+/// \brief Millet Hue detector.
+///
+/// \param[in] histo the histogram image on which applying the detector.
+/// \param[in] threshold a way to adapt the test to the population.
+///
+/// \return the proportion of population that verify the hue detector.
+///
+/// This test is used for discrimination between black and white pictures and
+/// color ones. Some colored Black and white pictures have their energy near
+/// the peak.
+float hue1_descriptor(mln::image1d<unsigned> histo, const short threshold)
+{
+  float                            cnt1;
+  float                            cnt2;
+  float                            prop;
+  short                            peak;
+  mln::point1d                     inf;
+  mln::point1d                     sup;
+
+  peak = peak_histo(histo);
+  inf  = mln::point1d(mln::math::max(0,   peak-threshold));
+  sup  = mln::point1d(mln::math::min(255, peak+threshold));
+  cnt1 = count_histo(histo|mln::box1d(inf,sup));
+  cnt2 = count_histo(histo);
+  prop = ((255.0 * cnt1) / cnt2);
+
+  return prop;
+}
+
+
+/// \brief Saturation detector.
+///
+/// \param[in] histo the histogram image on which applying the detector.
+/// \param[in] threshold a way to adapt the test to the population.
+///
+/// \return the proportion of population that verify the hue detector.
+///
+/// This test is used for discrimination between black and white pictures and
+/// color ones. Black and white pictures have their energy in the low saturation
+/// band.
+float sat1_descriptor(mln::image1d<unsigned> histo, const short threshold)
+{
+  float                            cnt1;
+  float                            cnt2;
+  float                            result;
+
+  cnt1        = count_histo(histo | mln::box1d(mln::point1d(0),
+					       mln::point1d(threshold)));
+  cnt2        = count_histo(histo);
+  result      = ((255.0 * cnt1) / cnt2);
+
+  return result;
+}
+
+
+/// \brief Counting grey levels descriptor.
+///
+/// \param[in] histo the histogram image on which applying the detector.
+///
+/// \return the number of grey levels.
+///
+/// This test aims at compute the number of grey levels. Photographies tends to
+/// use all the levels or many of them.
+float lvl0_descriptor(mln::image1d<unsigned> histo)
+{
+  float                            result;
+
+  // FIXME 255
+  result      = 255-count_null_frequency_histo(histo);
+
+  return result;
+}
+
+
+/// \brief Density hue detector.
+///
+/// \param[in] histo the histogram image on which applying the detector.
+///
+/// \return the proportion of population that verify the hue detector.
+///
+/// This test works on density histogram and compare to the
+/// equi-frequency histogram. If the normalized histogram show a peak,
+/// it will differ from the reference density.
+float hue0_descriptor(mln::image1d<unsigned> histo)
+{
+  mln::image1d<float>              histo_float;
+  float                            sum;
+  float                            result;
+
+  sum         = sum_frequency_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+  result      = cmp_equi_frequency_histo(histo_float);
+
+  return result*255;
+}
+
+
+/// \brief Density saturation detector.
+///
+/// \param[in] histo the histogram image on which applying the detector.
+///
+/// \return the proportion of population that verify the hue detector.
+///
+/// This test works on density histogram and compare to the
+/// equi-frequency histogram. If the normalized histogram show a peak,
+/// it will differ from the reference density.
+float sat0_descriptor(mln::image1d<unsigned> histo)
+{
+  mln::image1d<float>              histo_float;
+  float                            sum;
+  float                            result;
+
+  sum         = sum_frequency_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+  result      = cmp_equi_frequency_histo(histo_float);
+
+  return result*255;
+}
+
+
+/// \brief Density value detector.
+///
+/// \param[in] histo the histogram image on which applying the detector.
+///
+/// \return the proportion of population that verify the hue detector.
+///
+/// This test works on density histogram and compare to the
+/// equi-frequency histogram. If the normalized histogram show a peak,
+/// it will differ from the reference density.
+float val0_descriptor(mln::image1d<unsigned> histo)
+{
+  mln::image1d<float>              histo_float;
+  float                            sum;
+  float                            result;
+
+  sum         = sum_frequency_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+  result      = cmp_equi_frequency_histo(histo_float);
+
+  return result*255;
+}
+
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+/// \brief The stddev3 is an internal stuff.
+///
+/// \param[in] histo_ the image which represents the histogram.
+/// \param[in] peak   the position of the histogram peak.
+///
+/// \return simple computing of deviation.
+///
+/// This is an internal stuff. It splits the computing for easy
+/// reusing practice. Sum the R contribution.
+template <typename I>
+float stddev3(const mln::Image<I>& histo_, unsigned peak)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Compute stddev
+
+  float stddev = 0.0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    stddev  += r((short)peak, mln::opt::at(histo,peak), p.ind(), histo(p));
+  }
+
+  return stddev;
+}
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] image the input image to analyze.
+/// \param[in] peak the peak of the histogram.
+/// \param[in] limit the threshold to compute the contribution.
+///
+/// \return the deviation.
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it). The test is generalized by
+/// making constants as parameters.
+template <typename I>
+float stddev2(const mln::Image<I>& histo_, unsigned peak, unsigned limit)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float ret        = 0.0;
+
+  // A transformer avec des iterators
+
+  if (250 > peak)
+    stddev_up  = stddev3(histo |mln::box1d(mln::point1d(peak+1),
+					   mln::point1d(peak+limit)), peak);
+
+  if (5 < peak)
+    stddev_low = stddev3(histo |mln::box1d(mln::point1d(peak-limit),
+					   mln::point1d(peak-1)), peak);
+
+  ret = (250 < peak)? stddev_low : (5 > peak)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  return ret;
+}
+
+
+/// \brief Millet value descriptor (cf. Millet.phd.2008)
+///
+/// \param[in] histo the histogram image on which applying the detector.
+/// \param[in] threshold the limit where to compute the contribution.
+///
+/// \return the proportion of population that verify the hue detector.
+///
+/// This test aims at compute some deviation on the peak of the histogram of
+/// the image. Large deviations mean lots of graduation in colors (such as
+/// photos) and small ones mean something like cartoon.
+float val1_descriptor(mln::image1d<unsigned> histo, const short threshold)
+{
+  typedef mln::fun::v2v::rgb_to_value_map<8>   t_rgb_to_value_map;
+
+  float                            result;
+  short                            peak;
+
+  peak        = peak_histo(histo);
+  result      = stddev2(histo, peak, threshold);
+
+  return result;
+}
+
+
+/// \brief Error detector (jonathan idea).
+///
+/// \param[in] r_img_map the original red channel.
+/// \param[in] g_img_map the original green channel.
+/// \param[in] b_img_map the original blue channel.
+/// \param[in] r_rdc_map the reduced (in color) red channel.
+/// \param[in] g_rdc_map the reduced (in color) green channel.
+/// \param[in] b_rdc_map the reduced (in color) blue channel.
+///
+/// \return the PNSNR (cf compression p278 Handbook Color).
+///
+/// \fixme the actual PNSNR is unbound, we need to fix its max to
+/// 255. Two images which are the same produces an infinite PNSNR.
+float err_descriptor(mln::image2d<mln::value::int_u8> r_img_map,
+		     mln::image2d<mln::value::int_u8> g_img_map,
+		     mln::image2d<mln::value::int_u8> b_img_map,
+		     mln::image2d<mln::value::int_u8> r_rdc_map,
+		     mln::image2d<mln::value::int_u8> g_rdc_map,
+		     mln::image2d<mln::value::int_u8> b_rdc_map)
+
+
+{
+  typedef mln::accu::meta::stat::mean          t_mean;
+  typedef mln::image2d<mln::value::int_u8>     t_map;
+  typedef mln_trait_op_minus_(t_map,t_map)     t_minus;
+  typedef mln_trait_op_times_(t_minus,t_minus) t_times;
+
+
+  t_minus                          minus_red;
+  t_minus                          minus_green;
+  t_minus                          minus_blue;
+
+  t_times                          times_red;
+  t_times                          times_green;
+  t_times                          times_blue;
+
+  float                            error_red;
+  float                            error_green;
+  float                            error_blue;
+
+  float                            error;
+
+  minus_red      = (r_img_map - r_rdc_map);
+  times_red      = minus_red * minus_red;
+
+  minus_green    = (g_img_map - g_rdc_map);
+  times_green    = minus_green * minus_green;
+
+  minus_blue     = (b_img_map - b_rdc_map);
+  times_blue     = minus_blue * minus_blue;
+
+  error_red      = mln::data::compute(t_mean(), times_red);
+  error_green    = mln::data::compute(t_mean(), times_green);
+  error_blue     = mln::data::compute(t_mean(), times_blue);
+
+  error          = (error_red + error_green + error_blue)/3.0;
+  error          = mln::math::sqrt(error);
+  error          = 20 * log(255/error);
+
+// FIXME:
+// SAME IMAGE PRODUCE PNSNR GOING THROW THE INFINITY.
+// DIFFERENT IMAGE PRODUCE PNSNR GOING NEAR ZERO.
+// WE SHOULD KEEP THE PNSNR BELOW 255 FOR COMPARAISON.
+
+  return error;
+}
+
+/// Discriminant operators.
+///
+/// We have some operators that compute the threshold which separate
+/// two sub-populations in a histogram.
+/// /{
+
+/// \brief Compute discrimination threshold.
+/// \param[in] avg1 the mean of the population 1.
+/// \param[in] var1 the variance of the population 1.
+/// \param[in] avg2 the mean of the population 2.
+/// \param[in] var2 the variance of the population 2.
+///
+/// \return the threshold to discriminate the two populations.
+///
+/// Linear discriminant analysis in 1d is done. When two population
+/// have the same variance, the threshold is at (m1+m2)/2. When threre
+/// are different variances, we propose the threshold at the position
+/// (m1*sqrt(v1)+m2*sqrt(v2))/(sqrt(v1)+sqrt(v2)).
+float threshold_histo(float avg1, float var1, float avg2, float var2)
+{
+  float sigma1    = mln::math::sqrt(var1);
+  float sigma2    = mln::math::sqrt(var2);
+  float threshold = (avg1*sigma1+avg2*sigma2)/(sigma1+sigma2);
+
+  return threshold;
+}
+
+/// \brief Compute discrimination threshold.
+/// \param[in] avg1 the mean of the population 1.
+/// \param[in] var1 the variance of the population 1.
+/// \param[in] avg2 the mean of the population 2.
+/// \param[in] var2 the variance of the population 2.
+///
+/// \return the threshold to discriminate the two populations.
+///
+/// Linear discriminant analysis in 1d is done. When two population
+/// have the same variance, the threshold is at (m1+m2)/2. When threre
+/// are different variances, we propose the threshold at the position
+/// (m1*var1+m2*var2)/(sqrt(v1)+sqrt(v2)).
+
+float threshold3_histo(float avg1, float var1, float avg2, float var2)
+{
+  float threshold = (avg1*var1+avg2*var2)/(var1+var2);
+
+  return threshold;
+}
+
+
+/// \brief Compute discrimination threshold.
+/// \param[in] avg1 the mean of the population 1.
+/// \param[in] var1 the variance of the population 1.
+/// \param[in] avg2 the mean of the population 2.
+/// \param[in] var2 the variance of the population 2.
+///
+/// \return the threshold to discriminate the two populations.
+///
+/// Gaussian discriminant analysis in 1d is done. Compute the
+/// discrimanation and solve the parabolic equation.
+float threshold2_histo(float avg1, float var1, float avg2, float var2)
+{
+  float a = var2 - var1;
+  float b = -2 * (avg1 * var2 - avg2 * var1);
+  float c = var2 * mln::math::sqr(avg1) - var1 * mln::math::sqr(avg2);
+  float d = mln::math::sqr(b) - 4 * a * c;
+
+  if (d < 0)
+    std::cout << "delta negatif" << std::endl;
+
+  float x1 = (-b+mln::math::sqrt(d))/(2*a);
+  float x2 = (-b-mln::math::sqrt(d))/(2*a);
+
+  std::cout << "a  = " << a << std::endl;
+  std::cout << "b  = " << b << std::endl;
+  std::cout << "c  = " << c << std::endl;
+  std::cout << "d  = " << d << std::endl;
+  std::cout << "x1 = " << x1 << std::endl;
+  std::cout << "x2 = " << x2 << std::endl;
+
+  return x2;
+}
+
+/// \brief Minimisation of the error.
+///
+/// \param[in] histo_grp1 the histogram of the first population.
+/// \param[in] histo_grp2 the histogram of the second population.
+///
+/// \return the threshold.
+///
+/// Computes the error and find the minimum error threshold. It's just
+/// a counting of element in four categories (0 - but detects 1, 1 -
+/// but detects 1, 1 but detects 0, 0 but detects 0). The error is the
+/// sum of missclassifications for the classes 0 and 1. As Otsu done,
+/// we can iterate on the threshold and compute the error associated
+/// to it. The bes threshold is the one that minimize the error.
+short min_error(const mln::image1d<float> histo_grp1,
+		const mln::image1d<float> histo_grp2,
+		float *_c00, float *_c10, float *_c01, float *_c11)
+{
+  float c00[256];
+  float c10[256];
+  float c01[256];
+  float c11[256];
+  float err[256];
+
+  for (short p = 0; p < 256; p++)
+  {
+    c00[p] = cnt_histo(histo_grp1|mln::box1d(mln::point1d(0),
+					     mln::point1d(p)));
+
+    c10[p] = cnt_histo(histo_grp1|mln::box1d(mln::point1d(p+1),
+					     mln::point1d(255)));
+
+    c01[p] = cnt_histo(histo_grp2|mln::box1d(mln::point1d(0),
+					     mln::point1d(p)));
+
+    c11[p] = cnt_histo(histo_grp2|mln::box1d(mln::point1d(p+1),
+					     mln::point1d(255)));
+  }
+
+  short threshold = 0;
+  float error     = c01[0] + c01[0] + c00[0] + c11[0];
+
+  for(short p = 0; p < 256; p++)
+  {
+    err[p] = c10[p] + c01[p];
+
+//     std::cout << " p   = " << p
+// 	      << ";c00 = " << c00[p]
+// 	      << ";c10 = " << c10[p]
+// 	      << ";c01 = " << c01[p]
+// 	      << ";c11 = " << c11[p]
+// 	      << std::endl;
+//    std::cout << "err[" << p <<  "] = " << err[p] << std::endl;
+
+    if (error > err[p])
+    {
+      error     = err[p];
+      threshold = p;
+    }
+  }
+
+  *_c00 = c00[threshold];
+  *_c10 = c10[threshold];
+  *_c01 = c01[threshold];
+  *_c11 = c11[threshold];
+
+  return threshold;
+}
+
+
+/// \brief Fisher analysis.
+///
+/// \param[in] histo the histogram of the mixed population.
+///
+/// \return the threshold.
+///
+/// This routine is less performant than the others because it starts
+/// with a mixed population, but we know exactly the two separated
+/// population. It was just a test. Don't take it in production
+/// environement, it doesn't help you.
+short fisher_analysis(const mln::image1d<float> histo)
+{
+  typedef mln::value::int_u8 t_int_u8;
+
+  // FIXE ME SIZE const short a =  mln_min(t_int_u8);
+  //              float cnt1[a];
+
+  float cnt1[256];
+  float sum1[256];
+  float sqr1[256];
+  float avg1[256];
+  float var1[256];
+
+  float cnt2[256];
+  float sum2[256];
+  float sqr2[256];
+  float avg2[256];
+  float var2[256];
+
+  float cnt0[256]; // count of points
+  float sum0[256]; // sum of population
+  float sqr0[256]; // sqr of population
+  float avg0[256]; // average of the population
+  float v_in[256]; // variance with-in class
+  float v_bw[256]; // variance between class
+  float var0[256]; // variance of the population
+  short threshold;
+  float pos;
+  float min_var;
+
+  // Assign the first elements
+  cnt1[0]   = 0;
+  sum1[0]   = 0;
+  sqr1[0]   = 0;
+  avg1[0]   = 0;
+  var1[0]   = 0;
+
+  // Compute the stats of the wall histogram
+  cnt2[0]   = 0;
+  sum2[0]   = 0;
+  sqr2[0]   = 0;
+
+  for(short p = 0; p < 256; p++)
+  {
+    pos     =  p;
+    cnt2[0] += mln::opt::at(histo,p);
+    sum2[0] += (pos * mln::opt::at(histo,p));
+    sqr2[0] += (mln::math::sqr(pos) * mln::opt::at(histo,p));
+  }
+
+  avg2[0]   = (0 == cnt2[0])? 0 : sum2[0] / cnt2[0];
+  var2[0]   = (0 == cnt2[0])? 0 : sqr2[0] / cnt2[0] - mln::math::sqr(avg2[0]);
+
+  // watch the array limits
+  for (short p = 1; p < 256; p++)
+  {
+    pos     = p;
+
+    // Assign the statistics to the primary class
+    cnt1[p] = cnt1[p-1] + mln::opt::at(histo, p);
+    sum1[p] = sum1[p-1] + pos * mln::opt::at(histo, p);
+    sqr1[p] = sqr1[p-1] + mln::math::sqr(pos) * mln::opt::at(histo, p);
+    avg1[p] = (0 == cnt1[p])? 0 : (sum1[p] / cnt1[p]);
+    var1[p] = (0 == cnt1[p])? 0 : ((sqr1[p] / cnt1[p])-mln::math::sqr(avg1[p]));
+
+    // Assign the statistics to the second class
+    cnt2[p] = cnt2[p-1] - mln::opt::at(histo, p);;
+    sum2[p] = sum2[p-1] - p * mln::opt::at(histo, p);;
+    sqr2[p] = sqr2[p-1] - mln::math::sqr(p) * mln::opt::at(histo, p);;
+    avg2[p] = (0 == cnt2[p])? 0 : (sum2[p] / cnt2[p]);
+    var2[p] = (0 == cnt2[p])? 0 : ((sqr2[p] / cnt2[p])-mln::math::sqr(avg2[p]));
+
+    // Lets compute the invariants
+    cnt0[p] = cnt1[p] + cnt2[p];
+    sum0[p] = sum1[p] + sum2[p];
+    sqr0[p] = sqr1[p] + sqr2[p];
+    avg0[p] = (cnt1[p] * avg1[p] + cnt2[p] * avg2[p])/cnt0[p];
+    v_in[p] = (cnt1[p] * var1[p] + cnt2[p] * var2[p])/cnt0[p];
+    v_bw[p] = (cnt1[p] * mln::math::sqr(avg1[p]-avg0[p]) +
+	       cnt2[p] * mln::math::sqr(avg2[p]-avg0[p]))/cnt0[p];
+    var0[p] = v_in[p] + v_bw[p];
+  }
+
+  // Find the threshold that minimizes the intra-class variance
+  min_var   = cnt2[0]*var2[0];
+  threshold = 0;
+
+  for(short p = 0; p < 256; p++)
+  {
+    // Compute the intra-class variance
+    v_in[p] = cnt1[p]*var1[p] + cnt2[p]*var2[p];
+//    std::cout << "var intra[" << p << "]= " << v_in[p] << std::endl;
+
+    if (min_var > v_in[p])
+    {
+      min_var   = v_in[p];
+      threshold = p;
+    }
+  }
+
+  return threshold;
+}
+/// /}
+
+
+/// Launching part.
+///
+/// In this part, we have the front end that walk over the image
+/// databases and start to compute information that we pass to
+/// previous routines.
+/// \{
+
+#define LVL0_DESCR 0  // Number of grey available
+#define HUE0_DESCR 1  // Density histogram hue analysis
+#define HUE1_DESCR 2  // Millet Hue analysis
+#define SAT0_DESCR 3  // Density histogram saturation analysis
+#define SAT1_DESCR 4  // Millet saturation analysis
+#define VAL0_DESCR 5  // Density histogram grey level analysis
+#define VAL1_DESCR 6  // Millet grey level analysis
+#define GMP0_DESCR 7  // PNSNR with GIMP compression
+#define GMP1_DESCR 8  // PNSNR with GIMP compression
+#define GMP2_DESCR 9  // PNSNR with GIMP compression
+#define MGK0_DESCR 9  // PNSNR with ImageMagick compression
+#define MGK1_DESCR 10 // PNSNR with ImageMagick compression
+#define MGK2_DESCR 11 // PNSNR with ImageMagick compression
+
+#define MGK_DESCR(version) (MGK0_DESCR + version)
+#define GMP_DESCR(version) (GMP0_DESCR + version)
+
+#define NB_DESCR    12  // Number of descriptors
+#define NB_DATABASE 2   // Number of image databases : AFP,ICDAR
+#define NB_IMAGE    110 // Number of images
+#define NB_VERSION  3   // Number of compression by GIMP or ImageMagick
+
+/// \brief Make sure that the result is between 0 and 255.
+///
+/// \param[in] file_name the name of the analysis files.
+/// \param[in] result the values for each image and each descriptors.
+/// \param[in] size the number of image by each database.
+///
+/// Correct the descriptors if there is overflow values. Just used in
+/// debug mode.
+void init_descriptors(std::string file_name[],
+		      float       result[][NB_DESCR],
+		      int         size[])
+{
+  for (int i = 0; i < NB_IMAGE; i++)
+  {
+    file_name[i] = std::string("PGM");
+
+    for (int d = 0; d < NB_DESCR; d++)
+      result[i][d] = (i*d) % 256;
+  }
+
+  size[0] = 62;
+  size[1] = 48;
+}
+
+
+/// \brief Dump gnuplot file for vizualisation of results.
+///
+/// \param[in] file_name the name of the analysis files.
+/// \param[in] result the values for each image and each descriptors.
+/// \param[in] size the number of image by each database.
+///
+/// This routine aimed at plotting the result with one graph. Each
+/// database has got its color. We can see the values used by each
+/// descriptors along the image of each database.
+void dump_descriptors(const std::string file_name[],
+		      const float       result[][NB_DESCR],
+		      const int         size[])
+{
+  std::cout << "#!/usr/bin/gnuplot"                           << std::endl;
+  std::cout << "set terminal x11 persist 1"                   << std::endl;
+  std::cout << "plot '-' using 2 with point title 'ICDAR',\\" << std::endl;
+  std::cout << "     '-' using 2 with point title 'AFP'"      << std::endl;
+
+  int num = 0;
+
+  for (int db = 0; db < NB_DATABASE; db++)
+  {
+    for (int i = 0; i < size[db]; i++)
+    {
+      std::cout << result[num][LVL0_DESCR] << " ";
+      std::cout << result[num][HUE0_DESCR] << " ";
+      std::cout << result[num][HUE1_DESCR] << " ";
+      std::cout << result[num][SAT0_DESCR] << " ";
+      std::cout << result[num][SAT1_DESCR] << " ";
+      std::cout << result[num][VAL0_DESCR] << " ";
+      std::cout << result[num][VAL1_DESCR] << " ";
+      std::cout << result[num][GMP0_DESCR] << " ";
+      std::cout << result[num][GMP1_DESCR] << " ";
+      std::cout << result[num][GMP2_DESCR] << " ";
+      std::cout << result[num][MGK0_DESCR] << " ";
+      std::cout << result[num][MGK1_DESCR] << " ";
+      std::cout << result[num][MGK2_DESCR] << " ";
+      std::cout << " # " << file_name[num] << std::endl;
+      num++;
+    }
+
+    std::cout << "e"   << std::endl;
+  }
+}
+
+
+/// \brief Compute the descriptor histograms for each database.
+///
+/// \param[in] result the result values of each descriptors.
+/// \param[in] size the number of images by database.
+/// \param[out] histo the computed histograms.
+///
+/// This routine compute a histograms for each database and each descriptors.
+/// So we can see the distribution of descriptor values over each database.
+/// Result values are transform from float to int for histograms.
+void compute_histo(const float			result[][NB_DESCR],
+		   const int			size[],
+		   mln::image1d<float>          histo[][NB_DATABASE])
+{
+  for (int i = 0; i < NB_DESCR; i++)
+    for (int db = 0; db < NB_DATABASE; db++)
+  {
+    histo[i][db].init_(mln::box1d(mln::point1d(0),mln::point1d(255)));
+
+    mln::data::fill(histo[i][db], mln::literal::zero);
+  }
+
+  short v;
+  int   num = 0;
+
+  for (int db = 0; db < NB_DATABASE; db++)
+  {
+    for (int i = 0; i < size[db]; i++)
+    {
+ 	v = (short)mln::math::floor(result[num][VAL0_DESCR]+0.4999);
+ 	mln::opt::at(histo[VAL0_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][LVL0_DESCR]+0.4999);
+ 	mln::opt::at(histo[LVL0_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][HUE0_DESCR]+0.4999);
+ 	mln::opt::at(histo[HUE0_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][HUE1_DESCR]+0.4999);
+ 	mln::opt::at(histo[HUE1_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][SAT0_DESCR]+0.4999);
+ 	mln::opt::at(histo[SAT0_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][SAT1_DESCR]+0.4999);
+ 	mln::opt::at(histo[SAT1_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][VAL1_DESCR]+0.4999);
+ 	mln::opt::at(histo[VAL1_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][GMP0_DESCR]+0.4999);
+ 	mln::opt::at(histo[GMP0_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][GMP1_DESCR]+0.4999);
+ 	mln::opt::at(histo[GMP1_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][GMP2_DESCR]+0.4999);
+ 	mln::opt::at(histo[GMP2_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][MGK0_DESCR]+0.4999);
+ 	mln::opt::at(histo[MGK0_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][MGK1_DESCR]+0.4999);
+ 	mln::opt::at(histo[MGK1_DESCR][db],v)++;
+
+ 	v = (short)mln::math::floor(result[num][MGK2_DESCR]+0.4999);
+ 	mln::opt::at(histo[MGK2_DESCR][db],v)++;
+
+	num++;
+    }
+  }
+}
+
+
+/// Compute the threshold for discrimination between ICDAR and AFP.
+///
+/// \param[in] histo the histogram for each descriptor and for each database.
+/// \param[out] threshold computed values to discriminate between ICDAR/AFP.
+/// \param[out] c00 say CLASS 1 but CLASS 1.
+/// \param[out] c10 say CLASS 2 but CLASS 1.
+/// \param[out] c01 say CLASS 1 but CLASS 2.
+/// \param[out] c11 say CLASS 2 but CLASS 2.
+///
+/// Compute the threshold by the minimum of error of
+/// classification. Population are inverted in function of average,
+/// technical solution to prevent min_error crashed. The bad thing is
+/// now, the class 0 can be either ICDAR of AFP, depends on descriptors.
+void compute_thresholds(const mln::image1d<float>    histo[][NB_DATABASE],
+			short                        threshold[],
+			float                        c00[],
+			float                        c10[],
+			float                        c01[],
+			float                        c11[])
+{
+  for (int i = 0; i < NB_DESCR; i++)
+  {
+    float avg0 = avg_histo(histo[i][0]);
+    float avg1 = avg_histo(histo[i][1]);
+
+    if (avg0 < avg1)
+    {
+      threshold[i] = min_error(histo[i][0], histo[i][1],
+			       &c00[i], &c10[i], &c01[i], &c11[i]);
+    }
+    else
+    {
+      threshold[i] = min_error(histo[i][1], histo[i][0],
+			       &c00[i], &c10[i], &c01[i], &c11[i]);
+    }
+
+    std::cerr << "  i = "   << i
+	      << "; c00 = " << c00[i]
+	      << "; c10 = " << c10[i]
+	      << "; c01 = " << c01[i]
+	      << "; c11 = " << c11[i]
+	      << "; threshold " << threshold[i]
+	      << std::endl;
+
+  }
+}
+
+
+/// \brief Walk over the database directories.
+///
+/// \param[out] file_name the array of the image name.
+/// \param[out] result the descriptors values for each image.
+/// \param[out] size the number of image for each database.
+///
+/// This is the front end part to access to the database directories. We use
+/// boost library to do it. First we explore ICDAR database en then the AFP one.
+/// For each valid image, we compute all the descriptors. Histograms are
+/// computed at this level because we can do that thing one time for every
+/// density descriptors. Every parameters are updated to retrurn the values.
+void compute_descriptors(std::string file_name[],
+			 float       result[][NB_DESCR],
+			 int         size[])
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+  typedef mln::image1d<unsigned>                    t_histo;
+  typedef mln::value::rgb8                          t_rgb8;
+  typedef mln::value::int_u8                        t_int_u8;
+  typedef mln::image2d<t_int_u8>                    t_map;
+  typedef mln::image2d<t_rgb8>                      t_input;
+  typedef mln::fun::v2v::rgb_to_hue_map<8>          t_rgb_2_hue;
+  typedef mln::fun::v2v::rgb_to_saturation_map<8>   t_rgb_2_sat;
+  typedef mln::fun::v2v::rgb_to_value_map<8>        t_rgb_2_val;
+  typedef mln::fun::v2v::component<t_rgb8,0>        t_rgb_2_red;
+  typedef mln::fun::v2v::component<t_rgb8,1>        t_rgb_2_green;
+  typedef mln::fun::v2v::component<t_rgb8,2>        t_rgb_2_blue;
+  typedef mln::accu::meta::stat::histo1d            t_accu_histo;
+
+
+  t_path img_path[2]    = { ICDAR_20P_INPUT_IMG_PATH, AFP_PPM_IMG_PATH};
+  t_path mgk_path[3][2] = {{ICDAR_20P_MGK30_IMG_PATH, AFP_MGK30_IMG_PATH},
+			   {ICDAR_20P_MGK20_IMG_PATH, AFP_MGK20_IMG_PATH},
+			   {ICDAR_20P_MGK10_IMG_PATH, AFP_MGK10_IMG_PATH}};
+  t_path gmp_path[3][2] = {{ICDAR_20P_GMP30_IMG_PATH, AFP_GMP30_IMG_PATH},
+			   {ICDAR_20P_GMP20_IMG_PATH, AFP_GMP20_IMG_PATH},
+			   {ICDAR_20P_GMP10_IMG_PATH, AFP_GMP10_IMG_PATH}};
+
+  int    num            = 0;
+  int	 cnt	        = 0;
+
+  for (int db = 0; db < NB_DATABASE; db++)
+  {
+    if (boost::filesystem::exists(img_path[db]) &&
+	boost::filesystem::is_directory(img_path[db]))
+    {
+      boost::filesystem::system_complete(img_path[db]);
+
+      const t_iter_path end_iter;
+
+      cnt = 0;
+
+      for (t_iter_path dir_iter(img_path[db]); end_iter != dir_iter; ++dir_iter)
+      {
+	t_path  img_file  = dir_iter->path().leaf();
+	t_path  dir_file  = dir_iter->path();
+	t_input img_input;
+
+	mln::io::ppm::load(img_input, dir_file.string().c_str());
+
+	t_map   h_img_map = mln::data::transform(img_input, t_rgb_2_hue());
+	t_map   s_img_map = mln::data::transform(img_input, t_rgb_2_sat());
+	t_map   v_img_map = mln::data::transform(img_input, t_rgb_2_val());
+	t_map   r_img_map = mln::data::transform(img_input, t_rgb_2_red());
+	t_map   g_img_map = mln::data::transform(img_input, t_rgb_2_green());
+	t_map   b_img_map = mln::data::transform(img_input, t_rgb_2_blue());
+	t_histo h_img_hst = mln::data::compute(t_accu_histo(), h_img_map);
+	t_histo s_img_hst = mln::data::compute(t_accu_histo(), s_img_map);
+	t_histo v_img_hst = mln::data::compute(t_accu_histo(), v_img_map);
+	t_histo r_img_hst = mln::data::compute(t_accu_histo(), r_img_map);
+	t_histo g_img_hst = mln::data::compute(t_accu_histo(), g_img_map);
+	t_histo b_img_hst = mln::data::compute(t_accu_histo(), b_img_map);
+
+	std::cerr << dir_iter->path() << std::endl;
+
+	file_name[num] = img_file.string();
+
+	// descriptors
+	result[num][LVL0_DESCR] = lvl0_descriptor(v_img_hst);
+	result[num][HUE0_DESCR] = hue0_descriptor(h_img_hst);
+	result[num][HUE1_DESCR] = hue1_descriptor(h_img_hst,20);
+	result[num][SAT0_DESCR] = sat0_descriptor(s_img_hst);
+	result[num][SAT1_DESCR] = sat1_descriptor(s_img_hst,50);
+	result[num][VAL0_DESCR] = val0_descriptor(v_img_hst);
+	//result[num][VAL1_DESCR] = val1_descriptor(v_img_hst, 15);
+	result[num][VAL1_DESCR] = 0;
+
+	// for gimp and magick
+	for (int v = 0; v < NB_VERSION; v++)
+	{
+	  if (boost::filesystem::exists(mgk_path[v][db]) &&
+	      boost::filesystem::exists(gmp_path[v][db]) &&
+	      boost::filesystem::is_directory(mgk_path[v][db]) &&
+	      boost::filesystem::is_directory(gmp_path[v][db]))
+	  {
+	    t_path  mgk_file  = mgk_path[v][db] / img_file;
+	    t_path  gmp_file  = gmp_path[v][db] / img_file;
+	    t_input gmp_input;
+
+	    mln::io::ppm::load(gmp_input, gmp_file.string().c_str());
+
+	    t_map   r_gmp_map = mln::data::transform(gmp_input,t_rgb_2_red());
+	    t_map   g_gmp_map = mln::data::transform(gmp_input,t_rgb_2_green());
+	    t_map   b_gmp_map = mln::data::transform(gmp_input,t_rgb_2_blue());
+
+	    result[num][GMP_DESCR(v)]= err_descriptor(r_img_map,
+						      g_img_map,
+						      b_img_map,
+						      r_gmp_map,
+						      g_gmp_map,
+						      b_gmp_map);
+
+	    t_input mgk_input;
+
+	    mln::io::ppm::load(mgk_input, mgk_file.string().c_str());
+
+	    t_map   r_mgk_map = mln::data::transform(mgk_input,t_rgb_2_red());
+	    t_map   g_mgk_map = mln::data::transform(mgk_input,t_rgb_2_green());
+	    t_map   b_mgk_map = mln::data::transform(mgk_input,t_rgb_2_blue());
+
+	    result[num][MGK_DESCR(v)]= err_descriptor(r_img_map,
+						      g_img_map,
+						      b_img_map,
+						      r_mgk_map,
+						      g_mgk_map,
+						      b_mgk_map);
+	  }
+	}
+
+	num++;
+	cnt++;
+      }
+    }
+
+    size[db] = cnt;
+  }
+}
+
+/// \brief Just for debugging purpose and tests.
+int main2()
+{
+  typedef mln::image1d<unsigned>                    t_histo;
+  typedef mln::value::rgb8                          t_rgb8;
+  typedef mln::value::int_u8                        t_int_u8;
+  typedef mln::image2d<t_int_u8>                    t_map;
+  typedef mln::image2d<t_rgb8>                      t_input;
+  typedef mln::fun::v2v::rgb_to_hue_map<8>          t_rgb_2_hue;
+  typedef mln::fun::v2v::rgb_to_saturation_map<8>   t_rgb_2_sat;
+  typedef mln::fun::v2v::rgb_to_value_map<8>        t_rgb_2_val;
+  typedef mln::fun::v2v::component<t_rgb8,0>        t_rgb_2_red;
+  typedef mln::fun::v2v::component<t_rgb8,1>        t_rgb_2_green;
+  typedef mln::fun::v2v::component<t_rgb8,2>        t_rgb_2_blue;
+  typedef mln::accu::meta::stat::histo1d            t_accu_histo;
+
+  t_input img_input;
+
+  mln::io::ppm::load(img_input, ICDAR_20P_INPUT_IMG_PATH"/mp00032c_20p.ppm");
+  //mln::io::ppm::load(img_input, AFP_PPM_IMG_PATH"/000_Del218430.ppm");
+
+
+
+  t_map   h_img_map = mln::data::transform(img_input, t_rgb_2_hue());
+  t_map   s_img_map = mln::data::transform(img_input, t_rgb_2_sat());
+  t_map   v_img_map = mln::data::transform(img_input, t_rgb_2_val());
+  t_map   r_img_map = mln::data::transform(img_input, t_rgb_2_red());
+  t_map   g_img_map = mln::data::transform(img_input, t_rgb_2_green());
+  t_map   b_img_map = mln::data::transform(img_input, t_rgb_2_blue());
+  t_histo h_img_hst = mln::data::compute(t_accu_histo(), h_img_map);
+  t_histo s_img_hst = mln::data::compute(t_accu_histo(), s_img_map);
+  t_histo v_img_hst = mln::data::compute(t_accu_histo(), v_img_map);
+  t_histo r_img_hst = mln::data::compute(t_accu_histo(), r_img_map);
+  t_histo g_img_hst = mln::data::compute(t_accu_histo(), g_img_map);
+  t_histo b_img_hst = mln::data::compute(t_accu_histo(), b_img_map);
+
+
+  std::cout << "sat2 : " << sat0_descriptor(s_img_hst) << std::endl;
+
+  return 0;
+}
+
+
+/// \brief Main entry.
+///
+/// This is the front end for every routines.
+/// - compute descriptors.
+/// - dump descriptors.
+/// - compute histograms.
+/// - compute thresholds.
+/// - save results.
+///
+/// Global data used:
+/// - file_name : all the initial images name, mixed every image database.
+/// - result : all the result values for every descriptors and for every images.
+/// - histo : the histograms ny database and by descriptors.
+/// - size : the number of image by database.
+/// - threshold : the computed histogram separation on each descriptors.
+/// - cxx : the count of well/bad classified images function of threshold info.
+int main()
+{
+  std::string			file_name[NB_IMAGE];
+  float				result[NB_IMAGE][NB_DESCR];
+  int				size[NB_DATABASE];
+  mln::image1d<float>		histo[NB_DESCR][NB_DATABASE];
+  short				threshold[NB_DESCR];
+  float				c00[NB_DESCR];
+  float				c10[NB_DESCR];
+  float				c01[NB_DESCR];
+  float				c11[NB_DESCR];
+
+  std::cerr << "DESCRIPTORS" << std::endl;
+  compute_descriptors(file_name,result,size);
+//   std::cout << "DUMPING" << std::endl;
+//   init_descriptors(file_name,result,size);
+  dump_descriptors(file_name,result,size);
+  std::cerr << "HISTO" << std::endl;
+  compute_histo(result,size,histo);
+  std::cerr << "THRESHOLD" << std::endl;
+  compute_thresholds(histo,threshold,c00,c10,c01,c11);
+
+  mln::io::plot::save_image_sh(histo[LVL0_DESCR][0], "lvl0_histo1.sh");
+  mln::io::plot::save_image_sh(histo[HUE0_DESCR][0], "hue0_histo1.sh");
+  mln::io::plot::save_image_sh(histo[HUE1_DESCR][0], "hue1_histo1.sh");
+  mln::io::plot::save_image_sh(histo[SAT0_DESCR][0], "sat0_histo1.sh");
+  mln::io::plot::save_image_sh(histo[SAT1_DESCR][0], "sat1_histo1.sh");
+  mln::io::plot::save_image_sh(histo[VAL0_DESCR][0], "val0_histo1.sh");
+  mln::io::plot::save_image_sh(histo[VAL1_DESCR][0], "val1_histo1.sh");
+  mln::io::plot::save_image_sh(histo[GMP0_DESCR][0], "gmp0_histo1.sh");
+  mln::io::plot::save_image_sh(histo[GMP1_DESCR][0], "gmp1_histo1.sh");
+  mln::io::plot::save_image_sh(histo[GMP2_DESCR][0], "gmp2_histo1.sh");
+  mln::io::plot::save_image_sh(histo[MGK0_DESCR][0], "mgk0_histo1.sh");
+  mln::io::plot::save_image_sh(histo[MGK1_DESCR][0], "mgk1_histo1.sh");
+  mln::io::plot::save_image_sh(histo[MGK2_DESCR][0], "mgk2_histo1.sh");
+
+  mln::io::plot::save_image_sh(histo[LVL0_DESCR][1], "lvl0_histo2.sh");
+  mln::io::plot::save_image_sh(histo[HUE0_DESCR][1], "hue0_histo2.sh");
+  mln::io::plot::save_image_sh(histo[HUE1_DESCR][1], "hue1_histo2.sh");
+  mln::io::plot::save_image_sh(histo[SAT0_DESCR][1], "sat0_histo2.sh");
+  mln::io::plot::save_image_sh(histo[SAT1_DESCR][1], "sat1_histo2.sh");
+  mln::io::plot::save_image_sh(histo[VAL0_DESCR][1], "val0_histo2.sh");
+  mln::io::plot::save_image_sh(histo[VAL1_DESCR][1], "val1_histo2.sh");
+  mln::io::plot::save_image_sh(histo[GMP0_DESCR][1], "gmp0_histo2.sh");
+  mln::io::plot::save_image_sh(histo[GMP1_DESCR][1], "gmp1_histo2.sh");
+  mln::io::plot::save_image_sh(histo[GMP2_DESCR][1], "gmp2_histo2.sh");
+  mln::io::plot::save_image_sh(histo[MGK0_DESCR][1], "mgk0_histo2.sh");
+  mln::io::plot::save_image_sh(histo[MGK1_DESCR][1], "mgk1_histo2.sh");
+  mln::io::plot::save_image_sh(histo[MGK2_DESCR][1], "mgk2_histo2.sh");
+
+  return 0;
+}
+/// \}
+
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/error/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/error/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/error/error.cc b/scribo/sandbox/green/exp/annotating/error/error.cc
new file mode 100644
index 0000000..949b51b
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/error/error.cc
@@ -0,0 +1,833 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// This file is a prelude just before using the bench source. It puts
+/// the light on the Jonathan's idea which wants to compare ICDAR and
+/// AFP image database with difference between original image and
+/// color reducted one. The key point is to say that when a color
+/// image is degraded, the visual quality fall quickly in function of
+/// the number of colors left. A contrario, when an image is black and
+/// white, this kind of degradation doesn't change the original visual
+/// quality. The PNSNR detector is build and learning threshold for
+/// automatic classification is done (four algorithms are tested).
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/algebra/vec.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/mean.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/arith/minus.hh>
+#include <mln/arith/times.hh>
+#include <mln/arith/diff_abs.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/core/alias/point1d.hh>
+#include <mln/core/alias/box1d.hh>
+
+#include <mln/data/transform.hh>
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/fill.hh>
+
+#include <mln/fun/v2v/component.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/literal/zero.hh>
+
+#include <mln/math/ceil.hh>
+#include <mln/math/floor.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/trait/value_.hh>
+
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u8.hh>
+
+/// Work on histogram.
+/// \brief Different routines are presented for computing mean, variance ...
+/// \{
+
+/// \brief Counting the number of pixels in the histogram.
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the number of pixels in the histogram.
+///
+/// Such routine is a generic and is generally applied on a portion of
+/// the real domain.
+template <typename I>
+mln_value(I) cnt_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum += histo(p);
+  }
+
+  return sum;
+}
+
+/// \brief Summing the values ponderated by their occurences.
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the sum ponderated of values by their occurences.
+///
+/// This method is not a production routine, it's just a test to debug
+/// histogram problem. When we compute something over the histogram,
+/// we need to take care of the intermediate type that contains the
+/// temporary result. If not the case, the type used is the one of the
+/// value of the histogram and we can go to some overflow
+/// problems. The trick is to store the value returned by the iterator
+/// in some temporary computing type (look at pos in the code).
+template <typename I>
+mln_value(I) sum_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    sum += pos*histo(p);
+  }
+
+  return sum;
+}
+
+/// \brief Summing the values ponderated by their occurences.
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the sum ponderated of values by their occurences.
+template <typename I>
+mln_value(I) avg_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    cnt += histo(p);
+    sum += pos*histo(p);
+  }
+
+  return (0 == cnt)? 0 : sum/cnt;
+}
+
+/// \brief Computing the variance
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the variance of the histogram.
+///
+/// This computing is safe because the quantity of information stored
+/// in sum is low. This formulae doesn't show the overflow problem.
+template <typename I>
+mln_value(I) var3_histo(const mln::Image<I>& histo_, float mean)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    cnt += histo(p);
+    sum += (mln::math::sqr(p.ind()-mean)*histo(p));
+  }
+
+  return (0 == cnt)? 0 : sum/cnt;
+}
+
+/// \brief Computing the variance
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the variance of the histogram.
+///
+/// This is the debugging code to observe overflow problem.
+template <typename I>
+mln_value(I) var2_histo(const mln::Image<I>& histo_, float mean)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) sqr = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_value(I) dlt = mln::literal::zero;
+  mln_value(I) mxt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    cnt += (histo(p));
+    sum += (histo(p)*pos);
+    mxt += (histo(p)*pos*mean);
+    sqr += (histo(p)*mln::math::sqr(pos));
+    dlt += (histo(p)*mln::math::sqr(pos - mean));
+
+    std::cout << "p          = " << pos                       << std::endl;
+    std::cout << "p²         = " << mln::math::sqr(pos)       << std::endl;
+    std::cout << "p*mean     = " << (pos*mean)                << std::endl;
+    std::cout << "p-mean     = " << (pos-mean)                << std::endl;
+    std::cout << "(p-mean)²  = " << mln::math::sqr(pos-mean)  << std::endl;
+    std::cout << "histo(p)   = " << histo(p)                  << std::endl;
+    std::cout << "histo(p)*p = " << (pos*histo(p))            << std::endl;
+    std::cout << "histo(p)*p²= " << (mln::math::sqr(pos)*histo(p))
+	      << std::endl;
+    std::cout << "cnt        = " << cnt      << std::endl;
+    std::cout << "sum        = " << sum      << std::endl;
+    std::cout << "sqr        = " << sqr      << std::endl;
+    std::cout << "dlt        = " << dlt      << std::endl;
+    std::cout << "mxt        = " << mxt      << std::endl;
+    std::cout << std::endl;
+  }
+
+  std::cout << "sqr/cnt      = " << (sqr/cnt)               << std::endl;
+  std::cout << "sum/cnt      = " << (sum/cnt)               << std::endl;
+  std::cout << "(sum/cnt)²   = " << mln::math::sqr(sum/cnt) << std::endl;
+  std::cout << "dlt/cnt      = " << dlt/cnt                 << std::endl;
+  std::cout << "mxt/cnt      = " << mxt/cnt                 << std::endl;
+  std::cout << std::endl;
+
+  std::cout << "sqr                     = "
+	    << (sqr)                                          << std::endl;
+  std::cout << "dlt                     = "
+	    << (dlt)                                          << std::endl;
+  std::cout << "cnt*avg²                = "
+	    << (mln::math::sqr(sum/cnt)*cnt)                  << std::endl;
+  std::cout << "2*mxt                   = "
+	    << (2*mxt)                                        << std::endl;
+  std::cout << "sqr - cnt*avg²          = "
+	    << (sqr/cnt - mln::math::sqr(sum/cnt))            << std::endl;
+  std::cout << "(sqr -2*mxt + cnt*avg²) = "
+	    <<  ((sqr - 2*mxt + mln::math::sqr(sum/cnt))/cnt) << std::endl;
+  std::cout << std::endl;
+  return (0 == cnt)? 0 : sqr/cnt - mln::math::sqr(sum/cnt);
+}
+
+/// \brief Computing the variance
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the variance of the histogram.
+///
+/// My standard code for the variance.
+template <typename I>
+mln_value(I) var_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) pos = mln::literal::zero;
+  mln_value(I) sum = mln::literal::zero;
+  mln_value(I) sqr = mln::literal::zero;
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    pos =  p.ind();
+    cnt += (histo(p));
+    sum += (histo(p)*pos);
+    sqr += (histo(p)*mln::math::sqr(pos));
+  }
+
+  return (0 == cnt)? 0 : sqr/cnt - mln::math::sqr(sum/cnt);
+}
+/// \}
+
+
+/// Classify.
+/// \brief Classification routines that compute threshold.
+/// \{
+
+/// \brief Compute discrimination threshold.
+/// \param[in] avg1 the mean of the population 1.
+/// \param[in] var1 the variance of the population 1.
+/// \param[in] avg2 the mean of the population 2.
+/// \param[in] var2 the variance of the population 2.
+///
+/// \return the threshold to discriminate the two populations.
+///
+/// Linear discriminant analysis in 1d is done. When two population
+/// have the same variance, the threshold is at (m1+m2)/2. When threre
+/// are different variances, we propose the threshold at the position
+/// (m1*sqrt(v1)+m2*sqrt(v2))/(sqrt(v1)+sqrt(v2)).
+float threshold_histo(float avg1, float var1, float avg2, float var2)
+{
+  float sigma1    = mln::math::sqrt(var1);
+  float sigma2    = mln::math::sqrt(var2);
+  float threshold = (avg1*sigma1+avg2*sigma2)/(sigma1+sigma2);
+
+  return threshold;
+}
+
+/// \brief Compute discrimination threshold.
+/// \param[in] avg1 the mean of the population 1.
+/// \param[in] var1 the variance of the population 1.
+/// \param[in] avg2 the mean of the population 2.
+/// \param[in] var2 the variance of the population 2.
+///
+/// \return the threshold to discriminate the two populations.
+///
+/// Linear discriminant analysis in 1d is done. When two population
+/// have the same variance, the threshold is at (m1+m2)/2. When threre
+/// are different variances, we propose the threshold at the position
+/// (m1*var1+m2*var2)/(sqrt(v1)+sqrt(v2)).
+float threshold3_histo(float avg1, float var1, float avg2, float var2)
+{
+  float threshold = (avg1*var1+avg2*var2)/(var1+var2);
+
+  return threshold;
+}
+
+
+
+/// \brief Compute discrimination threshold.
+/// \param[in] avg1 the mean of the population 1.
+/// \param[in] var1 the variance of the population 1.
+/// \param[in] avg2 the mean of the population 2.
+/// \param[in] var2 the variance of the population 2.
+///
+/// \return the threshold to discriminate the two populations.
+///
+/// Gaussian discriminant analysis in 1d is done. Compute the
+/// discrimanation and solve the parabolic equation.
+float threshold2_histo(float avg1, float var1, float avg2, float var2)
+{
+  float a = var2 - var1;
+  float b = -2 * (avg1 * var2 - avg2 * var1);
+  float c = var2 * mln::math::sqr(avg1) - var1 * mln::math::sqr(avg2);
+  float d = mln::math::sqr(b) - 4 * a * c;
+
+  if (d < 0)
+    std::cout << "delta negatif" << std::endl;
+
+  float x1 = (-b+mln::math::sqrt(d))/(2*a);
+  float x2 = (-b-mln::math::sqrt(d))/(2*a);
+
+  std::cout << "a  = " << a << std::endl;
+  std::cout << "b  = " << b << std::endl;
+  std::cout << "c  = " << c << std::endl;
+  std::cout << "d  = " << d << std::endl;
+  std::cout << "x1 = " << x1 << std::endl;
+  std::cout << "x2 = " << x2 << std::endl;
+
+  return x2;
+}
+
+/// \brief Compute the other proportion of histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the ponderated sum of the sqrt values.
+///
+/// This is a test. Don't take this routine in production.
+template <typename I>
+mln_value(I) sqr_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    sum += (mln::math::sqr(p.ind())*histo(p));
+
+  return sum;
+}
+
+/// \brief Minimisation of the error.
+///
+/// \param[in] histo_grp1 the histogram of the first population.
+/// \param[in] histo_grp2 the histogram of the second population.
+///
+/// \return the threshold.
+///
+/// Computes the error and find the minimum error threshold. It's just
+/// a counting of element in four categories (0 - but detects 1, 1 -
+/// but detects 1, 1 but detects 0, 0 but detects 0). The error is the
+/// sum of missclassifications for the classes 0 and 1. As Otsu done,
+/// we can iterate on the threshold and compute the error associated
+/// to it. The bes threshold is the one that minimize the error.
+short min_error(const mln::image1d<float> histo_grp1,
+		const mln::image1d<float> histo_grp2)
+{
+  float c00[256];
+  float c10[256];
+  float c01[256];
+  float c11[256];
+  float err[256];
+
+  for (short p = 0; p < 256; p++)
+  {
+    c00[p] = cnt_histo(histo_grp1|mln::box1d(mln::point1d(0),
+					     mln::point1d(p)));
+
+    c10[p] = cnt_histo(histo_grp1|mln::box1d(mln::point1d(p+1),
+					     mln::point1d(255)));
+
+    c01[p] = cnt_histo(histo_grp2|mln::box1d(mln::point1d(0),
+					     mln::point1d(p)));
+
+    c11[p] = cnt_histo(histo_grp2|mln::box1d(mln::point1d(p+1),
+					     mln::point1d(255)));
+  }
+
+  short threshold = 0;
+  float error     = c01[0] + c01[0] + c00[0] + c11[0];
+
+  for(short p = 0; p < 256; p++)
+  {
+    err[p] = c10[p] + c01[p];
+
+    std::cout << " p   = " << p
+	      << ";c00 = " << c00[p]
+	      << ";c10 = " << c10[p]
+	      << ";c01 = " << c01[p]
+	      << ";c11 = " << c11[p]
+	      << std::endl;
+//    std::cout << "err[" << p <<  "] = " << err[p] << std::endl;
+
+    if (error > err[p])
+    {
+      error     = err[p];
+      threshold = p;
+    }
+  }
+
+  return threshold;
+}
+
+/// \brief Fisher analysis.
+///
+/// \param[in] histo the histogram of the mixed population.
+///
+/// \return the threshold.
+///
+/// This routine is less performant than the others because it starts
+/// with a mixed population, but we know exactly the two separated
+/// population. It was just a test. Don't take it in production
+/// environement, it doesn't help you.
+short fisher_analysis(const mln::image1d<float> histo)
+{
+  typedef mln::value::int_u8 t_int_u8;
+
+  // FIXE ME SIZE const short a =  mln_min(t_int_u8);
+  //              float cnt1[a];
+
+  float cnt1[256];
+  float sum1[256];
+  float sqr1[256];
+  float avg1[256];
+  float var1[256];
+
+  float cnt2[256];
+  float sum2[256];
+  float sqr2[256];
+  float avg2[256];
+  float var2[256];
+
+  float cnt0[256]; // count of points
+  float sum0[256]; // sum of population
+  float sqr0[256]; // sqr of population
+  float avg0[256]; // average of the population
+  float v_in[256]; // variance with-in class
+  float v_bw[256]; // variance between class
+  float var0[256]; // variance of the population
+  short threshold;
+  float pos;
+  float min_var;
+
+  // Assign the first elements
+  cnt1[0]   = 0;
+  sum1[0]   = 0;
+  sqr1[0]   = 0;
+  avg1[0]   = 0;
+  var1[0]   = 0;
+
+  // Compute the stats of the wall histogram
+  cnt2[0]   = 0;
+  sum2[0]   = 0;
+  sqr2[0]   = 0;
+
+  for(short p = 0; p < 256; p++)
+  {
+    pos     =  p;
+    cnt2[0] += mln::opt::at(histo,p);
+    sum2[0] += (pos * mln::opt::at(histo,p));
+    sqr2[0] += (mln::math::sqr(pos) * mln::opt::at(histo,p));
+  }
+
+  avg2[0]   = (0 == cnt2[0])? 0 : sum2[0] / cnt2[0];
+  var2[0]   = (0 == cnt2[0])? 0 : sqr2[0] / cnt2[0] - mln::math::sqr(avg2[0]);
+
+  // watch the array limits
+  for (short p = 1; p < 256; p++)
+  {
+    pos     = p;
+
+    // Assign the statistics to the primary class
+    cnt1[p] = cnt1[p-1] + mln::opt::at(histo, p);
+    sum1[p] = sum1[p-1] + pos * mln::opt::at(histo, p);
+    sqr1[p] = sqr1[p-1] + mln::math::sqr(pos) * mln::opt::at(histo, p);
+    avg1[p] = (0 == cnt1[p])? 0 : (sum1[p] / cnt1[p]);
+    var1[p] = (0 == cnt1[p])? 0 : ((sqr1[p] / cnt1[p])-mln::math::sqr(avg1[p]));
+
+    // Assign the statistics to the second class
+    cnt2[p] = cnt2[p-1] - mln::opt::at(histo, p);;
+    sum2[p] = sum2[p-1] - p * mln::opt::at(histo, p);;
+    sqr2[p] = sqr2[p-1] - mln::math::sqr(p) * mln::opt::at(histo, p);;
+    avg2[p] = (0 == cnt2[p])? 0 : (sum2[p] / cnt2[p]);
+    var2[p] = (0 == cnt2[p])? 0 : ((sqr2[p] / cnt2[p])-mln::math::sqr(avg2[p]));
+
+    // Lets compute the invariants
+    cnt0[p] = cnt1[p] + cnt2[p];
+    sum0[p] = sum1[p] + sum2[p];
+    sqr0[p] = sqr1[p] + sqr2[p];
+    avg0[p] = (cnt1[p] * avg1[p] + cnt2[p] * avg2[p])/cnt0[p];
+    v_in[p] = (cnt1[p] * var1[p] + cnt2[p] * var2[p])/cnt0[p];
+    v_bw[p] = (cnt1[p] * mln::math::sqr(avg1[p]-avg0[p]) +
+	       cnt2[p] * mln::math::sqr(avg2[p]-avg0[p]))/cnt0[p];
+    var0[p] = v_in[p] + v_bw[p];
+  }
+
+  // Find the threshold that minimizes the intra-class variance
+  min_var   = cnt2[0]*var2[0];
+  threshold = 0;
+
+  for(short p = 0; p < 256; p++)
+  {
+    // Compute the intra-class variance
+    v_in[p] = cnt1[p]*var1[p] + cnt2[p]*var2[p];
+//    std::cout << "var intra[" << p << "]= " << v_in[p] << std::endl;
+
+    if (min_var > v_in[p])
+    {
+      min_var   = v_in[p];
+      threshold = p;
+    }
+  }
+
+  return threshold;
+}
+/// \}
+
+/// \brief ERROR (MSE, PNSNR) compression p278 Handbook Color.
+/// \param[in] original the original image.
+/// \param[in] reduced the image with a reduced number of colors.
+///
+/// \return the PNSNR.
+///
+/// Compute the PNSNR. First compute the square difference in each
+/// channel. Then compute the mean of those square differences and get
+/// the mean over the three channels. Then, get the sqrt of that to
+/// have a distance. The PNSNR is a logarithmic quantity of that distance.
+float error_test(const std::string original,
+		 const std::string reduced)
+
+{
+
+  typedef mln::value::rgb8                     t_rgb8;
+  typedef mln::value::int_u8                   t_int_u8;
+  typedef mln::fun::v2v::component<t_rgb8,0>   t_component_red;
+  typedef mln::fun::v2v::component<t_rgb8,1>   t_component_green;
+  typedef mln::fun::v2v::component<t_rgb8,2>   t_component_blue;
+  typedef mln::accu::meta::stat::mean          t_mean;
+  typedef mln::accu::meta::stat::histo1d       t_histo;
+  typedef mln::image2d<t_int_u8>               t_img;
+  typedef mln_trait_op_minus_(t_img,t_img)     t_minus;
+  typedef mln_trait_op_times_(t_minus,t_minus) t_times;
+
+  mln::image2d<mln::value::rgb8>   original_rgb8;
+  mln::image2d<mln::value::rgb8>   reduced_rgb8;
+
+  mln::image2d<mln::value::int_u8> original_red;
+  mln::image2d<mln::value::int_u8> original_green;
+  mln::image2d<mln::value::int_u8> original_blue;
+
+  mln::image2d<mln::value::int_u8> reduced_red;
+  mln::image2d<mln::value::int_u8> reduced_green;
+  mln::image2d<mln::value::int_u8> reduced_blue;
+
+//   mln::image2d<mln::value::int_u8> map_red;
+//   mln::image2d<mln::value::int_u8> map_green;
+//   mln::image2d<mln::value::int_u8> map_blue;
+
+//   mln::image1d<unsigned>           histo_red;
+//   mln::image1d<unsigned>           histo_green;
+//   mln::image1d<unsigned>           histo_blue;
+
+  t_minus                          minus_red;
+  t_minus                          minus_green;
+  t_minus                          minus_blue;
+
+  t_times                          times_red;
+  t_times                          times_green;
+  t_times                          times_blue;
+
+  float                            error_red;
+  float                            error_green;
+  float                            error_blue;
+
+  float                            error;
+
+
+  mln::io::ppm::load(original_rgb8, original.c_str());
+  mln::io::ppm::load(reduced_rgb8, reduced.c_str());
+
+  original_red   = mln::data::transform(original_rgb8, t_component_red());
+  original_green = mln::data::transform(original_rgb8, t_component_green());
+  original_blue  = mln::data::transform(original_rgb8, t_component_blue());
+
+  reduced_red    = mln::data::transform(reduced_rgb8, t_component_red());
+  reduced_green  = mln::data::transform(reduced_rgb8, t_component_green());
+  reduced_blue   = mln::data::transform(reduced_rgb8, t_component_blue());
+
+  minus_red      = (original_red - reduced_red);
+  times_red      = minus_red * minus_red;
+
+  minus_green    = (original_green - reduced_green);
+  times_green    = minus_green * minus_green;
+
+  minus_blue     = (original_blue - reduced_blue);
+  times_blue     = minus_blue * minus_blue;
+
+  error_red      = mln::data::compute(t_mean(), times_red);
+  error_green    = mln::data::compute(t_mean(), times_green);
+  error_blue     = mln::data::compute(t_mean(), times_blue);
+
+//   map_red	 = mln::data::stretch(t_int_u8(), times_red);
+//   map_green	 = mln::data::stretch(t_int_u8(), times_blue);
+//   map_blue	 = mln::data::stretch(t_int_u8(), times_green);
+
+//   histo_red      = mln::data::compute(t_histo(), map_red);
+//   histo_green    = mln::data::compute(t_histo(), map_green);
+//   histo_blue     = mln::data::compute(t_histo(), map_blue);
+
+//   mln::io::plot::save_image_sh(histo_red,  "histo_red.sh");
+//   mln::io::plot::save_image_sh(histo_green,"histo_green.sh");
+//   mln::io::plot::save_image_sh(histo_blue, "histo_blue.sh");
+
+//   mln::io::pgm::save(map_red,  "red.pgm");
+//   mln::io::pgm::save(map_green,"green.pgm");
+//   mln::io::pgm::save(map_blue, "blue.pgm");
+
+  error          = (error_red + error_green + error_blue)/3.0;
+  error          = mln::math::sqrt(error);
+  error          = 20 * log(255/error);
+
+// Le PNSNR semble offrir plus d'espace pour la discrimination
+// Si les images sont identiques ==> PNSNR = +inf
+// Si les images sont très différentes ==> PNSNR = 0
+
+  return error;
+}
+
+
+/// \brief The main entry.
+///
+/// This is the front end for error classification. This is the big
+/// loop where we walk other image data bases. Computation of
+/// automatic thresholds are called from here.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  mln::image1d<float> histo(256);
+  mln::image1d<float> histo_grp[2]; // histo by group
+
+  histo_grp[0].init_(mln::box1d(mln::point1d(0),mln::point1d(255)));
+  histo_grp[1].init_(mln::box1d(mln::point1d(0),mln::point1d(255)));
+
+  mln::data::fill(histo, mln::literal::zero);
+  mln::data::fill(histo_grp[0], mln::literal::zero);
+  mln::data::fill(histo_grp[1], mln::literal::zero);
+
+  t_path original_path[] = {ICDAR_20P_INPUT_IMG_PATH,
+			    AFP_PPM_IMG_PATH};
+
+//   t_path reduced1_path[] = {ICDAR_20P_MGK30_IMG_PATH,
+// 			    AFP_MGK30_IMG_PATH};
+
+//   t_path reduced1_path[] = {ICDAR_20P_MGK20_IMG_PATH,
+// 			    AFP_MGK20_IMG_PATH};
+
+  t_path reduced1_path[] = {ICDAR_20P_MGK10_IMG_PATH,
+			    AFP_MGK10_IMG_PATH};
+
+//   t_path reduced2_path[] = {ICDAR_20P_GMP30_IMG_PATH,
+// 			    AFP_GMP30_IMG_PATH};
+
+//   t_path reduced2_path[] = {ICDAR_20P_GMP20_IMG_PATH,
+// 			    AFP_GMP20_IMG_PATH};
+
+  t_path reduced2_path[] = {ICDAR_20P_GMP10_IMG_PATH,
+			    AFP_GMP10_IMG_PATH};
+
+
+  std::cout << "#!/usr/bin/gnuplot"                       << std::endl;
+  std::cout << "set terminal x11 persist 1"               << std::endl;
+  std::cout << "ERROR"                                    << std::endl;
+  std::cout << "plot '-' using 1 with point notitle,\\"   << std::endl;
+  std::cout << "     '-' using 1 with point notitle"      << std::endl;
+
+  for (int i = 0; i < 2; i++)
+  {
+    if (boost::filesystem::exists(original_path[i]) &&
+	boost::filesystem::exists(reduced1_path[i]) &&
+	boost::filesystem::exists(reduced2_path[i]) &&
+	boost::filesystem::is_directory(original_path[i]) &&
+	boost::filesystem::is_directory(reduced1_path[i]) &&
+	boost::filesystem::is_directory(reduced2_path[i]))
+    {
+      boost::filesystem::system_complete(original_path[i]);
+      const t_iter_path end_iter;
+      float             error1 = 0.0;
+      float             error2 = 0.0;
+      t_path            leaf;
+      t_path            reduced1_file;
+      t_path            reduced2_file;
+
+      for (t_iter_path dir_iter(original_path[i]);end_iter!=dir_iter;++dir_iter)
+      {
+	leaf          = dir_iter->path().leaf();
+	reduced1_file = reduced1_path[i] / leaf;
+	reduced2_file = reduced2_path[i] / leaf;
+
+	error1 = error_test(dir_iter->path().string(), reduced1_file.string());
+	error2 = error_test(dir_iter->path().string(), reduced2_file.string());
+
+ 	float a1 = 1;
+ 	short v1 = (short)mln::math::floor(error2+0.4999);
+ 	mln::opt::at(histo,v1) += a1;
+ 	mln::opt::at(histo_grp[i],v1) += a1;
+
+// 	float a1 = error2 - mln::math::floor(error2);
+// 	float a2 = mln::math::ceil(error2) - error2;
+// 	short v1 = (short)mln::math::floor(error2);
+// 	short v2 = (short)mln::math::ceil(error2);
+// 	mln::opt::at(histo,v1) += a1;
+// 	mln::opt::at(histo,v2) += a2;
+// 	mln::opt::at(histo_grp[i],v1) += a1;
+// 	mln::opt::at(histo_grp[i],v2) += a2;
+
+	std::cout << error1  << " ";
+	std::cout << error2  << " ";
+	std::cout << "# "  << dir_iter->path().leaf() << std::endl;
+      }
+      std::cout << "e"   << std::endl;
+    }
+  }
+
+  mln::io::plot::save_image_sh(histo, "histo.sh");
+  mln::io::plot::save_image_sh(histo_grp[1], "histo_grp1.sh");
+  mln::io::plot::save_image_sh(histo_grp[0], "histo_grp2.sh");
+
+  float threshold  = fisher_analysis(histo);
+  float threshold2 = threshold_histo(avg_histo(histo_grp[1]),
+				     var_histo(histo_grp[1]),
+				     avg_histo(histo_grp[0]),
+				     var_histo(histo_grp[0]));
+  float threshold3 = threshold2_histo(avg_histo(histo_grp[1]),
+				     var_histo(histo_grp[1]),
+				     avg_histo(histo_grp[0]),
+				     var_histo(histo_grp[0]));
+  float threshold4 = min_error(histo_grp[1],histo_grp[0]);
+
+  std::cout << "threshold  = " << threshold   << std::endl;
+  std::cout << "threshold2 = " << threshold2  << std::endl;
+  std::cout << "threshold3 = " << threshold3  << std::endl;
+  std::cout << "threshold4 = " << threshold4  << std::endl;
+  std::cout << "avg_grp1   = " << avg_histo(histo_grp[1])  << std::endl;
+  std::cout << "avg_grp2   = " << avg_histo(histo_grp[0])  << std::endl;
+
+  // compute the classification matrix
+  // for each sub population
+
+  float c00 = cnt_histo(histo_grp[1] | mln::box1d(mln::point1d(0),
+						  mln::point1d(threshold)));
+
+  float c10 = cnt_histo(histo_grp[1] | mln::box1d(mln::point1d(threshold+1),
+						  mln::point1d(255)));
+
+  float c01 = cnt_histo(histo_grp[0] | mln::box1d(mln::point1d(0),
+						  mln::point1d(threshold)));
+
+  float c11 = cnt_histo(histo_grp[0] | mln::box1d(mln::point1d(threshold+1),
+						  mln::point1d(255)));
+
+
+  std::cout << "pop0 = " << cnt_histo(histo_grp[1]) << std::endl;
+  std::cout << "pop1 = " << cnt_histo(histo_grp[0]) << std::endl;
+  std::cout << std::endl;
+
+  std::cout << "c00 = " << c00 << std::endl;
+  std::cout << "c10 = " << c10 << std::endl;
+  std::cout << "c01 = " << c01 << std::endl;
+  std::cout << "c11 = " << c11 << std::endl;
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/histo/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/histo/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/histo/histo.cc b/scribo/sandbox/green/exp/annotating/histo/histo.cc
new file mode 100644
index 0000000..90b18e4
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/histo/histo.cc
@@ -0,0 +1,366 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Build normalized histograms for visualization only.
+///
+/// The goal of this code is to build every normalized histograms of
+/// an image database for visual inspection. It enables the
+/// comparaison of the densities of each image database and the
+/// understanding of the differences in this space.
+
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/arith/minus.hh>
+#include <mln/arith/div.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/convert.hh>
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/literal/zero.hh>
+#include <mln/literal/colors.hh>
+#include <mln/literal/grays.hh>
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+#include <mln/math/sqr.hh>
+#include <mln/math/sqrt.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/fun/v2v/rgb_to_hue_map.hh>
+#include <mln/fun/v2v/rgb_to_saturation_map.hh>
+#include <mln/fun/v2v/rgb_to_value_map.hh>
+#include <mln/fun/v2v/component.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/rgb8.hh>
+
+//============================================================================//
+//                         HISTOGRAM
+//============================================================================//
+
+/// \brief Count the number of pixel in the histogram.
+///
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the number of pixels in the domain.
+///
+/// This is simple counting routine that compute the number of pixels
+/// in the domain of the histogram. For each site, it sums the
+/// frequencies associated to its site.
+template <typename I>
+mln_value(I) cnt_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) cnt = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    cnt += histo(p);
+  }
+
+  return cnt;
+}
+
+/// \brief The computing of the normalized histogram.
+///
+/// \param[in] input        the name of the input image.
+/// \param[in] output_map   the name of the specific map (hue,sat,val,R,G,B).
+/// \param[in] output_histo the name of the output normalized histogram.
+/// \param[in] space        the name of the studied channel (R,G,B,H,S,V).
+///
+/// Compute the normalized histogram in the given channel. First get
+/// the channel from the RGB space or the HSV space and then compute
+/// its normalized histogram. Normalization is done by dividing each
+/// frequency by the sum of frequencies. It's a way to make the
+/// histogram independant from the dimension of the input image and
+/// then to compare different image databases together.
+void histo(const std::string input,
+	   const std::string output_map,
+	   const std::string output_histo,
+	   const char        space)
+
+{
+  typedef mln::value::rgb8                              t_rgb8;
+  typedef mln::fun::v2v::rgb_to_hue_map<8>		t_rgb_to_hue_map;
+  typedef mln::fun::v2v::rgb_to_saturation_map<8>	t_rgb_to_sat_map;
+  typedef mln::fun::v2v::rgb_to_value_map<8>		t_rgb_to_val_map;
+  typedef mln::fun::v2v::component<t_rgb8,0>		t_component_r;
+  typedef mln::fun::v2v::component<t_rgb8,1>		t_component_g;
+  typedef mln::fun::v2v::component<t_rgb8,2>		t_component_b;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  mln::image1d<float>              histo_float;
+  float                            sum;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  switch(space)
+  {
+    case 'h': map = mln::data::transform(input_rgb8, t_rgb_to_hue_map()); break;
+    case 's': map = mln::data::transform(input_rgb8, t_rgb_to_sat_map()); break;
+    case 'v': map = mln::data::transform(input_rgb8, t_rgb_to_val_map()); break;
+    case 'r': map = mln::data::transform(input_rgb8, t_component_r()); break;
+    case 'g': map = mln::data::transform(input_rgb8, t_component_g()); break;
+    case 'b': map = mln::data::transform(input_rgb8, t_component_b()); break;
+    default:  break;// crash
+  }
+
+  histo       = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  sum         = cnt_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+
+  mln::io::pgm::save(map, output_map.c_str());
+  mln::io::plot::save_image_sh(histo_float, output_histo.c_str());
+}
+
+//============================================================================//
+//                         MAIN
+//============================================================================//
+
+
+/// \brief The main entry.
+///
+/// This a front end to compute histogram with boost plumberies. There
+/// is 2 uses cases, the computing over the icdar database and over
+/// the afp database. We force the computing over the six channel
+/// (H,S,V,R,G,B) in order to select the channel the most specific for
+/// a database. It seems that saturation channel and value channel are
+/// the most specific to describe each database. Take care to
+/// coherence of the output directories for each source of images.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+//   t_path full_path[] = {t_path(ICDAR_20P_TEXT_ONLY_IMG_PATH),
+//  			t_path(ICDAR_20P_TEXT_COLOR_IMG_PATH),
+//  			t_path(ICDAR_20P_TEXT_PHOTO_IMG_PATH)};
+
+//  t_path full_path[] = {t_path(AFP_INPUT_IMG_PATH)};
+//   t_path full_path[] = {t_path(AFP_GMP30_IMG_PATH)};
+//   t_path full_path[] = {t_path(AFP_GMP20_IMG_PATH)};
+//   t_path full_path[] = {t_path(AFP_GMP10_IMG_PATH)};
+//   t_path full_path[] = {t_path(AFP_MGK30_IMG_PATH)};
+//   t_path full_path[] = {t_path(AFP_MGK20_IMG_PATH)};
+//   t_path full_path[] = {t_path(AFP_MGK10_IMG_PATH)};
+
+//  t_path full_path[] = {t_path(ICDAR_20P_INPUT_IMG_PATH)};
+//   t_path full_path[] = {t_path(ICDAR_20P_GMP30_IMG_PATH)};
+   t_path full_path[] = {t_path(ICDAR_20P_GMP20_IMG_PATH)};
+//   t_path full_path[] = {t_path(ICDAR_20P_GMP10_IMG_PATH)};
+//   t_path full_path[] = {t_path(ICDAR_20P_MGK30_IMG_PATH)};
+//   t_path full_path[] = {t_path(ICDAR_20P_MGK20_IMG_PATH)};
+//   t_path full_path[] = {t_path(ICDAR_20P_MGK10_IMG_PATH)};
+
+  for (int i = 0; i < 1; ++i)
+  {
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      t_path            directory;
+      t_path            leaf;
+      t_path            output_map;
+      t_path            output_histo;
+
+      std::cerr << "entering "   << full_path[i] << std::endl;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	std::cerr << dir_iter->path() << std::endl;
+
+	leaf         = dir_iter->path().leaf();
+
+//	directory    = ANNOTATING_AFP_R_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_AFP_R_GMP30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_R_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_R_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_AFP_R_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_R_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_R_MGK10_RET_PATH;
+
+//	directory    = ANNOTATING_ICDAR_R_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_R_GMP30_RET_PATH;
+ 	directory    = ANNOTATING_ICDAR_R_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_R_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_R_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_R_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_R_MGK10_RET_PATH;
+	output_histo = change_extension(directory / leaf, ".sh");
+	output_map   = change_extension(directory / leaf, ".pgm");
+
+	histo(dir_iter->path().string(),
+	      output_map.string(),
+	      output_histo.string(),
+	      'r');
+
+//	directory    = ANNOTATING_AFP_G_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_AFP_G_GMP30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_G_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_G_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_AFP_G_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_G_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_G_MGK10_RET_PATH;
+
+//	directory    = ANNOTATING_ICDAR_G_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_G_GMP30_RET_PATH;
+ 	directory    = ANNOTATING_ICDAR_G_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_G_GMP10_RET_PATH;
+//	directory    = ANNOTATING_ICDAR_G_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_G_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_G_MGK10_RET_PATH;
+	output_histo = change_extension(directory / leaf, ".sh");
+	output_map   = change_extension(directory / leaf, ".pgm");
+
+	histo(dir_iter->path().string(),
+	      output_map.string(),
+	      output_histo.string(),
+	      'g');
+
+//	directory    = ANNOTATING_AFP_B_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_AFP_B_GMP30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_B_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_B_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_AFP_B_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_B_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_B_MGK10_RET_PATH;
+
+//	directory    = ANNOTATING_ICDAR_B_INPUT_RET_PATH;
+//	directory    = ANNOTATING_ICDAR_B_GMP30_RET_PATH;
+ 	directory    = ANNOTATING_ICDAR_B_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_B_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_B_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_B_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_B_MGK10_RET_PATH;
+	output_histo = change_extension(directory / leaf, ".sh");
+	output_map   = change_extension(directory / leaf, ".pgm");
+
+	histo(dir_iter->path().string(),
+	      output_map.string(),
+	      output_histo.string(),
+	      'b');
+
+//	directory    = ANNOTATING_AFP_H_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_AFP_H_GMP30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_H_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_H_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_AFP_H_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_H_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_H_MGK10_RET_PATH;
+
+//	directory    = ANNOTATING_ICDAR_H_INPUT_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_H_GMP30_RET_PATH;
+	directory    = ANNOTATING_ICDAR_H_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_H_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_H_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_H_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_H_MGK10_RET_PATH;
+	output_histo = change_extension(directory / leaf, ".sh");
+	output_map   = change_extension(directory / leaf, ".pgm");
+
+	histo(dir_iter->path().string(),
+	      output_map.string(),
+	      output_histo.string(),
+	      'h');
+
+//	directory    = ANNOTATING_AFP_S_INPUT_RET_PATH;
+//	directory    = ANNOTATING_AFP_S_GMP30_RET_PATH;
+//	directory    = ANNOTATING_AFP_S_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_S_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_AFP_S_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_S_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_S_MGK10_RET_PATH;
+
+//	directory    = ANNOTATING_ICDAR_S_INPUT_RET_PATH;
+//	directory    = ANNOTATING_ICDAR_S_GMP30_RET_PATH;
+ 	directory    = ANNOTATING_ICDAR_S_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_S_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_S_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_S_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_S_MGK10_RET_PATH;
+	output_histo = change_extension(directory / leaf, ".sh");
+	output_map   = change_extension(directory / leaf, ".pgm");
+
+	histo(dir_iter->path().string(),
+	      output_map.string(),
+	      output_histo.string(),
+	      's');
+
+//	directory    = ANNOTATING_AFP_V_INPUT_RET_PATH;
+//	directory    = ANNOTATING_AFP_V_GMP30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_V_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_V_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_AFP_V_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_AFP_V_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_AFP_V_MGK10_RET_PATH;
+
+//	directory    = ANNOTATING_ICDAR_V_INPUT_RET_PATH;
+//	directory    = ANNOTATING_ICDAR_V_GMP30_RET_PATH;
+ 	directory    = ANNOTATING_ICDAR_V_GMP20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_V_GMP10_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_V_MGK30_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_V_MGK20_RET_PATH;
+// 	directory    = ANNOTATING_ICDAR_V_MGK10_RET_PATH;
+	output_histo = change_extension(directory / leaf, ".sh");
+	output_map   = change_extension(directory / leaf, ".pgm");
+
+	histo(dir_iter->path().string(),
+	      output_map.string(),
+	      output_histo.string(),
+	      'v');
+      }
+    }
+  }
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/hsv/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/hsv/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/hsv/hsv.cc b/scribo/sandbox/green/exp/annotating/hsv/hsv.cc
new file mode 100644
index 0000000..507d07b
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/hsv/hsv.cc
@@ -0,0 +1,912 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet HSV operator [millet.phd.2008.pdf]
+///
+/// This is the Millet code for moving from RGB space to Hue
+/// one. Formulae are classical, we can find them on the web.
+///
+/// Val = max(R,G,B).
+/// Sat = (max(R,G,B) - min(R,G,B))/max(R,G,B).
+/// IF R = max(R,G,B) THEN Hue = 60 * [(V-B)/(max(R,G,B)-min(R,G,B))].
+/// IF G = max(R,G,B) THEN Hue = 60 * [2 + (B-R)/(max(R,G,B)-min(R,G,B))].
+/// IF B = max(R,G,B) THEN Hue = 60 * [4 + (R-G)/(max(R,G,B)-min(R,G,B))].
+///
+/// This operator try to integrate many processing in one shot, after
+/// HSV transformation.
+
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/arith/minus.hh>
+#include <mln/arith/div.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/convert.hh>
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/literal/zero.hh>
+#include <mln/literal/colors.hh>
+#include <mln/literal/grays.hh>
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+#include <mln/math/sqr.hh>
+#include <mln/math/sqrt.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/fun/v2v/rgb_to_hue_map.hh>
+#include <mln/fun/v2v/rgb_to_saturation_map.hh>
+#include <mln/fun/v2v/rgb_to_value_map.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/rgb8.hh>
+
+//============================================================================//
+//                         HISTOGRAM
+//============================================================================//
+
+/// Histogram
+/// \{
+/// \brief Histogram processing methods.
+///
+/// In this part, we define methods for histogram processing as average,
+/// peak, variance etc ...
+
+
+/// \brief Sum all the bins of the histogram.
+///
+/// \param[in] img the histogram based on image.
+///
+/// \return the sum of the overall bins.
+///
+/// Sum evry bins and return the result.
+template <typename I>
+mln_value(I) count_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) result = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    result += histo(p);
+
+  return result;
+}
+
+/// \brief Sum the whole frequencies.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the number of pixels in the domain.
+///
+/// By summing all the frequencies of the domain, we count in fact the
+/// number of pixels in the image.
+template <typename I>
+mln_value(I) sum_frequency_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) sum = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    sum += histo(p);
+
+  return sum;
+}
+
+/// \brief Count the null frequencies.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the number of null frequencies.
+///
+/// It's a way to access the number of distinct colors in the
+/// histogram by comparing it with the histogram domain.
+template <typename I>
+mln_value(I) count_null_frequency_histo(const mln::Image<I>& histo_)
+{
+  const   I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  mln_value(I) count = mln::literal::zero;
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+    if (0 == histo(p))
+      count++;
+
+  return count;
+}
+
+/// \brief Find the peak of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the bin which contains the greatest value.
+///
+/// Compute the position of the peak of the histogram. To do this, we
+/// view evrey bin and we maintain the maxima of the values and the
+/// position. At the end, we return the position which contains the
+/// greatest value.
+template <typename I>
+mln_coord(mln_site_(I)) peak_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the peak of the histogram
+  mln_value(I)            v_max = mln::opt::at(histo, mln::literal::zero);
+  mln_coord(mln_site_(I)) p_max = mln::literal::zero;
+  mln_piter(I)            p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  return p_max;
+}
+
+/// \brief Find the maximum frequency of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the maximum frequency of the histogram.
+///
+/// Find the peak and return its value, not its position. We use that
+/// function to normalize histograms.
+template <typename I>
+mln_value(I) max_frequency_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the value of the peak from the histogram
+  mln_value(I)            max = mln::opt::at(histo, mln::literal::zero);
+  mln_piter(I)            p(histo.domain());
+
+  for_all(p)
+  {
+    max = mln::math::max(histo(p),max);
+  }
+
+  return max;
+}
+
+/// \brief Find the mean of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the aveerage of the histogram.
+///
+/// Compute the mean.
+template <typename I>
+float mean_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the mean of the histogram
+  float sum   = 0;
+  float mean  = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum  += histo(p);
+    mean += p.ind()*histo(p);
+  }
+
+  mean = mean / sum;
+
+  return mean;
+}
+
+/// \brief Compare the histogram with the equi distributed histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the distance between the equi distributed histogram.
+///
+/// Compute the square euclidian distance between histogram and the
+/// equi distributed histogram. The equi distributed histogram is an
+/// histogram in which each bin has the same frequency (id est 1/256
+/// for instance). The integral equals one for this two
+/// histograms. This is a major contribution test to differentiate
+/// image database.
+template <typename I>
+float cmp_equi_frequency_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the mean of the histogram
+  float sum   = 0;
+  float var   = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum += histo(p);
+    var += mln::math::sqr(histo(p) - (1/256.0));
+  }
+
+  var = var / sum;
+
+  return var;
+}
+
+/// \brief Compute the variance on the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the variance.
+///
+/// Compute the variance by substracting the mean.
+template <typename I>
+float var_histo(const mln::Image<I>& histo_, float mean)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the mean of the histogram
+  float sum   = 0;
+  float var   = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum  += histo(p);
+    var  += mln::math::sqr(p.ind() - mean) * histo(p);
+  }
+
+  var = var / sum;
+
+  return var;
+}
+
+/// \brief Find the mean of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the aveerage of the histogram.
+///
+/// Compute the mean.
+template <typename I>
+float mean_frequency_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the mean of the histogram
+  float sum   = 0;
+  float mean  = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum++;
+    mean += histo(p);
+  }
+
+  mean = mean / sum;
+
+  return mean;
+}
+
+/// \brief Compute the standard deviation on the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the dstandard deviation.
+///
+/// Compute the standard deviation by substracting the mean
+template <typename I>
+float stddev_frequency_histo(const mln::Image<I>& histo_, float mean)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the var of the histogram
+  float sum  = 0;
+  float var  = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum++;
+    var += mln::math::sqr(histo(p)-mean);
+  }
+
+  var = mln::math::sqrt(var / sum);
+
+  return var;
+}
+/// \}
+
+//============================================================================//
+//                         HUE TEST
+//============================================================================//
+
+/// Hue test
+/// \{
+/// \brief Hue test image processing stuff.
+///
+/// In this part, we define every thing that is correlated to the hue analysis.
+
+
+/// \brief Label a grey value.
+///
+/// \param[in] int_u8 the grey value.
+///
+/// \return the reference color for this grey value.
+///
+/// Classify grey value in three class, white, black and medium_gray.
+mln::value::rgb8 label_val(const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (82 > val)
+    result = mln::literal::black;
+  else if (179 > val)
+    result= mln::literal::medium_gray;
+  else
+    result = mln::literal::white;
+
+  return result;
+}
+
+
+/// \brief Label color with orange reference or brown reference.
+///
+/// \param[in] color the rgb8 color.
+/// \param[in] sat the HSV saturation.
+/// \param[in] val the HSV value.
+///
+/// \return the reference color with which it has been associated to.
+mln::value::rgb8 label_orange_or_brown(const mln::value::rgb8   color,
+				       const mln::value::int_u8 sat,
+				       const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (mln::literal::orange == color)
+  {
+    unsigned dist_orange = mln::math::abs(sat - 184)
+      + mln::math::abs(val - 65);
+
+    unsigned dist_brown  = mln::math::abs(sat - 255)
+      + mln::math::abs(val - 125);
+
+    if (dist_orange < dist_brown)
+      result = mln::literal::orange;
+    else
+      result = mln::literal::brown;
+  }
+  else
+    result = color;
+
+  return result;
+}
+
+
+/// \brief Label between yellow and green color.
+///
+/// \param[in] color the rgb8 color.
+/// \param[in] val the HSV value.
+///
+/// \return the reference color associated to that color.
+mln::value::rgb8 label_yellow_or_green(const mln::value::rgb8   color,
+				       const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (mln::literal::yellow == color)
+  {
+    // Is it green or yellow ?
+    if (80 > val)
+      result = mln::literal::green;
+    else
+      result = mln::literal::yellow;
+  }
+  else
+    return color;
+
+  return result;
+}
+
+
+/// \brief Label hue color.
+///
+/// \param[in] hue the HSV hue canal for a pixel.
+///
+/// \return a hue segmentation of the hue wheel.
+///
+/// The old classification given by Millet is commented. Mine is ready
+/// to use.  We need to change reference colors to make the
+/// primary colors, the secondary ones, etc...
+mln::value::rgb8 label_hue(const mln::value::int_u8 hue)
+{
+  mln::value::rgb8 result;
+
+
+  if (10 > hue)
+    result = mln::literal::red;
+  else if (32 > hue)
+    result = mln::literal::orange;
+  else if (53 > hue)
+    result = mln::literal::yellow;
+  else if (74 > hue)
+    result = mln::literal::green; // chartreuse
+  else if (96 > hue)
+    result = mln::literal::green;
+  else if (116 > hue)
+    result = mln::literal::green;// turquoise, aigue-marine
+  else if (138 > hue)
+    result = mln::literal::green; // cyan
+  else if (159 > hue)
+    result = mln::literal::blue; // azur
+  else if (181 > hue)
+    result = mln::literal::blue;
+  else if (202 > hue)
+    result = mln::literal::violet;
+  else if (223 > hue)
+    result = mln::literal::pink;
+  else // if (244 > hue)
+    result = mln::literal::red;
+
+  return result;
+}
+
+/// \brief The hue test.
+///
+/// \param[in] input the name of the input image.
+/// \param[in] output the name of the histogram to output.
+/// \param[in] tmp the name of the hue map to output.
+/// \param[in] threshold the limit to compute the histogram contribution.
+///
+/// \return the proportion of pixels that pass the test.
+///
+/// This is an augmented test. We first normalized the histogram to
+/// obtain a discrete distribution. Then we compute the mean (or the
+/// peak, i don't really know what is the best) and we look at the
+/// proportion of the pixels around the mean or the peak. This
+/// proportion tell us how histogram distribution is concentrated
+/// around the modal value. If a hue modal value exist, we can say
+/// that the image is colorized.
+float hue_test(const std::string input,
+	       const std::string output,
+	       const std::string tmp,
+	       const short threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_hue_map<8>   t_rgb_to_hue_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  mln::image1d<float>              histo_float;
+  float                            cnt1;
+  float                            cnt2;
+  float                            prop;
+  short                            peak;
+  mln::value::rgb8                 color;
+  float                            sum;
+  mln::point1d                     inf;
+  mln::point1d                     sup;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map         = mln::data::transform(input_rgb8, t_rgb_to_hue_map());
+  histo       = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  sum         = sum_frequency_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+  peak        = mean_histo(histo); //peak_histo(histo);
+  color       = label_hue(peak);
+  inf         = mln::point1d(mln::math::max(0,   peak-threshold));
+  sup         = mln::point1d(mln::math::min(255, peak+threshold));
+  cnt1        = count_histo(histo_float|mln::box1d(inf,sup));
+  cnt2        = count_histo(histo_float);
+  prop        = ((100.0 * cnt1) / cnt2);
+
+  mln::io::plot::save_image_sh(histo_float, output.c_str());
+  mln::io::pgm::save(map, tmp.c_str());
+//  std::cout << "peak  = " << peak  << std::endl;
+//  std::cout << "color = " << color << std::endl;
+
+  return prop;
+}
+/// \}
+
+//============================================================================//
+//                         SATURATION TEST
+//============================================================================//
+
+/// Saturation test
+/// \{
+/// \brief Saturation test image processing stuff.
+///
+/// In this part, we define every thing that is correlated to the
+/// saturation analysis.
+
+
+/// \brief The saturation test.
+///
+/// \param[in] input the name of the input image.
+/// \param[in] output the name of the histogram to output.
+/// \param[in] tmp the name of the hue map to output.
+/// \param[in] threshold for deciding which is low saturation or not.
+///
+/// \return the proportion of pixels which pass the test.
+///
+/// This is the augmented test, we normalized the histogram and then
+/// we count the proportion of the histogram below the threshold.
+float saturation_test(const std::string input,
+		      const std::string output,
+		      const std::string tmp,
+		      const short threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_saturation_map<8>    t_rgb_to_saturation_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  mln::image1d<float>              histo_float;
+  float                            cnt1;
+  float                            cnt2;
+  float                            sum;
+  float                            prop;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map         = mln::data::transform(input_rgb8, t_rgb_to_saturation_map());
+  histo       = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  sum         = sum_frequency_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+  cnt1        = count_histo(histo_float | mln::box1d(mln::point1d(0),
+						     mln::point1d(threshold)));
+  cnt2        = count_histo(histo_float);
+  prop        = ((100.0 * cnt1) / cnt2);
+
+  mln::io::plot::save_image_sh(histo_float, output.c_str());
+  mln::io::pgm::save(map, tmp.c_str());
+
+  return prop;
+}
+/// \}
+
+//============================================================================//
+//                         VALUE TEST
+//============================================================================//
+
+/// Value test
+/// \{
+/// \brief Value test image processing stuff.
+///
+/// In this part, we define every thing that is correlated to the
+/// value analysis.
+
+
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+/// \brief The stddev3 is an internal stuff.
+///
+/// \param[in] histo_ the image which represents the histogram.
+/// \param[in] peak   the position of the histogram peak.
+///
+/// \return simple computing of deviation.
+///
+/// This is an internal stuff. It splits the computing for easy
+/// reusing practice. Sum the R contribution.
+template <typename I>
+float stddev3(const mln::Image<I>& histo_, unsigned peak)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Compute stddev
+
+  float stddev = 0.0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    stddev  += r((short)peak, mln::opt::at(histo,peak), p.ind(), histo(p));
+  }
+
+  return stddev;
+}
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] image the input image to analyze.
+///
+/// \return the deviation.
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it). The test is generalized by
+/// making constants as parameters.
+template <typename I>
+float stddev2(const mln::Image<I>& histo_, unsigned peak, unsigned limit)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float ret        = 0.0;
+
+  // A transformer avec des iterators
+
+  if (250 > peak)
+    stddev_up  = stddev3(histo |mln::box1d(mln::point1d(peak+1),
+					   mln::point1d(peak+limit)), peak);
+
+  if (5 < peak)
+    stddev_low = stddev3(histo |mln::box1d(mln::point1d(peak-limit),
+					   mln::point1d(peak-1)), peak);
+
+  ret = (250 < peak)? stddev_low : (5 > peak)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  return ret;
+}
+
+
+/// \brief This is the Value test.
+///
+/// \param[in] input the name of the input image.
+/// \param[in] output the name of result histogram.
+/// \param[in] tmp the name of the output value (HSV) map.
+/// \param[in] threshold the range around the peak where R is computed.
+///
+/// \return the proportion of pixels that pass the test.
+///
+/// This is the augmented version of the Millet test. This code is not
+/// stable.  There is a lots of tests on. The Millet test is computed
+/// with stddev2 call.  We test simple counting around the pic as we
+/// do for other tests but it's not really insteresting. The prop4 is
+/// the best for me. We test the difference between the distribution and the
+/// equi-distribution.
+float value_test(const std::string input,
+		 const std::string output,
+		 const std::string tmp,
+		 const short threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_value_map<8>   t_rgb_to_value_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  mln::image1d<float>              histo_float;
+  float                            cnt1;
+  float                            cnt2;
+  float                            prop;
+  float                            sum;
+  float                            prop4;
+  short                            peak;
+  mln::point1d                     inf;
+  mln::point1d                     sup;
+
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map         = mln::data::transform(input_rgb8, t_rgb_to_value_map());
+  histo       = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  sum         = sum_frequency_histo(histo);
+  histo_float = mln::data::convert(float(), histo) / sum;
+  prop4       = cmp_equi_frequency_histo(histo_float);
+  peak        = peak_histo(histo); // mean_histo(histo);
+  //prop        = stddev2(histo, peak, threshold);
+  inf         = mln::point1d(mln::math::max(0,   peak-threshold));
+  sup         = mln::point1d(mln::math::min(255, peak+threshold));
+  cnt1        = count_histo(histo_float|mln::box1d(inf,sup));
+  cnt2        = count_histo(histo_float);
+  prop        = ((100.0 * cnt1) / cnt2);
+
+  std::cerr << "peak = " << peak << std::endl;
+  std::cerr << "inf  = " << inf  << std::endl;
+  std::cerr << "sup  = " << sup  << std::endl;
+  std::cerr << "cnt1 = " << cnt1 << std::endl;
+  std::cerr << "cnt2 = " << cnt2 << std::endl;
+  std::cerr << "prop = " << prop << std::endl;
+  std::cerr << "prop4= " << prop4 << std::endl;
+
+  mln::io::plot::save_image_sh(histo_float, output.c_str());
+  mln::io::pgm::save(map, tmp.c_str());
+
+  return prop;
+}
+
+//============================================================================//
+//                         MAIN
+//============================================================================//
+
+
+/// \brief The main entry.
+///
+/// This is a front end for launching image processing test. We deal
+/// with boost library to walk on image database directories. Nothing
+/// very interesting here, it is a lot of plumberies.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+//   t_path full_path[] = {t_path(ICDAR_20P_TEXT_ONLY_IMG_PATH),
+//  			t_path(ICDAR_20P_TEXT_COLOR_IMG_PATH),
+//  			t_path(ICDAR_20P_TEXT_PHOTO_IMG_PATH)};
+
+  t_path full_path[] = {t_path(AFP_PPM_IMG_PATH)};
+
+  std::cout << "#!/usr/bin/gnuplot"                       << std::endl;
+  std::cout << "set terminal x11 persist 1"               << std::endl;
+  std::cout << "#HUE - SATURATION - VALUE"                << std::endl;
+  std::cout << "plot '-' using 1:2 with point notitle,\\" << std::endl;
+  std::cout << "     '-' using 1:2 with point notitle,\\" << std::endl;
+  std::cout << "     '-' using 1:2 with point notitle"    << std::endl;
+
+  for (int i = 0; i < 1; ++i)
+  {
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float             prop = 0.0;
+      t_path            directory;
+      t_path            leaf;
+      t_path            output;
+      t_path            tmp;
+
+      std::cerr << "entering "   << full_path[i] << std::endl;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	std::cerr << dir_iter->path() << std::endl;
+	// concatenation de chaine
+//	directory = (ANNOTATING_ICDAR_H_INPUT_RET_PATH);
+	directory = (ANNOTATING_AFP_H_INPUT_RET_PATH);
+	leaf      = dir_iter->path().leaf();
+	output    = change_extension(directory / leaf, ".sh");
+	tmp       = change_extension(directory / leaf, ".pgm");
+
+	prop = hue_test(dir_iter->path().string(),
+			output.string(),
+			tmp.string(),
+			20);
+
+	std::cout << prop << " ";
+
+//	directory = (ANNOTATING_ICDAR_S_INPUT_RET_PATH);
+	directory = (ANNOTATING_AFP_S_INPUT_RET_PATH);
+	leaf      = dir_iter->path().leaf();
+	output    = change_extension(directory / leaf, ".sh");
+	tmp       = change_extension(directory / leaf, ".pgm");
+
+	prop = saturation_test(dir_iter->path().string(),
+			       output.string(),
+			       tmp.string(),
+			       25);
+
+	std::cout << prop << " ";
+
+//	directory = (ANNOTATING_ICDAR_V_INPUT_RET_PATH);
+	directory = (ANNOTATING_AFP_V_INPUT_RET_PATH);
+	leaf      = dir_iter->path().leaf();
+	output    = change_extension(directory / leaf, ".sh");
+	tmp       = change_extension(directory / leaf, ".pgm");
+
+	prop = value_test(dir_iter->path().string(),
+			  output.string(),
+			  tmp.string(),
+			  15);
+
+	std::cout << prop  << " ";
+	std::cout << "# "  << dir_iter->path().leaf() << std::endl;
+      }
+      std::cout << "e"   << std::endl;
+    }
+  }
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/hue/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/hue/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/hue/hue.cc b/scribo/sandbox/green/exp/annotating/hue/hue.cc
new file mode 100644
index 0000000..6e1195c
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/hue/hue.cc
@@ -0,0 +1,402 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet hue operator [millet.phd.2008.pdf]
+///
+/// This is the Millet code for moving from RGB space to Hue
+/// one. Formulae are classical, we can find them on the web.
+///
+/// Val = max(R,G,B).
+/// Sat = (max(R,G,B) - min(R,G,B))/max(R,G,B).
+/// IF R = max(R,G,B) THEN Hue = 60 * [(V-B)/(max(R,G,B)-min(R,G,B))].
+/// IF G = max(R,G,B) THEN Hue = 60 * [2 + (B-R)/(max(R,G,B)-min(R,G,B))].
+/// IF B = max(R,G,B) THEN Hue = 60 * [4 + (R-G)/(max(R,G,B)-min(R,G,B))].
+
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/literal/colors.hh>
+#include <mln/literal/grays.hh>
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/fun/v2v/rgb_to_hue_map.hh>
+#include <mln/value/rgb8.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+
+
+/// \brief Label a grey value.
+///
+/// \param[in] int_u8 the grey value.
+///
+/// \return the reference color for this grey value.
+///
+/// Classify grey value in three class, white, black and medium_gray.
+mln::value::rgb8 label_val(const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (82 > val)
+    result = mln::literal::black;
+  else if (179 > val)
+    result= mln::literal::medium_gray;
+  else
+    result = mln::literal::white;
+
+  return result;
+}
+
+
+/// \brief Label color with orange reference or brown reference.
+///
+/// \param[in] color the rgb8 color.
+/// \param[in] sat the HSV saturation.
+/// \param[in] val the HSV value.
+///
+/// \return the reference color with which it has been associated to.
+mln::value::rgb8 label_orange_or_brown(const mln::value::rgb8   color,
+				       const mln::value::int_u8 sat,
+				       const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (mln::literal::orange == color)
+  {
+    unsigned dist_orange = mln::math::abs(sat - 184)
+      + mln::math::abs(val - 65);
+
+    unsigned dist_brown  = mln::math::abs(sat - 255)
+      + mln::math::abs(val - 125);
+
+    if (dist_orange < dist_brown)
+      result = mln::literal::orange;
+    else
+      result = mln::literal::brown;
+  }
+  else
+    result = color;
+
+  return result;
+}
+
+/// \brief Label between yellow and green color.
+///
+/// \param[in] color the rgb8 color.
+/// \param[in] val the HSV value.
+///
+/// \return the reference color associated to that color.
+mln::value::rgb8 label_yellow_or_green(const mln::value::rgb8   color,
+				       const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (mln::literal::yellow == color)
+  {
+    // Is it green or yellow ?
+    if (80 > val)
+      result = mln::literal::green;
+    else
+      result = mln::literal::yellow;
+  }
+  else
+    return color;
+
+  return result;
+}
+
+
+/// \brief Label hue color.
+///
+/// \param[in] hue the HSV hue canal for a pixel.
+///
+/// \return a hue segmentation of the hue wheel.
+///
+/// The old classification given by Millet is commented. Mine is ready
+/// to use.  We need to change reference colors to make the
+/// primary colors, the secondary ones, etc...
+mln::value::rgb8 label_hue(const mln::value::int_u8 hue)
+{
+  mln::value::rgb8 result;
+
+
+  if (10 > hue)
+    result = mln::literal::red;
+  else if (32 > hue)
+    result = mln::literal::orange;
+  else if (53 > hue)
+    result = mln::literal::yellow;
+  else if (74 > hue)
+    result = mln::literal::green; // chartreuse
+  else if (96 > hue)
+    result = mln::literal::green;
+  else if (116 > hue)
+    result = mln::literal::green;// turquoise, aigue-marine
+  else if (138 > hue)
+    result = mln::literal::green; // cyan
+  else if (159 > hue)
+    result = mln::literal::blue; // azur
+  else if (181 > hue)
+    result = mln::literal::blue;
+  else if (202 > hue)
+    result = mln::literal::violet;
+  else if (223 > hue)
+    result = mln::literal::pink;
+  else // if (244 > hue)
+    result = mln::literal::red;
+
+
+//   if (14 > hue)
+//     result = mln::literal::red;
+//   else if (29 > hue)
+//     result = mln::literal::orange;
+//   else if (45 > hue)
+//     result = mln::literal::yellow;
+//   else if (113 > hue)
+//     result = mln::literal::green;
+//   else if (149 > hue)
+//     result = mln::literal::cyan;
+//   else if (205 > hue)
+//     result = mln::literal::blue;
+//   else if (235 > hue)
+//     result = mln::literal::violet;
+//   else if (242 > hue)
+//     result = mln::literal::pink;
+//   else
+//     result = mln::literal::red;
+
+  return result;
+}
+
+
+/// \brief Sum all the bins of the histogram.
+///
+/// \param[in] img the histogram based on image.
+///
+/// \return the sum of the overall bins.
+///
+/// Sum evry bins and return the result.
+template <typename I>
+unsigned count_histo(const mln::Image<I>& img_)
+{
+  const   I& img = exact(img_);
+
+  mln_precondition(img.is_valid());
+
+  unsigned     result = 0;
+
+  mln_piter(I) p(img.domain());
+
+  for_all(p)
+    result += img(p);
+
+  return result;
+}
+
+/// \brief Find the peak of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the bin which contains the greatest value.
+///
+/// Compute the position of the peak of the histogram. To do this, we
+/// view evrey bin and we maintain the maxima of the values and the
+/// position. At the end, we return the position which contains the
+/// greatest value.
+template <typename I>
+unsigned peak_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  return p_max;
+}
+
+/// \brief Compute the average of the histogram.
+///
+/// \param[in] histo_ the histogram.
+///
+/// \return the average of the histogram.
+///
+/// Compute the mean of the histogram by summing the values of each
+/// bin ponderated by its frequency. The result is divided by the sum
+/// of the frequencies.
+template <typename I>
+unsigned mean_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the mean of the histogram
+  float sum   = 0;
+  float mean  = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum  += histo(p);
+    mean += p.ind()*histo(p);
+  }
+
+  mean = mean / sum;
+
+  return mean;
+}
+
+
+/// \brief The hue test.
+///
+/// \param[in] input the name of the input image.
+/// \param[in] output the name of the histogram to output.
+/// \param[in] tmp the name of the hue map to output.
+///
+/// \return the proportion of pixels that pass the test.
+///
+/// Load the input image, transform it to get the hue_map and compute
+/// the histogram. Then count the number of pixels that are between
+/// peak-threshold and peak +threshold. Print the peak and the
+/// percentage of pixels around the pic.
+float hue_test(const std::string input,
+	       const std::string output,
+	       const std::string tmp,
+	       const unsigned threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_hue_map<8>   t_rgb_to_hue_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  unsigned                         cnt1;
+  unsigned                         cnt2;
+  float                            prop;
+  unsigned                         peak;
+  mln::value::rgb8                 color;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map    = mln::data::transform(input_rgb8, t_rgb_to_hue_map());
+  histo  = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  peak   = mean_histo(histo); //peak_histo(histo);
+  color  = label_hue(peak);
+  cnt1   = count_histo(histo | mln::box1d(mln::point1d(peak-threshold),
+					  mln::point1d(peak+threshold)));
+  cnt2   = mln::geom::nsites(input_rgb8);
+  prop   = ((100.0 * cnt1) / cnt2);
+
+  mln::io::plot::save_image_sh(histo, output.c_str());
+  mln::io::pgm::save(map, tmp.c_str());
+  std::cout << "peak  = " << peak  << std::endl;
+  std::cout << "color = " << color << std::endl;
+
+  return prop;
+}
+
+
+/// \brief Main entry.
+///
+/// It is a front end which managing the iteration through one image
+/// data base with boost. Save hue map and hue histogram.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ICDAR_20P_PPM_IMG_PATH)};
+
+  for (int i = 0; i < 1; ++i)
+  {
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float             prop = 0.0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	// concatenation de chaine
+	t_path directory(ANNOTATING_ICDAR_RET_PATH);
+	t_path leaf   = dir_iter->path().leaf();
+	t_path output = change_extension(directory / leaf, ".sh");
+	t_path tmp    = change_extension(directory / leaf, ".pgm");
+
+	prop = hue_test(dir_iter->path().string(),
+			output.string(),
+			tmp.string(),
+			20);
+
+	std::cout << output << " : " << prop << std::endl;
+	std::cerr << output << " : " << prop << std::endl;
+      }
+    }
+  }
+
+  return 0;
+}
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-color.txt b/scribo/sandbox/green/exp/annotating/hue/text-color.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-color.txt
copy to scribo/sandbox/green/exp/annotating/hue/text-color.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-img.txt b/scribo/sandbox/green/exp/annotating/hue/text-img.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-img.txt
copy to scribo/sandbox/green/exp/annotating/hue/text-img.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-only.txt b/scribo/sandbox/green/exp/annotating/hue/text-only.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-only.txt
copy to scribo/sandbox/green/exp/annotating/hue/text-only.txt
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/nb_color/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/nb_color/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/nb_color/nb_color.cc b/scribo/sandbox/green/exp/annotating/nb_color/nb_color.cc
new file mode 100644
index 0000000..2331c61
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/nb_color/nb_color.cc
@@ -0,0 +1,171 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Compute the number of colors in an image.
+///
+/// Build histogram of colors and count the bins different from zero.
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/math/count.hh>
+#include <mln/accu/stat/histo3d_rgb.hh>
+
+#include <mln/binarization/threshold.hh>
+
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+// #include <mln/morpho/opening/volume.hh>
+
+#include <mln/io/ppm/load.hh>
+
+#include <mln/pw/value.hh>
+#include <mln/pw/cst.hh>
+
+#include <mln/util/timer.hh>
+
+#include <mln/value/rgb8.hh>
+//#include <mln/value/rgb.hh>
+
+
+/// \brief Count the colors.
+///
+/// \param[in] image the name of the image to process.
+///
+/// \return the number of colors.
+///
+/// Count the color by building histogram. Strange filtering is
+/// done. We use also the technique of regional maxima in
+/// comment. Quantification is done to reduce the size of the
+/// histogram as well.
+
+// n < 8, n is the degree of quantification
+template <unsigned n>
+unsigned count_image_color(const std::string& image)
+{
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::rgb<n>                          t_rgbn;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_rgbn>                        t_image2d_rgbn;
+  typedef mln::image3d<unsigned>                      t_histo3d;
+  typedef mln::image3d<bool>                          t_histo3d_bool;
+  typedef mln::fun::v2v::rgb8_to_rgbn<n>              t_rgb8_to_rgbn;
+  typedef mln::accu::meta::stat::histo3d_rgb          t_histo3d_fun;
+  typedef mln::accu::meta::math::count                t_count_fun;
+
+  t_image2d_rgb8                                      input_rgb8;
+  t_image2d_rgbn                                      input_rgbn;
+  t_image2d_rgbn                                      output_rgbn;
+  t_histo3d                                           histo;
+//   t_histo3d                                           opened;
+  t_histo3d_bool                                      filtered;
+
+  mln::io::ppm::load(input_rgb8, image.c_str());
+
+  unsigned nb_pixel   = input_rgb8.ncols() * input_rgb8.nrows();
+  unsigned min_volume = (unsigned)(nb_pixel * 0.0001);
+  unsigned nb_color   = 0;
+
+//  input_rgbn = mln::data::transform(input_rgb8, t_rgb8_to_rgbn());
+  histo      = mln::data::compute(t_histo3d_fun(), input_rgb8);
+//   opened     = mln::morpho::opening::volume(histo, mln::c6(), min_volume);
+  filtered   = mln::binarization::threshold(histo, min_volume);
+  nb_color   = mln::data::compute(t_count_fun(),
+				 (filtered|(mln::pw::value(filtered)!=0)).rw());
+
+  return nb_color;
+}
+
+
+/// \brief Main entry.
+///
+/// The main routine makes the base driver job. It looks after many
+/// directories and lists every images in it. We use the boost library
+/// to do it. Statistics are computed on the number of colors. The
+/// first idea was to answer the question is this descriptor allow to
+/// recognize a specific base.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  //typedef boost::filesystem::initial_path<t_path()> t_init_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ANNOTATING_1_BILL_IMG_PATH),
+			t_path(ANNOTATING_1_FAX_IMG_PATH),
+			t_path(ANNOTATING_1_HANDWRITTEN_IMG_PATH),
+			t_path(ANNOTATING_1_LOGO_IMG_PATH),
+			t_path(ANNOTATING_1_MAP_IMG_PATH),
+			t_path(ANNOTATING_1_PHOTO_IMG_PATH),
+			t_path(ANNOTATING_1_SCREENSHOT_IMG_PATH),
+			t_path(ANNOTATING_1_SLIDE_IMG_PATH),
+			t_path(ANNOTATING_1_TYPED_IMG_PATH)};
+
+  for (int i = 0; i < 9; ++i)
+  {
+    std::cerr << "entering "   << full_path[i] << std::endl;
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      unsigned count = 0;
+      unsigned sum1  = 0;
+      unsigned sum2  = 0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	unsigned val = count_image_color<8>(dir_iter->path().string());
+
+	++count;
+	sum1 += val;
+	sum2 += val*val;
+
+	std::cout << dir_iter->path().string() << " => " << val << std::endl;
+      }
+
+      float mean = sum1 / count;
+      float var  = ((float)sum2 / count) - (mean * mean);
+
+      std::cout << "mean : " << mean << std::endl;
+      std::cout << "var  : " << var  << std::endl;
+    }
+  }
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/saturation/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/saturation/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/saturation/saturation.cc b/scribo/sandbox/green/exp/annotating/saturation/saturation.cc
new file mode 100644
index 0000000..b5834a1
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/saturation/saturation.cc
@@ -0,0 +1,175 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet saturation operator [millet.phd.2008.pdf]
+///
+/// This is the Millet code for moving from RGB space to Sat
+/// one. Formulae are classical, we can find them on the web.
+///
+/// Val = max(R,G,B).
+/// Sat = (max(R,G,B) - min(R,G,B))/max(R,G,B).
+/// IF R = max(R,G,B) THEN Hue = 60 * [(V-B)/(max(R,G,B)-min(R,G,B))].
+/// IF G = max(R,G,B) THEN Hue = 60 * [2 + (B-R)/(max(R,G,B)-min(R,G,B))].
+/// IF B = max(R,G,B) THEN Hue = 60 * [4 + (R-G)/(max(R,G,B)-min(R,G,B))].
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/fun/v2v/rgb_to_saturation_map.hh>
+
+#include <mln/io/ppm/load.hh>
+//#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/rgb8.hh>
+
+/// \brief Sum all the bins of the histogram.
+///
+/// \param[in] img the histogram based on image.
+///
+/// \return the sum of the overall bins.
+///
+/// Sum evry bins and return the result.
+template <typename I>
+unsigned count_histo(const mln::Image<I>& img_)
+{
+  const   I& img = exact(img_);
+
+  mln_precondition(img.is_valid());
+
+  unsigned     result = 0;
+
+  mln_piter(I) p(img.domain());
+
+  for_all(p)
+    result += img(p);
+
+  return result;
+}
+
+/// \brief The saturation test.
+///
+/// \param[in] input the name of the input image.
+/// \param[in] output the name of the histogram to output.
+/// \param[in] threshold for deciding which is low saturation or not.
+///
+/// \return the proportion of pixels that pass the test.
+///
+/// Load the input image, transform it to get the saturation_map and compute
+/// the histogram. Then count the number of pixels that are under the threshold.
+/// Then return the proportion of pixels.
+float saturation_test(const std::string input,
+		      const std::string output,
+//		      const std::string tmp,
+		      const unsigned threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_saturation_map<8>   t_rgb_to_saturation_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  unsigned                         cnt1;
+  unsigned                         cnt2;
+  float                            prop;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map    = mln::data::transform(input_rgb8, t_rgb_to_saturation_map());
+  histo  = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  cnt1   = count_histo(histo | mln::box1d(mln::point1d(0),
+					  mln::point1d(threshold)));
+  cnt2   = mln::geom::nsites(input_rgb8);
+  prop   = ((100.0 * cnt1) / cnt2);
+
+  mln::io::plot::save_image_sh(histo, output.c_str());
+//  mln::io::pgm::save(map, tmp.c_str());
+
+  return prop;
+}
+
+
+/// \brief the main entry.
+///
+/// This is a front end for image processing routine. It manages the
+/// calling of every image in the database.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ICDAR_20P_PPM_IMG_PATH)};
+
+  for (int i = 0; i < 1; ++i)
+  {
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float             prop = 0.0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	// concatenation de chaine
+	t_path directory(ANNOTATING_ICDAR_RET_PATH);
+	t_path leaf   = dir_iter->path().leaf();
+	t_path output = change_extension(directory / leaf, ".sh");
+	t_path tmp    = change_extension(directory / leaf, ".pgm");
+
+	prop = saturation_test(dir_iter->path().string(),
+			       output.string(),
+//			       tmp.string(),
+			       25);
+
+	std::cout << output << " : " << prop << std::endl;
+	std::cerr << output << " : " << prop << std::endl;
+      }
+    }
+  }
+
+  return 0;
+}
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-color.txt b/scribo/sandbox/green/exp/annotating/saturation/text-color.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-color.txt
copy to scribo/sandbox/green/exp/annotating/saturation/text-color.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-img.txt b/scribo/sandbox/green/exp/annotating/saturation/text-img.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-img.txt
copy to scribo/sandbox/green/exp/annotating/saturation/text-img.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-only.txt b/scribo/sandbox/green/exp/annotating/saturation/text-only.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-only.txt
copy to scribo/sandbox/green/exp/annotating/saturation/text-only.txt
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/stddev_color/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/stddev_color/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/stddev_color/stddev_color.cc b/scribo/sandbox/green/exp/annotating/stddev_color/stddev_color.cc
new file mode 100644
index 0000000..365a9c3
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/stddev_color/stddev_color.cc
@@ -0,0 +1,216 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet clipart detection [millet.phd.2008.pdf]
+///
+/// The aim of this descriptor is to recognize clipart. To do this, we
+/// assume that clipart have their histogram concentrated around their
+/// mode. This is particularly true if the clipart is design by hand,
+/// because a very small number of grey tones or colors are used to
+/// draw it. But sometimes, computer assists their creation and we can
+/// find some continuous set of tones and this artefact create noise
+/// for the detection technique describe bellow.
+
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/max_site.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/fill.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb8_to_int_u8.hh>
+
+#include <mln/io/ppm/load.hh>
+
+#include <mln/math/sqr.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u.hh>
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] image the input image to analyze.
+///
+/// \return the deviation.
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it).
+float stddev_color(const std::string& image)
+{
+  typedef mln::point1d                                t_point1d;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+  typedef mln::image1d<unsigned>                      t_histo1d;
+  typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+  typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+  typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+  t_image2d_rgb8                                      input_rgb8;
+  t_image2d_int_u8                                    input_int_u8;
+  t_histo1d                                           histo;
+  t_point1d                                           max_site;
+
+  mln::io::ppm::load(input_rgb8, image.c_str());
+  input_int_u8 = mln::data::transform(input_rgb8, t_rgb8_to_int_u8());
+  histo        = mln::data::compute(t_histo1d_fun(), input_int_u8);
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter_(t_histo1d) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  // Compute the specific stddev
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float stddev     = 0.0;
+
+  if (250 > p_max)
+    for (short i = p_max+1; i < p_max+6; ++i)
+      stddev_up += r(p_max, mln::opt::at(histo,p_max),
+		     i, mln::opt::at(histo,i));
+
+  if (5 < p_max)
+    for (short i = p_max-1; i > p_max-6; --i)
+      stddev_low += r(p_max, mln::opt::at(histo,p_max),
+		      i, mln::opt::at(histo,i));
+
+  stddev = (250 < p_max)? stddev_low : (5 > p_max)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  return stddev;
+}
+
+
+/// \brief Main entry.
+///
+/// Front end for image processing. It is in the main routine where we
+/// go through the image data base (using boost to do it).
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ANNOTATING_1_BILL_IMG_PATH),
+			t_path(ANNOTATING_1_FAX_IMG_PATH),
+			t_path(ANNOTATING_1_HANDWRITTEN_IMG_PATH),
+			t_path(ANNOTATING_1_LOGO_IMG_PATH),
+			t_path(ANNOTATING_1_MAP_IMG_PATH),
+			t_path(ANNOTATING_1_PHOTO_IMG_PATH),
+			t_path(ANNOTATING_1_SCREENSHOT_IMG_PATH),
+			t_path(ANNOTATING_1_SLIDE_IMG_PATH),
+			t_path(ANNOTATING_1_TYPED_IMG_PATH)};
+
+  for (int i = 0; i < 9; ++i)
+  {
+    std::cerr << "entering "   << full_path[i] << std::endl;
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float count = 0;
+      float sum1  = 0;
+      float sum2  = 0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	float val = stddev_color(dir_iter->path().string());
+
+	++count;
+	sum1 += val;
+	sum2 += val*val;
+
+	std::cout << dir_iter->path().string() << " => " << val << std::endl;
+      }
+
+      float mean = sum1 / count;
+      float var  = ((float)sum2 / count) - (mean * mean);
+
+      std::cout << "mean : " << mean << std::endl;
+      std::cout << "var  : " << var  << std::endl;
+    }
+  }
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/stddev_color_16/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/stddev_color_16/Makefile.am
diff --git a/scribo/sandbox/green/exp/annotating/stddev_color_16/stddev_color_16.cc b/scribo/sandbox/green/exp/annotating/stddev_color_16/stddev_color_16.cc
new file mode 100644
index 0000000..fc55547
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/stddev_color_16/stddev_color_16.cc
@@ -0,0 +1,277 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet clipart detection [millet.phd.2008.pdf]
+///
+/// The aim of this descriptor is to recognize clipart. To do this, we
+/// assume that clipart have their histogram concentrated around their
+/// mode. This is particularly true if the clipart is design by hand,
+/// because a very small number of grey tones or colors are used to
+/// draw it. But sometimes, computer assists their creation and we can
+/// find some continuous set of tones and this artefact create noise
+/// for the detection technique describe bellow. When photographies
+/// has some large uniform border, the detection can fail. To improve
+/// the method, Millet decide to subdivise the image in 16 sub images
+/// on which it applies the test.
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/max_site.hh>
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+
+#include <mln/debug/println.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/fill.hh>
+#include <mln/data/transform.hh>
+#include <mln/data/paste.hh>
+
+#include <mln/fun/v2v/rgb8_to_int_u8.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/math/sqr.hh>
+#include <mln/math/max.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/value/rgb8.hh>
+#include <mln/value/int_u.hh>
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] input_int_u8 the 8 bits input image to analyze.
+/// \param[in] name_histo   the name of the output histogram.
+/// \param[in] name_image   the name of the ouput sub image.
+///
+/// \return the deviation, but at this time nothing..
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it).
+float stddev_color(mln::image2d<mln::value::int_u8> input_int_u8)
+{
+  typedef mln::point1d                                t_point1d;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+  typedef mln::image1d<unsigned>                      t_histo1d;
+  typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+  typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+  typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+  t_histo1d                                           histo;
+
+  histo        = mln::data::compute(t_histo1d_fun(), input_int_u8);
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter_(t_histo1d) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  // Compute the specific stddev
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float stddev     = 0.0;
+
+  if (250 > p_max)
+    for (short i = p_max+1; i < p_max+6; ++i)
+      stddev_up += r(p_max, mln::opt::at(histo,p_max),
+		     i, mln::opt::at(histo,i));
+
+  if (5 < p_max)
+    for (short i = p_max-1; i > p_max-6; --i)
+      stddev_low += r(p_max, mln::opt::at(histo,p_max),
+		      i, mln::opt::at(histo,i));
+
+  stddev = (250 < p_max)? stddev_low : (5 > p_max)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  return stddev;
+}
+
+/// \brief Divide the image in 16 sub images.
+///
+/// \param[in] image the input image.
+///
+/// \result nothing.
+///
+/// Divive the input image in 16 by uniform and geometrical
+/// method. When a sub image is ready, call the stddev routine to show
+/// stats on it.
+float stddev_color_16(const std::string& image)
+{
+  typedef mln::point1d                                t_point1d;
+  typedef mln::value::rgb8                            t_rgb8;
+  typedef mln::value::int_u8                          t_int_u8;
+  typedef mln::image2d<t_rgb8>                        t_image2d_rgb8;
+  typedef mln::image2d<t_int_u8>                      t_image2d_int_u8;
+  typedef mln::image1d<unsigned>                      t_histo1d;
+  typedef mln::fun::v2v::rgb8_to_int_u8               t_rgb8_to_int_u8;
+  typedef mln::accu::meta::stat::histo1d              t_histo1d_fun;
+  typedef mln::accu::max_site<t_histo1d>              t_max_site_fun;
+
+  t_image2d_rgb8                                      input_rgb8;
+  t_image2d_int_u8                                    input_int_u8;
+
+  mln::io::ppm::load(input_rgb8, image.c_str());
+  input_int_u8 = mln::data::transform(input_rgb8, t_rgb8_to_int_u8());
+
+  // IMAGE SPLITTING PHASE
+  mln::box2d     domain = input_int_u8.domain();
+  mln::point2d   pmin   = domain.pmin();
+  mln::point2d   pmax   = domain.pmax();
+
+  unsigned       sz_row = (pmax.row() - pmin.row())/ 4;
+  unsigned       sz_col = (pmax.col() - pmin.col())/ 4;
+  float          stddev = 0.0;
+
+  // Divide the domain in nine sub-domains.
+  for (unsigned i = 0; i < 4; ++i)
+    for (unsigned j = 0; j < 4; ++j)
+    {
+      mln::point2d min(pmin.row()+sz_row*i,pmin.col()+sz_col*j);
+      mln::point2d max(pmin.row()+sz_row*(i+1),pmin.col()+sz_col*(j+1));
+      mln::box2d   dom(min,max);
+
+      // Save it
+      t_image2d_int_u8   input_1o16_int_u8(dom);
+
+      mln::data::paste(input_int_u8 | dom, input_1o16_int_u8);
+
+      stddev = mln::math::max(stddev, stddev_color(input_1o16_int_u8));
+    }
+
+  return stddev;
+}
+
+
+/// \brief Main entry.
+///
+/// Just a front end for image processing routine. Use boost to go
+/// through the image database.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ANNOTATING_1_BILL_IMG_PATH),
+			t_path(ANNOTATING_1_FAX_IMG_PATH),
+			t_path(ANNOTATING_1_HANDWRITTEN_IMG_PATH),
+			t_path(ANNOTATING_1_LOGO_IMG_PATH),
+			t_path(ANNOTATING_1_MAP_IMG_PATH),
+			t_path(ANNOTATING_1_PHOTO_IMG_PATH),
+			t_path(ANNOTATING_1_SCREENSHOT_IMG_PATH),
+			t_path(ANNOTATING_1_SLIDE_IMG_PATH),
+			t_path(ANNOTATING_1_TYPED_IMG_PATH)};
+
+  for (int i = 0; i < 9; ++i)
+  {
+    std::cerr << "entering "   << full_path[i] << std::endl;
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float count = 0;
+      float sum1  = 0;
+      float sum2  = 0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	float val = stddev_color_16(dir_iter->path().string());
+
+	++count;
+	sum1 += val;
+	sum2 += val*val;
+
+	std::cout << dir_iter->path().string() << " => " << val << std::endl;
+      }
+
+      float mean = sum1 / count;
+      float var  = ((float)sum2 / count) - (mean * mean);
+
+      std::cout << "mean : " << mean << std::endl;
+      std::cout << "var  : " << var  << std::endl;
+    }
+  }
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/exp/regional_maxima/Makefile.am b/scribo/sandbox/green/exp/annotating/value/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/exp/regional_maxima/Makefile.am
copy to scribo/sandbox/green/exp/annotating/value/Makefile.am
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-color.txt b/scribo/sandbox/green/exp/annotating/value/text-color.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-color.txt
copy to scribo/sandbox/green/exp/annotating/value/text-color.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-img.txt b/scribo/sandbox/green/exp/annotating/value/text-img.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-img.txt
copy to scribo/sandbox/green/exp/annotating/value/text-img.txt
diff --git a/milena/sandbox/green/exp/annotating/achromastism/text-only.txt b/scribo/sandbox/green/exp/annotating/value/text-only.txt
similarity index 100%
copy from milena/sandbox/green/exp/annotating/achromastism/text-only.txt
copy to scribo/sandbox/green/exp/annotating/value/text-only.txt
diff --git a/scribo/sandbox/green/exp/annotating/value/value.cc b/scribo/sandbox/green/exp/annotating/value/value.cc
new file mode 100644
index 0000000..cade88b
--- /dev/null
+++ b/scribo/sandbox/green/exp/annotating/value/value.cc
@@ -0,0 +1,468 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena.  If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction.  Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License.  This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+/// \file
+///
+/// \brief Implement the Millet value operator [millet.phd.2008.pdf]
+///
+/// This is the Millet code for moving from RGB space to value
+/// one. Formulae are classical, we can find them on the web.
+///
+/// Val = max(R,G,B).
+/// Sat = (max(R,G,B) - min(R,G,B))/max(R,G,B).
+/// IF R = max(R,G,B) THEN Hue = 60 * [(V-B)/(max(R,G,B)-min(R,G,B))].
+/// IF G = max(R,G,B) THEN Hue = 60 * [2 + (B-R)/(max(R,G,B)-min(R,G,B))].
+/// IF B = max(R,G,B) THEN Hue = 60 * [4 + (R-G)/(max(R,G,B)-min(R,G,B))].
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem.hpp>
+
+#include <mln/img_path.hh>
+
+#include <mln/accu/stat/histo1d.hh>
+
+#include <mln/core/image/image1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+
+#include <mln/data/compute.hh>
+#include <mln/data/stretch.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/literal/colors.hh>
+#include <mln/literal/grays.hh>
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/geom/nsites.hh>
+
+#include <mln/fun/v2v/rgb_to_value_map.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/rgb8.hh>
+
+/// \brief Label the value.
+///
+/// \param[in] val the value in [0..255].
+///
+/// \return the reference color.
+///
+/// Segment the grey value in three classes.
+mln::value::rgb8 label_val(const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (82 > val)
+    result = mln::literal::black;
+  else if (179 > val)
+    result= mln::literal::medium_gray;
+  else
+    result = mln::literal::white;
+
+  return result;
+}
+
+
+/// \brief Label color with orange reference or brown reference.
+///
+/// \param[in] color the rgb8 color.
+/// \param[in] sat the HSV saturation.
+/// \param[in] val the HSV value.
+///
+/// \return the reference color with which it has been associated to.
+///
+/// Discriminate between orange and brown colors which are at the same
+/// position on the hue wheel.
+mln::value::rgb8 label_orange_or_brown(const mln::value::rgb8   color,
+				       const mln::value::int_u8 sat,
+				       const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (mln::literal::orange == color)
+  {
+    unsigned dist_orange = mln::math::abs(sat - 184)
+      + mln::math::abs(val - 65);
+
+    unsigned dist_brown  = mln::math::abs(sat - 255)
+      + mln::math::abs(val - 125);
+
+    if (dist_orange < dist_brown)
+      result = mln::literal::orange;
+    else
+      result = mln::literal::brown;
+  }
+  else
+    result = color;
+
+  return result;
+}
+
+/// \brief Label between yellow and green color.
+///
+/// \param[in] color the rgb8 color.
+/// \param[in] val the HSV value.
+///
+/// \return the reference color associated to that color.
+///
+/// Segment between yellow and green because the discrimination is not
+/// so easy based on the hue wheel.
+mln::value::rgb8 label_yellow_or_green(const mln::value::rgb8   color,
+				       const mln::value::int_u8 val)
+{
+  mln::value::rgb8 result;
+
+  if (mln::literal::yellow == color)
+  {
+    // Is it green or yellow ?
+    if (80 > val)
+      result = mln::literal::green;
+    else
+      result = mln::literal::yellow;
+  }
+  else
+    return color;
+
+  return result;
+}
+
+/// \brief Label hue color.
+///
+/// \param[in] hue the HSV hue canal for a pixel.
+///
+/// \return a hue segmentation of the hue wheel.
+///
+/// The old classification given by Millet is commented. Mine is ready
+/// to use.  We need to change reference colors to make the primary
+/// colors, the secondary ones, etc...
+mln::value::rgb8 label_hue(const mln::value::int_u8 hue)
+{
+  mln::value::rgb8 result;
+
+  if (14 > hue)
+    result = mln::literal::red;
+  else if (29 > hue)
+    result = mln::literal::orange;
+  else if (45 > hue)
+    result = mln::literal::yellow;
+  else if (113 > hue)
+    result = mln::literal::green;
+  else if (149 > hue)
+    result = mln::literal::cyan;
+  else if (205 > hue)
+    result = mln::literal::blue;
+  else if (235 > hue)
+    result = mln::literal::violet;
+  else if (242 > hue)
+    result = mln::literal::pink;
+  else
+    result = mln::literal::red;
+
+  return result;
+}
+
+/// \brief Sum all the bins of the histogram.
+///
+/// \param[in] img the histogram based on image.
+///
+/// \return the sum of the overall bins.
+///
+/// Sum evry bins and return the result.
+template <typename I>
+unsigned count_histo(const mln::Image<I>& img_)
+{
+  const   I& img = exact(img_);
+
+  mln_precondition(img.is_valid());
+
+  unsigned     result = 0;
+
+  mln_piter(I) p(img.domain());
+
+  for_all(p)
+    result += img(p);
+
+  return result;
+}
+
+/// \brief Detect the peak of the histogram.
+///
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the position of the peak.
+///
+/// This is a typical accumulator use case but as it needs the
+/// position it couldn't be one of them. Look at the last maxima in
+/// the curve and return its position.
+template <typename I>
+unsigned peak_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the peak of the histogram
+  unsigned v_max = mln::opt::at(histo, 0);
+  short    p_max = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    if (v_max < histo(p))
+    {
+      v_max = histo(p);
+      p_max = p.ind();
+    }
+  }
+
+  return p_max;
+}
+
+/// \brief Compute the average of the histogram.
+///
+/// \param[in] histo_ the image which represents the histogram.
+///
+/// \return the average of the histogram.
+///
+/// This code should be an accumulator. It computes the mean of the
+/// histogram, just stats in loop. Compute the sum, compute the
+/// ponderate sum and divide the second by the first.
+template <typename I>
+unsigned mean_histo(const mln::Image<I>& histo_)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Find the mean of the histogram
+  float sum   = 0;
+  float mean  = 0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    sum  += histo(p);
+    mean += p.ind()*histo(p);
+  }
+
+  mean = mean / sum;
+
+  return mean;
+}
+
+/// \brief The R function of Millet
+///
+/// \param[in] p       the position of the pic.
+/// \param[in] histo_p the histo value of the pic.
+/// \param[in] x       the position of the element which we compute the contrib.
+/// \param[in] histo_x the histo value of that element.
+///
+/// \result the contribution of the element x.
+///
+/// This function compute the variance-like contribution of an element
+/// x linked to the pic of the histogram. In fact, every thing is like
+/// we compute a square distance-like between the element x and the
+/// pic in the normalized histogram. Notice that the normalized
+/// histogram is the histogram divide by the value of it's pic. So at
+/// the pic, the value equals 1. It's a current representation of the
+/// histogram in image processing, we can find it in gimp for exemple.
+float r(short p, unsigned histo_p, short x, unsigned histo_x)
+{
+  float result = mln::math::sqr(((float)histo_x / histo_p) * (x-p));
+
+  return result;
+}
+
+
+/// \brief The stddev3 is an internal stuff.
+///
+/// \param[in] histo_ the image which represents the histogram.
+/// \param[in] peak   the position of the histogram peak.
+///
+/// \return simple computing of deviation.
+///
+/// This is an internal stuff. It splits the computing for easy
+/// reusing practice. Sum the R contribution.
+template <typename I>
+float stddev3(const mln::Image<I>& histo_, unsigned peak)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  // Compute stddev
+
+  float stddev = 0.0;
+
+  mln_piter(I) p(histo.domain());
+
+  for_all(p)
+  {
+    stddev  += r((short)peak, mln::opt::at(histo,peak), p.ind(), histo(p));
+  }
+
+  return stddev;
+}
+
+
+/// Brief compute the whole deviation of Millet
+///
+/// \param[in] image the input image to analyze.
+/// \param[in] peak the peak of the histogram.
+/// \param[in] limit the threshold to compute the contribution.
+///
+/// \return the deviation.
+///
+/// The deviation uses the R function. It stats by finding the pic. If
+/// the pic is near the rigth border of the histo, compute the R
+/// function on the left neighbouring of the pic. If the pic is near
+/// the left border of the histo, compute the R function on the right
+/// neigbouring. Otherwise, compute the average of the right and left
+/// results. The selected neighbouring is composed of five pixels at
+/// the right or at the left of the pic. The detection of clipart
+/// assumes that the majority of the energy of the histogram is closed
+/// to the pic (five pixels around it). The test is generalized by
+/// making constants as parameters.
+template <typename I>
+float stddev2(const mln::Image<I>& histo_, unsigned peak, unsigned limit)
+{
+  const I& histo = exact(histo_);
+
+  mln_precondition(histo.is_valid());
+
+  float stddev_low = 0.0;
+  float stddev_up  = 0.0;
+  float ret        = 0.0;
+
+  // A transformer avec des iterators
+
+  if (250 > peak)
+    stddev_up  = stddev3(histo |mln::box1d(mln::point1d(peak+1),
+					   mln::point1d(peak+limit)), peak);
+
+  if (5 < peak)
+    stddev_low = stddev3(histo |mln::box1d(mln::point1d(peak-limit),
+					   mln::point1d(peak-1)), peak);
+
+  ret = (250 < peak)? stddev_low : (5 > peak)? stddev_up :
+    (stddev_low + stddev_up)/2;
+
+  return ret;
+}
+
+
+/// \brief This is the main Millet test.
+///
+/// \param[in] input the name of the input image.
+/// \param[in] output the name of result histogram.
+/// \param[in] tmp the name of the output value (HSV) map.
+/// \param[in] threshold the range around the peak where R is computed.
+///
+/// \return the proportion of pixels that pass the test.
+float value_test(const std::string input,
+		 const std::string output,
+		 const std::string tmp,
+		 const unsigned threshold)
+
+{
+  typedef mln::fun::v2v::rgb_to_value_map<8>   t_rgb_to_value_map;
+
+  mln::image2d<mln::value::rgb8>   input_rgb8;
+  mln::image2d<mln::value::int_u8> map;
+  mln::image1d<unsigned>           histo;
+  unsigned                         cnt1;
+  unsigned                         cnt2;
+  float                            prop;
+  unsigned                         peak;
+
+  mln::io::ppm::load(input_rgb8, input.c_str());
+
+  map    = mln::data::transform(input_rgb8, t_rgb_to_value_map());
+  histo  = mln::data::compute(mln::accu::meta::stat::histo1d(), map);
+  peak   = peak_histo(histo); // mean_histo(histo);
+  prop   = stddev2(histo, peak, threshold);
+//  cnt1   = count_histo(histo | mln::box1d(mln::point1d(peak-threshold),
+//					  mln::point1d(peak+threshold)));
+//  cnt2   = mln::geom::nsites(input_rgb8);
+//  prop   = ((100.0 * cnt1) / cnt2);
+
+  mln::io::plot::save_image_sh(histo, output.c_str());
+  mln::io::pgm::save(map, tmp.c_str());
+
+  return prop;
+}
+
+
+/// \brief The main entry.
+///
+/// This is the front end for using directories with boost. It calls
+/// the true image processing routine.
+int main()
+{
+  typedef boost::filesystem::path                   t_path;
+  typedef boost::filesystem::directory_iterator     t_iter_path;
+
+  t_path full_path[] = {t_path(ICDAR_20P_PPM_IMG_PATH)};
+
+  for (int i = 0; i < 1; ++i)
+  {
+    std::cout << "entering "   << full_path[i] << std::endl;
+
+    if (boost::filesystem::exists(full_path[i]) &&
+	boost::filesystem::is_directory(full_path[i]))
+    {
+      boost::filesystem::system_complete(full_path[i]);
+      const t_iter_path end_iter;
+      float             prop = 0.0;
+
+      for (t_iter_path dir_iter(full_path[i]); end_iter != dir_iter; ++dir_iter)
+      {
+	// concatenation de chaine
+	t_path directory(ANNOTATING_RET_PATH);
+	t_path leaf   = dir_iter->path().leaf();
+	t_path output = change_extension(directory / leaf, ".sh");
+	t_path tmp    = change_extension(directory / leaf, ".pgm");
+
+	prop = value_test(dir_iter->path().string(),
+			  output.string(),
+			  tmp.string(),
+			  15);
+
+	std::cout << output << " : " << prop << std::endl;
+	std::cerr << output << " : " << prop << std::endl;
+      }
+    }
+  }
+
+  return 0;
+}
diff --git a/scribo/sandbox/green/mln/clustering/kmean2d.hh b/scribo/sandbox/green/mln/clustering/kmean2d.hh
index 51aaf49..4539083 100644
--- a/scribo/sandbox/green/mln/clustering/kmean2d.hh
+++ b/scribo/sandbox/green/mln/clustering/kmean2d.hh
@@ -150,7 +150,7 @@ namespace mln
     {
       /// Type definitions.
       /// \brief A few type definitions to limit the refactoring impact.
-      ///{
+      /// \{
       typedef value::rgb<8>                      t_rgb;
       typedef value::label<8>                    t_label;
       typedef value::rg<n>                       t_value;
@@ -179,7 +179,7 @@ namespace mln
       typedef util::array<t_mean_set>            t_mean_cnv;
       typedef image1d<t_result1d>                t_variance_val;
       typedef util::array<t_variance_val>        t_variance_cnv;
-      ///}
+      /// \}
 
       /// \brief Constructor.
       /// \param[in] point     : the image as the population of pixels.
diff --git a/scribo/sandbox/green/mln/fun/p2b/achromatic.hh b/scribo/sandbox/green/mln/fun/p2b/achromatic.hh
index 1f45b2d..91a2dc5 100644
--- a/scribo/sandbox/green/mln/fun/p2b/achromatic.hh
+++ b/scribo/sandbox/green/mln/fun/p2b/achromatic.hh
@@ -44,15 +44,29 @@ namespace mln
 
     namespace p2b
     {
-      /// \brief Functor that compare the i-th component of a value.
-      // V is for the type of the value received
-      // i is the ith component to select
+      /// \brief Functor that compare the i-th component with a threshold.
+      ///
+      /// T_rgb is the kind of RGB we use.
       template <typename T_rgb>
       struct achromatic : public Function_v2b< achromatic<T_rgb> >
       {
 	typedef bool result;
+
+	/// \brief Operator that makes the threshold [millet.phd.2008.pdf]
+	///
+	/// \param[in] p the selected site
+	///
+	/// \return if the site is achromatic or not.
+	///
+        /// This a try for opimized the call to the achromatic
+	/// routine.  The goal is to decide if a site has got an
+	/// achromatic status or not. This is the true Millet test.
 	bool operator()(const point2d& p) const;
 
+	/// \brief Cstor of the object.
+	///
+	/// \param[in] img the RGB input image.
+	/// \param[in] threshold the value to compare with.
 	achromatic(const image2d<T_rgb>& img, const float threshold);
 
 	const float           threshold_;
diff --git a/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh b/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
index 84d26c8..e776c9a 100644
--- a/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
+++ b/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
@@ -32,6 +32,10 @@
 # include <mln/value/hsv.hh>
 # include <mln/value/rgb8.hh>
 
+/// \file
+///
+/// This is the code for building hue_concentration_map.
+
 namespace mln
 {
 
@@ -41,12 +45,18 @@ namespace mln
     namespace v2v
     {
 
+      /// \brief internal method for detecting the histogram peak.
+      ///
+      /// \param[in] hue_histo the histogram of hue.
+      ///
+      /// \return the seed of the peek.
       unsigned peak_histo(const mln::image1d<unsigned>& hue_histo);
 
       struct hue_concentration : public Function_v2v< hue_concentration >
       {
 	typedef float result;
 
+	/// \brief Gibe the distance map between actual hue and the peak.
 	float operator()(const float hue) const;
 
 	hue_concentration(const mln::image1d<unsigned>& hue_histo)
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
index 6de63ec..126f9bd 100644
--- a/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
@@ -49,6 +49,11 @@ namespace mln
 
       /// \brief Convert rgb value to achromatism map.
       ///
+      /// Convert rgb value to binary achromastism map using the
+      /// rebuilded Millet phd formulae [millet.phd.2008.pdf]. The
+      /// idea is to look at the minimum and maximum of the channels
+      /// and to return the difference.
+      ///
       /// \ingroup modfunv2v
 
       template <unsigned n>
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
index 3dd8eb0..a191095 100644
--- a/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
@@ -34,6 +34,11 @@
 #include <mln/value/hsv.hh>
 #include <mln/value/rgb.hh>
 
+/// \fiie
+///
+/// This is the millet [millet.phd.2008.pdf] transformation from RGB
+/// space to HSV space.
+
 namespace mln
 {
 
@@ -57,7 +62,15 @@ namespace mln
 	typedef T_hsv result;
 
 
-	/// HSV implementation from millet.2008.phd.pdf p67
+	/// \brief HSV implementation from millet.2008.phd.pdf p67
+	///
+	/// \param[in] rgb the input rgb pixel.
+	///
+	/// \return a HSV pixel.
+	///
+	/// This is the Millet implementation of its transformation
+	/// operator to go from RGB space to HSV space. When pixels
+	/// are achromatic, hue equals -1.
 	template <typename T_rgb>
 	T_hsv operator()(const T_rgb& rgb) const;
 
-- 
1.5.6.5

    

Yann Jacquelet

tags

participants (1)