15 Nov
2010
15 Nov
'10
3:40 p.m.
Implement the first version with vectors and matrices.
* mln/clustering/k_mean.hh: New library component.
* use/clustering/k_mean: New directory.
* use/clustering/k_mean/Makefile.am: New makefile.
* use/clustering/k_mean/k_mean.cc: New source file.
* tests/clustering/k_mean: New directory.
* tests/clustering/k_mean/Makefile.am: New makefile.
* tests/clustering/k_mean/k_mean.cc: New source file.
Implement the second version with image and working in 1d.
* mln/clustering/kmean1d.hh: New library component.
* use/clustering/kmean1d: New directory.
* use/clustering/kmean1d/Makefile.am: New makefile.
* use/clustering/kmean1d/kmean1d.cc: New source file.
* demo/clustering/kmean1d: New directory.
* demo/clustering/kmean1d/Makefile.am: New makefile.
* demo/clustering/kmean1d/kmean1d.cc: New source file.
Implement transformation between RG space and RGB space.
* mln/fun/v2v/rg_to_rgb.hh: New library component.
* use/fun/v2v/rg_to_rgb: New directory.
* use/fun/v2v/rg_to_rgb/Makefile.am: New makefile.
* use/fun/v2v/rg_to_rgb/rg_to_rgb.cc: New source file.
Implement the third version working in 2d (r/g).
* mln/clustering/kmean2d.hh: New library component.
* use/clustering/kmean2d: New directory.
* use/clustering/kmean2d/Makefile.am: New makefile.
* use/clustering/kmean2d/kmean2d.cc: New source file.
* demo/clustering/kmean2d: New directory.
* demo/clustering/kmean2d/Makefile.am: New makefile.
* demo/clustering/kmean2d/kmean2d.cc: New source file.
Implement the fourth version working in 3d (rgb).
* mln/clustering/kmean3d.hh: New library component.
* use/clustering/kmean3d: New directory.
* use/clustering/kmean3d/Makefile.am: New makefile.
* use/clustering/kmean3d/kmean3d.cc: New source file.
* demo/clustering/kmean3d: New directory.
* demo/clustering/kmean3d/Makefile.am: New makefile.
* demo/clustering/kmean3d/kmean3d.cc: New source file.
Implement the fith version as a function (working in rgb space).
* mln/clustering/kmean_rgb.hh: New library component.
* use/clustering/kmean_rgb: New directory.
* use/clustering/kmean_rgb/Makefile.am: New makefile.
* use/clustering/kmean_rgb/kmean_rgb.cc: New source file.
* demo/clustering/kmean_rgb: New directory.
* demo/clustering/kmean_rgb/Makefile.am: New makefile.
* demo/clustering/kmean_rgb/kmean_rgb.cc: New source file.
Benchmark distance algorithm for the kmean algorithm.
* bench/clustering/distance: New directory.
* bench/clustering/distance/Makefile.am: New makefile.
* bench/clustering/distance/distance.cc: New source file.
---
scribo/sandbox/green/ChangeLog | 77 ++
scribo/sandbox/green/README.green | 150 ++++-
.../green/bench/clustering/distance/Makefile.am | 153 ++++
.../green/bench/clustering/distance/distance.cc | 842 ++++++++++++++++++++
.../green/demo/clustering/kmean1d/Makefile.am | 153 ++++
.../green/demo/clustering/kmean1d/kmean1d.cc | 258 ++++++
.../green/demo/clustering/kmean2d/Makefile.am | 153 ++++
.../green/demo/clustering/kmean2d/kmean2d.cc | 278 +++++++
.../green/demo/clustering/kmean3d/Makefile.am | 153 ++++
.../green/demo/clustering/kmean3d/kmean3d.cc | 265 ++++++
.../green/demo/clustering/kmean_rgb/Makefile.am | 153 ++++
.../green/demo/clustering/kmean_rgb/kmean_rgb.cc | 239 ++++++
scribo/sandbox/green/mln/clustering/k_mean.hh | 365 ++++++---
scribo/sandbox/green/mln/clustering/kmean1d.hh | 194 ++---
scribo/sandbox/green/mln/clustering/kmean2d.hh | 329 ++++----
scribo/sandbox/green/mln/clustering/kmean3d.hh | 246 +++---
scribo/sandbox/green/mln/clustering/kmean_rgb.hh | 87 ++-
scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh | 59 ++-
.../green/tests/clustering/k_mean/Makefile.am | 13 +-
.../green/tests/clustering/k_mean/k_mean.cc | 395 ++++++----
.../stat/histo1d => clustering/k_mean}/Makefile.am | 0
.../sandbox/green/use/clustering/k_mean/k_mean.cc | 55 ++
.../histo1d => clustering/kmean1d}/Makefile.am | 0
.../green/use/clustering/kmean1d/kmean1d.cc | 50 ++
.../histo1d => clustering/kmean2d}/Makefile.am | 0
.../green/use/clustering/kmean2d/kmean2d.cc | 61 ++
.../histo1d => clustering/kmean3d}/Makefile.am | 0
.../green/use/clustering/kmean3d/kmean3d.cc | 63 ++
.../histo1d => clustering/kmean_rgb}/Makefile.am | 0
.../green/use/clustering/kmean_rgb/kmean_rgb.cc | 63 ++
.../stat/histo1d => fun/v2v/rg_to_rgb}/Makefile.am | 0
.../green/use/fun/v2v/rg_to_rgb/rg_to_rgb.cc | 68 ++
32 files changed, 4224 insertions(+), 698 deletions(-)
create mode 100644 scribo/sandbox/green/bench/clustering/distance/Makefile.am
create mode 100644 scribo/sandbox/green/bench/clustering/distance/distance.cc
create mode 100644 scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
create mode 100644 scribo/sandbox/green/demo/clustering/kmean1d/kmean1d.cc
create mode 100644 scribo/sandbox/green/demo/clustering/kmean2d/Makefile.am
create mode 100644 scribo/sandbox/green/demo/clustering/kmean2d/kmean2d.cc
create mode 100644 scribo/sandbox/green/demo/clustering/kmean3d/Makefile.am
create mode 100644 scribo/sandbox/green/demo/clustering/kmean3d/kmean3d.cc
create mode 100644 scribo/sandbox/green/demo/clustering/kmean_rgb/Makefile.am
create mode 100644 scribo/sandbox/green/demo/clustering/kmean_rgb/kmean_rgb.cc
copy scribo/sandbox/green/use/{accu/stat/histo1d => clustering/k_mean}/Makefile.am
(100%)
create mode 100644 scribo/sandbox/green/use/clustering/k_mean/k_mean.cc
copy scribo/sandbox/green/use/{accu/stat/histo1d => clustering/kmean1d}/Makefile.am
(100%)
create mode 100644 scribo/sandbox/green/use/clustering/kmean1d/kmean1d.cc
copy scribo/sandbox/green/use/{accu/stat/histo1d => clustering/kmean2d}/Makefile.am
(100%)
create mode 100644 scribo/sandbox/green/use/clustering/kmean2d/kmean2d.cc
copy scribo/sandbox/green/use/{accu/stat/histo1d => clustering/kmean3d}/Makefile.am
(100%)
create mode 100644 scribo/sandbox/green/use/clustering/kmean3d/kmean3d.cc
copy scribo/sandbox/green/use/{accu/stat/histo1d => clustering/kmean_rgb}/Makefile.am
(100%)
create mode 100644 scribo/sandbox/green/use/clustering/kmean_rgb/kmean_rgb.cc
copy scribo/sandbox/green/use/{accu/stat/histo1d => fun/v2v/rg_to_rgb}/Makefile.am
(100%)
create mode 100644 scribo/sandbox/green/use/fun/v2v/rg_to_rgb/rg_to_rgb.cc
diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index 7bb6646..4ddaa54 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -1,3 +1,80 @@
+2010-06-28 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Implement the kmean algorithh and start to optimize it.
+
+ Implement the first version with vectors and matrices.
+
+ * mln/clustering/k_mean.hh: New library component.
+
+ * use/clustering/k_mean: New directory.
+ * use/clustering/k_mean/Makefile.am: New makefile.
+ * use/clustering/k_mean/k_mean.cc: New source file.
+
+ * tests/clustering/k_mean: New directory.
+ * tests/clustering/k_mean/Makefile.am: New makefile.
+ * tests/clustering/k_mean/k_mean.cc: New source file.
+
+ Implement the second version with image and working in 1d.
+
+ * mln/clustering/kmean1d.hh: New library component.
+
+ * use/clustering/kmean1d: New directory.
+ * use/clustering/kmean1d/Makefile.am: New makefile.
+ * use/clustering/kmean1d/kmean1d.cc: New source file.
+
+ * demo/clustering/kmean1d: New directory.
+ * demo/clustering/kmean1d/Makefile.am: New makefile.
+ * demo/clustering/kmean1d/kmean1d.cc: New source file.
+
+ Implement transformation between RG space and RGB space.
+
+ * mln/fun/v2v/rg_to_rgb.hh: New library component.
+ * use/fun/v2v/rg_to_rgb: New directory.
+ * use/fun/v2v/rg_to_rgb/Makefile.am: New makefile.
+ * use/fun/v2v/rg_to_rgb/rg_to_rgb.cc: New source file.
+
+ Implement the third version working in 2d (r/g).
+
+ * mln/clustering/kmean2d.hh: New library component.
+
+ * use/clustering/kmean2d: New directory.
+ * use/clustering/kmean2d/Makefile.am: New makefile.
+ * use/clustering/kmean2d/kmean2d.cc: New source file.
+
+ * demo/clustering/kmean2d: New directory.
+ * demo/clustering/kmean2d/Makefile.am: New makefile.
+ * demo/clustering/kmean2d/kmean2d.cc: New source file.
+
+ Implement the fourth version working in 3d (rgb).
+
+ * mln/clustering/kmean3d.hh: New library component.
+
+ * use/clustering/kmean3d: New directory.
+ * use/clustering/kmean3d/Makefile.am: New makefile.
+ * use/clustering/kmean3d/kmean3d.cc: New source file.
+
+ * demo/clustering/kmean3d: New directory.
+ * demo/clustering/kmean3d/Makefile.am: New makefile.
+ * demo/clustering/kmean3d/kmean3d.cc: New source file.
+
+ Implement the fith version as a function (working in rgb space).
+
+ * mln/clustering/kmean_rgb.hh: New library component.
+
+ * use/clustering/kmean_rgb: New directory.
+ * use/clustering/kmean_rgb/Makefile.am: New makefile.
+ * use/clustering/kmean_rgb/kmean_rgb.cc: New source file.
+
+ * demo/clustering/kmean_rgb: New directory.
+ * demo/clustering/kmean_rgb/Makefile.am: New makefile.
+ * demo/clustering/kmean_rgb/kmean_rgb.cc: New source file.
+
+ Benchmark distance algorithm for the kmean algorithm.
+
+ * bench/clustering/distance: New directory.
+ * bench/clustering/distance/Makefile.am: New makefile.
+ * bench/clustering/distance/distance.cc: New source file.
+
2010-06-24 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
Define documentation files.
diff --git a/scribo/sandbox/green/README.green b/scribo/sandbox/green/README.green
index 3f3c9a9..02d8654 100644
--- a/scribo/sandbox/green/README.green
+++ b/scribo/sandbox/green/README.green
@@ -33,8 +33,7 @@ n'y a rien à copier. Rendons-nous dans le répertoire de compilation
et lançon
le makefile.
#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$
-cd ../../../build/demo/annotating/hsv
-
+#:cd ../../../build/demo/annotating/hsv
#:~/git/olena/scribo/sandbox/green/build/demo/annotating/hsv$ make clean all
L'exécutable est généré par le makefile, il porte le nom du
@@ -168,6 +167,14 @@ de comptage puisqu'il est décrit sous la forme de triplets de
float
contient une séquence d'appels pour les routines permettant de
considérer la dimension de la teinte comme circulaire.
+Après réflexion, le code des histogrammes et tous les accumulateurs
+qui en découlent devraient être rangés dans l'espace de nommage
+mln::accu::histo. Cela permettrait de ne pas parasiter mln::accu::stat
+avec tous les éléments propres aux histogrammes et de ne pas faire un
+espace de nommage à rallonge en introduisant histo dans stat. Donc
+mln::accu::stat semble être une bonne postion pour le rangement final
+du code relatif aux histogrammes.
+
a) version 1d
@@ -198,7 +205,6 @@ c) version 3d RGB
* use/accu/stat/histo3_rgb: Code minimal utilisant un histogramme 3d RGB.
-
d) version 3d HSL
* mln/accu/stat/histo3d_hsl.hh: Accumulateur histogramme image3d HSL.
@@ -245,23 +251,145 @@ IX KMEANS
Ce travail m'avait été demandé par théo. Je le laisse inachevé, quelque part
perdu pendant l'optimisation du code et sa transformation en canevas.
+
+a) Première implémentation avec matrices et vecteurs
+
+Cette version est bien documentée et permet de mieux comprendre les autres
+versions. Par ailleurs, elle n'est pas spécialement optimisée ce qui fait
+qu'elle colle davantage au modèle de l'algorithme kmean traditionnel.
+
* mln/clustering/k_mean.hh: Première implémentation avec matrices et vecteurs.
+* use/clustering/k_mean: Code minimal utilisant cette première implémentation.
+* tests/clustering/k_mean: Tests unitaires sur la permière version.
+
+
+b) Seconde implémentation avec image en 1d
+
+Cette seconde version intègre une optimisation testée par théo il y a
+longtemps. Je me demande si ce n'étais pas pendant sa thèse qu'il
+avait travaillé sur cette version. Bref, dans la mesure où
+l'optimisation passe par la création d'un histogramme, cette version
+devient dépendante des histogrammes réalisés plutôt (il est aussi
+dépendant de la sauvegarde au format gnuplot shell). L'idée générale
+de l'optimisation est de ne plus raisonner sur l'image, mais sur
+l'histogramme. Car à un moment donné, la classification ne tient
+compte que de la valeur du pixel en intensité (pas de ses coordonnées
+dans l'image). Donc tout pixel de même intensité sera classé de
+manière identique. D'où l'intérêt de travailler avec les
+histogrammes. Les limites de cette optimisation se trouvent dans la
+taille des histogrammes. L'optimisation marche à merveille pour de
+faibles quantifications (8 bits c'est parfait). Par contre, lorsque
+l'on passe à un histogramme couleur, la taille de l'histogramme
+devient problématique et peut dépasser la taille de l'image. Cette
+optimisation n'a alors plus aucun sens.
+
* mln/clustering/kmean1d.hh: Implémentation 1d avec des images.
+* use/clustering/kmean1d : Code minimal utilisant cette seconde implémentation.
+* demo/clustering/kmean1d : Demonstrateur.
+
+La visualisation de la convergence des moyennes, générée par le
+démonstrateur, n'est pas très lisible. La lecture textuelle du fichier
+gnuplot shell (mean_cnv.sh) permet d'interpréter ce qui se passe, par
+contre le graphique est à refaire.
+
+
+c) kmean2d
+
+Cette troisième version est identique à la seconde, sauf qu'elle
+permet de faire la classification dans un espace à deux
+dimensions. Malheureusement, un tel travail dans cet espace coûte
+beaucoup plus cher à l'exécution.
+
+* mln/fun/v2v/rg_to_rgb.hh: Transformation de l'espace RG vers l'espace RGB.
+* use/fun/v2v/rg_to_rgb: Exemple de code pour l'utilisation de rg_to_rgb.
+
* mln/clustering/kmean2d.hh: Implémentation 2d avec des images.
-* mln/clustering/kmean3d.hh: Implémentation 3d avec des images.
-* mln/clustering/kmean_rgb.hh: Impl. 3d aplatie et en cours de mise en canevas.
+* use/clustering/kmean2d : Code minimal utilisant cette seconde implémentation.
+* demo/clustering/kmean2d : Demonstrateur.
-* tests/clustering/k_mean: Tests unitaires sur la permière version.
-* tests/clustering/kmean1d: Tests unitaire sur la version 1d.
+La visualisation de la convergence des moyennes est cette fois-ci
+complètement aboutie. Le fichier semble avoir quelques soucis, il
+manque des lignes dans le splot initial, en remettre pour qu'il y en
+ait autant que les blocs de données. L'espace des couleurs étant le
+bicanal r/g, on peut visualiser sur une troisième dimension
+l'évolution des centres dans l'espace initial. L'effet est très réussi
+et aussi très parlant. Chaque run, correspond alors à une trajectoire
+particulière. L'affichage des variations des variances a été rénové et
+est lui aussi beaucoup plus lisible.
+
+
+d) kmean3d
+
+Cette quatrième version est la copie conforme de la version
+précédente. Les problèmes de visualisation sur les fichiés générés
+sont les mêmes. L'affichage des convergences est identique. Le recours
+à une dégradation de l'image d'entrée est impérative pour avoir des
+temps encore acceptables.
-* demo/clustering/kmean1d: Utilisation de la version 1d.
-* demo/clustering/kmean2d: Utilisation de la version 2d.
-* demo/clustering/kmean3d: Utilisation de la version 3d.
+* mln/clustering/kmean3d.hh: Implémentation 3d avec des images.
+* use/clustering/kmean3d : Code minimal utilisant cette quatrième impl.
+* demo/clustering/kmean3d : Demonstrateur.
+
+
+e) kmean aplati
+
+Cette cinquième version est très spéciale. Elle doit permettre de
+gagner du temps d'exécution. Le concept est simple au départ, tout
+écrire d'un seul tenant. L'exercice est fastidieux et difficile
+(intellectuellement). Une fois fait, il faut réfléchir à ce qui peut
+être mis sous forme de canevas. Par exemple, la manière de calculer
+les distances peut être une information paramétrable. Cela pemettrait
+de faire un benchmark in situ. La transcription actuelle compile. Elle
+n'intègre pas tous les outils de debuggage que nous pouvions avoir sur
+les autres versions. Par ailleurs, comme le code est réuni en une
+seule fonction, nous avons pour l'instant une seule sortie, l'image de
+labels de la classification réalisée. A partir de cette image, nous
+pouvons en reconstruire d'autres. Il manque quand même la possibilité
+d'observer les convergences. Le travail était en cours, à prendre donc
+avec beaucoup de pincettes. La dernière exécution house.ppm, 3
+centres, 10 itérations et 10 runs fonctionne parfaitement sur les
+premiers runs puis l'affichage s'emballe sans que l'on y comprenne
+rien. Un dump dans un fichier révèle le non appariement de certaines
+traces (entering/exiting). Une piste à suivre est la sortie anticipée
+d'une de mes boucles sans pour autant fermer une trace ... ???
+
+* mln/clustering/kmean_rgb.hh: Implémentation 3d avec des images.
+* use/clustering/kmean_rgb : Code minimal utilisant cette quatrième impl.
* demo/clustering/kmean_rgb: Utilisation de la version aplatie.
+
+f) optimisation possible
+
+Le calcul des distances entre les points et les différents centres
+peut être réalisé par des transformées. Certes, les distances ne seront
+pas les mêmes que la distance euclidienne, mais elles s'en approchent
+et cela constitue très certainement une très bonne approximation pour
+l'objectif que nous cherchons à atteindre. Le but de ce benchmark est
+de regarder quel type de transformation est le plus rapide pour
+arriver à nos fins en fonction des données d'entrée. Cette
+optimisation n'a pas encore été intégrée dans le code, et reste une
+piste à exploiter.
+
* bench/clustering/distance: Comparaison algorithmes d'évaluation des distances.
-==> to do
+Une routine du benchmark ne compile plus. Il semble qu'il y ait un
+mauvais appel à la fonction at_ dans la routine
+influence_zone_geodesic.hh ligne 127. Le but du benchmark est de
+tester les distances en 2d et 3d pour des voisinages différents (c04,
+c08, c06, c18, c26) sur les routines distance euclidienne classique,
+zone d'influence geodesique et zone d'influence "front". La première
+serie de test vise à garder une taille d' image constante et
+d'augmenter le nombre de centres pour voir comment se comporte les
+algorithmes et la seconde serie, vise à garder un nombre constant de
+centres et à agrandir progressivement l'image. Attention, le benchmark
+essaye d'être assez exhaustif et donc se paye par un temps d'execution
+assez long. Les différents fichiers générés reprennent les différents
+tests effectués et montrent l'évolution du temps de calcul suivant la
+progression du paramètre observé (taille de l'image ou nombre de
+centres).
+
+==> to do : le changelog + commit + give it to scribo-z branch
+
X REGIONAL MAXIMA
-----------------
diff --git a/scribo/sandbox/green/bench/clustering/distance/Makefile.am
b/scribo/sandbox/green/bench/clustering/distance/Makefile.am
new file mode 100644
index 0000000..ca5e187
--- /dev/null
+++ b/scribo/sandbox/green/bench/clustering/distance/Makefile.am
@@ -0,0 +1,153 @@
+#
+# Generic Makefile
+#
+
+#########
+# TOOLS #
+#########
+
+#LOADLIBES= -lboost_filesystem
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+#CXXFLAGS= -ggdb -O0 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O1 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+CXXFLAGS= -DNDEBUG -O3 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+ECHO= echo
+RM= rm
+MKDIR= mkdir -p
+CP= cp
+
+SOURCE_PATTERN= green/bench
+BUILD__PATTERN= green/build/bench
+
+
+ifeq ($(findstring $(BUILD__PATTERN),$(PWD)), $(BUILD__PATTERN))
+# Case where make is done from build directory.
+SOURCE_DIR= $(subst $(BUILD__PATTERN),$(SOURCE_PATTERN),$(PWD))
+BUILD__DIR= $(PWD)/
+else
+# Case where make is done from source directory.
+SOURCE_DIR= $(PWD)/
+BUILD__DIR= $(subst $(SOURCE_PATTERN),$(BUILD__PATTERN),$(PWD))
+endif
+
+SRC= $(notdir $(wildcard $(SOURCE_DIR)/*.cc))
+OLD= $(notdir $(wildcard $(SOURCE_DIR)/*~))
+OBJ= $(patsubst %.cc,%.o,$(SRC))
+SOURCE_MAKEFILE=Makefile.am
+BUILD__MAKEFILE=Makefile
+TARGET_FILE= $(notdir $(PWD))
+SOURCE_FILES= $(notdir $(wildcard $(SOURCE_DIR)/*.*))
+BUILD__FILES= $(filter-out $(SRC) $(SOURCE_MAKEFILE), $(SOURCE_FILES))
+
+BUILD__F_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__FILES))
+SOURCE_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_FILES))
+
+BUILD__M_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__MAKEFILE))
+SOURCE_M_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_MAKEFILE))
+
+TARGET_F_PATH= $(addprefix $(BUILD__DIR)/,$(TARGET_FILE))
+OBJ_F_PATH= $(addprefix $(BUILD__DIR)/,$(OBJ))
+SRC_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SRC))
+OLD_F_PATH= $(addprefix $(SOURCE_DIR)/,$(OLD))
+
+#############
+# BOOTSTRAP #
+#############
+
+
+bootstrap: $(BUILD__DIR) $(BUILD__F_PATH) $(BUILD__M_PATH)
+
+# Create, if nessary, the destination directory
+$(BUILD__DIR):
+ $(MKDIR) $(BUILD__DIR)
+
+# Copy, if nessary, all the files, except the Makefile.am
+$(BUILD__F_PATH): $(SOURCE_F_PATH)
+ $(CP) $(addprefix $(SOURCE_DIR),$(@F)) $@
+
+# Copy if nessary, the Makefile.am into Makefile
+$(BUILD__M_PATH): $(SOURCE_M_PATH)
+ $(CP) $(SOURCE_M_PATH) $(BUILD__M_PATH)
+
+
+#######
+# ALL #
+#######
+
+# We assume that the call is done from the build directory.
+# With the directive vpath, hidden files are found in the source directory.
+
+all: $(TARGET_F_PATH)
+
+
+$(TARGET_F_PATH): $(OBJ_F_PATH)
+ $(LINK.cc) $< $(LOADLIBES) $(LDLIBS) -o $@
+
+$(OBJ_F_PATH):$(SRC_F_PATH)
+ $(COMPILE.cc) $(OUTPUT_OPTION) $<
+
+
+#########
+# CLEAN #
+#########
+
+# Force every time the deletion
+clean: clean_target clean_obj clean_dst clean_old #clean_make
+
+
+clean_target:
+ -@$(RM) $(TARGET_F_PATH) &> /dev/null
+
+clean_obj:
+ -@$(RM) $(OBJ_F_PATH) &> /dev/null
+
+clean_dst:
+ -@$(RM) $(BUILD_F_PATH) &> /dev/null
+
+clean_make:
+ -@$(RM) $(BUILD_M_PATH) &> /dev/null
+
+clean_old:
+ -@$(RM) $(OLD_F_PATH) &> /dev/null
+
+
+#########
+# PRINT #
+#########
+
+print: print_tools print_bootstrap
+
+print_tools:
+ @$(ECHO) "HOME = $(HOME)"
+ @$(ECHO) "INCLUDES = $(INCLUDES)"
+ @$(ECHO) "CXXFLAGS = $(CXXFLAGS)"
+ @$(ECHO) "ECHO = $(ECHO)"
+ @$(ECHO) "RM = $(RM)"
+ @$(ECHO) "MKDIR = $(MKDIR)"
+ @$(ECHO) "CP = $(CP)"
+ @$(ECHO)
+
+print_bootstrap:
+ @$(ECHO) "PWD = $(PWD)"
+ @$(ECHO) "SOURCE_PATTERN = $(SOURCE_PATTERN)"
+ @$(ECHO) "BUILD__PATTERN = $(BUILD__PATTERN)"
+ @$(ECHO) "SOURCE_DIR = $(SOURCE_DIR)"
+ @$(ECHO) "BUILD__DIR = $(BUILD__DIR)"
+ @$(ECHO) "SOURCE_MAKEFILE = $(SOURCE_MAKEFILE)"
+ @$(ECHO) "BUILD__MAKEFILE = $(BUILD__MAKEFILE)"
+ @$(ECHO) "TARGET_FILE = $(TARGET_FILE)"
+ @$(ECHO) "SOURCE_FILES = $(SOURCE_FILES)"
+ @$(ECHO) "SOURCE_F_PATH = $(SOURCE_F_PATH)"
+ @$(ECHO) "BUILD__FILES = $(BUILD__FILES)"
+ @$(ECHO) "BUILD__F_PATH = $(BUILD__F_PATH)"
+ @$(ECHO) "BUILD__M_PATH = $(BUILD__M_PATH)"
+ @$(ECHO) "SOURCE_M_PATH = $(SOURCE_M_PATH)"
+ @$(ECHO) "SRC = $(SRC)"
+ @$(ECHO) "OBJ = $(OBJ)"
+ @$(ECHO) "OLD = $(OLD)"
+ @$(ECHO) "SRC_F_PATH = $(SRC_F_PATH)"
+ @$(ECHO) "OBJ_F_PATH = $(OBJ_F_PATH)"
+ @$(ECHO) "OLD_F_PATH = $(OLD_F_PATH)"
+ @$(ECHO)
diff --git a/scribo/sandbox/green/bench/clustering/distance/distance.cc
b/scribo/sandbox/green/bench/clustering/distance/distance.cc
new file mode 100644
index 0000000..4daea44
--- /dev/null
+++ b/scribo/sandbox/green/bench/clustering/distance/distance.cc
@@ -0,0 +1,842 @@
+// 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.
+
+#include <mln/core/alias/box3d.hh>
+#include <mln/core/alias/neighb2d.hh>
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/alias/point3d.hh>
+#include <mln/core/alias/w_window2d_int.hh>
+#include <mln/core/alias/w_window3d_int.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+#include <mln/core/routine/initialize.hh>
+
+#include <mln/data/fill.hh>
+
+#include <mln/io/pgm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/literal/zero.hh>
+
+#include <mln/make/w_window2d_int.hh>
+#include <mln/make/w_window3d_int.hh>
+
+#include <mln/opt/at.hh>
+
+#include <mln/transform/influence_zone_geodesic.hh>
+#include <mln/transform/influence_zone_front.hh>
+
+#include <mln/util/array.hh>
+#include <mln/util/timer.hh>
+
+#include <mln/value/label_8.hh>
+
+
+/// Build inputs, build seeds, count distance.
+/// \{
+/// \brief Build 2d/3d input image and 2d/3d seed image.
+///
+/// Building seeds means making a rectangular grid over a virtual image with
+/// a specific size and collects together in a array each node of this grid.
+/// In the context of the kmean algorithm, seeds are equavalent to centers.
+/// Building input means creating a label image and associates to each seed
+/// a unique label id.
+/// Distance are square euclidian distance in 2d and in 3d.
+mln::image2d<mln::value::label_8> build_input2d(unsigned nb_seed, unsigned size)
+{
+ typedef mln::value::label_8 t_lbl;
+ mln::image2d<t_lbl> input(mln::box2d(mln::point2d(0,0),
+ mln::point2d(size,size)));
+
+ mln::data::fill(input, mln::literal::zero);
+
+ unsigned top = size / nb_seed;
+ unsigned lbl = 0;
+
+ for (unsigned i = top/2; i < size; i += top)
+ for (unsigned j = top/2; j < size; j += top)
+ input(mln::point2d(i,j)) = ++lbl;
+
+ //mln::io::pgm::save(input, "input.pgm");
+
+ return input;
+}
+
+mln::image3d<mln::value::label_8> build_input3d(unsigned nb_seed, unsigned size)
+{
+ typedef mln::value::label_8 t_lbl;
+ mln::image3d<t_lbl> input(mln::box3d(mln::point3d(0,0,0),
+ mln::point3d(size,size,size)));
+
+ mln::data::fill(input, mln::literal::zero);
+
+ unsigned top = size / nb_seed;
+ unsigned lbl = 0;
+
+ for (unsigned i = top/2; i < size; i += top)
+ for (unsigned j = top/2; j < size; j += top)
+ for (unsigned k = top/2; k < size; k += top)
+ input(mln::point3d(k,i,j)) = ++lbl;
+
+ //mln::io::pgm::save(input, "input.pgm");
+
+ return input;
+}
+
+mln::util::array<mln::point3d> build_seed3d(unsigned nb_seed, unsigned size)
+{
+ mln::util::array<mln::point3d> result;
+ unsigned top = size / nb_seed;
+
+ for (unsigned i = top/2; i < size; i += top)
+ for (unsigned j = top/2; j < size; j += top)
+ for (unsigned k = top/2; k < size; k += top)
+ result.append(mln::point3d(k,i,j));
+
+ // std::cout << result << std::endl;
+
+ return result;
+}
+
+mln::util::array<mln::point2d> build_seed2d(unsigned nb_seed, unsigned size)
+{
+ mln::util::array<mln::point2d> result;
+ unsigned top = size / nb_seed;
+
+ for (unsigned i = top/2; i < size; i += top)
+ for (unsigned j = top/2; j < size; j += top)
+ result.append(mln::point2d(j,i));
+
+ // std::cout << result << std::endl;
+
+ return result;
+}
+
+unsigned distance(mln::point3d p1, mln::point3d p2)
+{
+ unsigned row2 = (p1.row() - p2.row())*(p1.row() - p2.row());
+ unsigned col2 = (p1.col() - p2.col())*(p1.col() - p2.col());
+ unsigned sli2 = (p1.sli() - p2.sli())*(p1.sli() - p2.sli());
+ unsigned res = row2 + col2 + sli2;
+
+ return res;
+}
+
+unsigned distance(mln::point2d p1, mln::point2d p2)
+{
+ unsigned row2 = (p1.row() - p2.row())*(p1.row() - p2.row());
+ unsigned col2 = (p1.col() - p2.col())*(p1.col() - p2.col());
+ unsigned res = row2 + col2;
+
+ return res;
+}
+/// \}
+
+/// Benchmark geodesic distance.
+/// \{
+/// \brief The geodesic material for the benchmark process.
+///
+/// This part of the file contains all we need to benchmarck the
+/// geodesic distance. First of all, we have the calling functions
+/// that encapsulate the real call to geodesic routine. They bring us
+/// a clean place where starting and stopping the timer without any
+/// other code interference. Printing results could be done at this step.
+/// At least, we have the test routine that call the previous functions
+/// by passing arguments like different size of inputs and different
+/// neighbouring. The test routines save their results in gnuplot script shell
+/// file that enable to show charts.
+void influence_zone_geodesic_2d(mln::util::timer& timer,
+ const mln::image2d<mln::value::label_8>& input,
+ const mln::neighb2d & neighb)
+{
+ mln::image2d<mln::value::label_8> output;
+
+ timer.start();
+ output = mln::transform::influence_zone_geodesic(input, neighb);
+ timer.stop();
+
+ //mln::io::pgm::save(output, "output.pgm");
+}
+
+/// \fixme influence_zone_geodesic_3d doesn't compile!
+void influence_zone_geodesic_3d(mln::util::timer& timer,
+ const mln::image3d<mln::value::label_8>& input,
+ const mln::neighb3d & neighb)
+{
+ mln::image3d<mln::value::label_8> output;
+
+ timer.start();
+ // FIXME : Problem with the influence_zone_geodesic in 3d (bad call to at_).
+ // output = mln::transform::influence_zone_geodesic(input, neighb);
+ timer.stop();
+
+ //mln::io::pgm::save(output, "output.pgm");
+}
+
+
+int test_influence_zone_geodesic_2d()
+{
+ mln::util::timer timer;
+
+// Test the label c4
+ mln::image1d<float> chart_seed_c04(16*16+2);
+
+ mln::data::fill(chart_seed_c04, mln::literal::zero);
+
+ for (unsigned i = 1; i < 16+1; ++i)
+ {
+ influence_zone_geodesic_2d(timer,build_input2d(i,256),mln::c4());
+ std::cout << "c04|256x256|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c04, i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c04, "geodesic.c04.2d.seed.sh");
+
+ // Test the label c8
+ mln::image1d<float> chart_seed_c08(16*16+2);
+
+ mln::data::fill(chart_seed_c08, mln::literal::zero);
+
+ for (unsigned i = 1; i < 16+1; ++i)
+ {
+ influence_zone_geodesic_2d(timer,build_input2d(i,256),mln::c8());
+ std::cout << "c08|256x256|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c08, i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c08, "geodesic.c08.2d.seed.sh");
+
+ // Test the size of the image
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c04(256+1);
+
+ mln::data::fill(chart_size_c04, mln::literal::zero);
+
+ for (unsigned i = 16; i < 256+1; ++i)
+ {
+ influence_zone_geodesic_2d(timer, build_input2d(4,i),mln::c4());
+ std::cout << "c04|" << i << "x" << i
<< "|16 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c04, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c04, "geodesic.c04.2d.size.sh");
+
+ // Test the size of the image
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c08(256+1);
+
+ mln::data::fill(chart_size_c08, mln::literal::zero);
+
+ for (unsigned i = 16; i < 256+1; ++i)
+ {
+ influence_zone_geodesic_2d(timer, build_input2d(4,i),mln::c8());
+ std::cout << "c08|" << i << "x" << i
<< "|16 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c08, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c08, "geodesic.c08.2d.size.sh");
+
+
+ return 0;
+}
+
+
+void test_influence_zone_geodesic_3d()
+{
+ mln::util::timer timer;
+
+ // Test the number of labels c06
+ mln::image1d<float> chart_seed_c06(5*5*5+2);
+
+ mln::data::fill(chart_seed_c06, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_geodesic_3d(timer, build_input3d(i,128), mln::c6());
+ std::cout << "c06|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c06, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c06, "geodesic.c06.3d.seed.sh");
+
+ // Test the number of labels c18
+ mln::image1d<float> chart_seed_c18(5*5*5+2);
+
+ mln::data::fill(chart_seed_c18, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_geodesic_3d(timer, build_input3d(i,128), mln::c18());
+ std::cout << "c18|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c18, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c18, "geodesic.c18.3d.seed.sh");
+
+ // Test the number of labels c26
+ mln::image1d<float> chart_seed_c26(5*5*5+2);
+
+ mln::data::fill(chart_seed_c26, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_geodesic_3d(timer, build_input3d(i,128), mln::c26());
+ std::cout << "c26|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c26, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c26, "geodesic.c26.3d.seed.sh");
+
+ // Test the size of the image c06
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c06(128+1);
+
+ mln::data::fill(chart_size_c06, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_geodesic_3d(timer, build_input3d(2,i), mln::c6());
+ std::cout << "c06|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c06, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c06, "geodesic.c06.3d.size.sh");
+
+ // Test the size of the image c18
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c18(128+1);
+
+ mln::data::fill(chart_size_c18, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_geodesic_3d(timer, build_input3d(2,i), mln::c18());
+ std::cout << "c18|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c18, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c18, "geodesic.c18.3d.size.sh");
+
+ // Test the size of the image c26
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c26(128+1);
+
+ mln::data::fill(chart_size_c26, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_geodesic_3d(timer, build_input3d(2,i), mln::c26());
+ std::cout << "c26|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c26, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c26, "geodesic.c26.3d.size.sh");
+}
+/// \}
+
+/// Benchmark front distance.
+/// \{
+/// \brief The front material for the benchmark process.
+///
+/// This part of the file contains all we need to benchmarck the
+/// front distance. First of all, we have the calling functions
+/// that encapsulate the real call to geodesic routine. They bring us
+/// a clean place where starting and stopping the timer without any
+/// other code interference. Printing results could be done at this step.
+/// At least, we have the test routine that call the previous functions
+/// by passing arguments like different size of inputs and different
+/// neighbouring. The test routines save their results in gnuplot script shell
+/// file that enable to show charts.
+void influence_zone_front_2d(mln::util::timer& timer,
+ const mln::image2d<mln::value::label_8>& input,
+ const mln::neighb2d& neighb,
+ const mln::w_window2d_int& w2d)
+{
+ mln::image2d<mln::value::label_8> output;
+
+ timer.start();
+ output = mln::transform::influence_zone_front(input, neighb, w2d);
+ timer.stop();
+
+ //mln::io::pgm::save(output, "output.pgm");
+}
+
+
+void influence_zone_front_3d(mln::util::timer& timer,
+ const mln::image3d<mln::value::label_8>& input,
+ const mln::neighb3d& neighb,
+ const mln::w_window3d_int& w3d)
+{
+ mln::image3d<mln::value::label_8> output;
+
+ timer.start();
+ output = mln::transform::influence_zone_front(input, neighb, w3d);
+ timer.stop();
+
+ //mln::io::pgm::save(output, "output.pgm");
+}
+
+
+void test_influence_zone_front_3d()
+{
+ mln::util::timer timer;
+
+ int ws_c06[] = {
+ // Internal slice
+ 0, 0, 0,
+ 0, 2, 0,
+ 0, 0, 0,
+ // Middle slice
+ 0, 2, 0,
+ 2, 0, 2,
+ 0, 2, 0,
+ // External slice
+ 0, 0, 0,
+ 0, 2, 0,
+ 0, 0, 0 };
+
+ int ws_c18[] = {
+ // Internal slice
+ 0, 6, 0,
+ 6, 4, 6,
+ 0, 6, 0,
+ // Middle slice
+ 6, 4, 6,
+ 4, 0, 4,
+ 6, 4, 6,
+ // External slice
+ 0, 6, 0,
+ 6, 4, 6,
+ 0, 6, 0 };
+
+ int ws_c26[] = {
+ // Internal slice
+ 7, 6, 7,
+ 6, 4, 6,
+ 7, 6, 7,
+ // Middle slice
+ 6, 4, 6,
+ 4, 0, 4,
+ 6, 4, 6,
+ // External slice
+ 7, 6, 7,
+ 6, 4, 6,
+ 7, 6, 7 };
+
+ mln::w_window3d_int w3d_c06 = mln::make::w_window3d_int(ws_c06);
+ mln::w_window3d_int w3d_c18 = mln::make::w_window3d_int(ws_c18);
+ mln::w_window3d_int w3d_c26 = mln::make::w_window3d_int(ws_c26);
+
+ // Test the number of labels c06
+ mln::image1d<float> chart_seed_c06(5*5*5+2);
+
+ mln::data::fill(chart_seed_c06, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_front_3d(timer, build_input3d(i,128), mln::c6(), w3d_c06);
+ std::cout << "c06|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c06, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c06, "front.c06.3d.seed.sh");
+
+ // Test the number of labels c18
+ mln::image1d<float> chart_seed_c18(5*5*5+2);
+
+ mln::data::fill(chart_seed_c18, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_front_3d(timer, build_input3d(i,128), mln::c18(), w3d_c18);
+ std::cout << "c18|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c18, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c18, "front.c18.3d.seed.sh");
+
+ // Test the number of labels c26
+ mln::image1d<float> chart_seed_c26(5*5*5+2);
+
+ mln::data::fill(chart_seed_c26, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_front_3d(timer, build_input3d(i,128), mln::c26(), w3d_c26);
+ std::cout << "c26|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c26, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c26, "front.c26.3d.seed.sh");
+
+ // Test the size of the image c06
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c06(128+1);
+
+ mln::data::fill(chart_size_c06, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_front_3d(timer, build_input3d(2,i), mln::c6(), w3d_c06);
+ std::cout << "c06|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c06, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c06, "front.c06.3d.size.sh");
+
+ // Test the size of the image c18
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c18(128+1);
+
+ mln::data::fill(chart_size_c18, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_front_3d(timer, build_input3d(2,i), mln::c18(), w3d_c18);
+ std::cout << "c18|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c18, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c18, "front.c18.3d.size.sh");
+
+ // Test the size of the image c26
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c26(128+1);
+
+ mln::data::fill(chart_size_c26, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_front_3d(timer, build_input3d(2,i), mln::c26(), w3d_c26);
+ std::cout << "c26|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c26, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c26, "front.c26.3d.size.sh");
+}
+
+void test_influence_zone_front_2d()
+{
+ mln::util::timer timer;
+
+ int ws_c04[] = {
+ 0, 2, 0,
+ 2, 0, 2,
+ 0, 2, 0};
+
+ int ws_c08[] = {
+ 6, 4, 6,
+ 4, 0, 4,
+ 6, 4, 6};
+
+ mln::w_window2d_int w2d_c04 = mln::make::w_window2d_int(ws_c04);
+ mln::w_window2d_int w2d_c08 = mln::make::w_window2d_int(ws_c08);
+
+ // Test the label c4
+ mln::image1d<float> chart_seed_c04(16*16+2);
+
+ mln::data::fill(chart_seed_c04, mln::literal::zero);
+
+ for (unsigned i = 1; i < 16+1; ++i)
+ {
+ influence_zone_front_2d(timer,build_input2d(i,256),mln::c4(),w2d_c04);
+ std::cout << "c04|256x256|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c04, i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c04, "front.c04.2d.seed.sh");
+
+ // Test the label c8
+ mln::image1d<float> chart_seed_c08(16*16+2);
+
+ mln::data::fill(chart_seed_c08, mln::literal::zero);
+
+ for (unsigned i = 1; i < 16+1; ++i)
+ {
+ influence_zone_front_2d(timer,build_input2d(i,256),mln::c8(),w2d_c08);
+ std::cout << "c08|256x256|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed_c08, i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed_c08, "front.c08.2d.seed.sh");
+
+ // Test the size of the image
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c04(256+1);
+
+ mln::data::fill(chart_size_c04, mln::literal::zero);
+
+ for (unsigned i = 16; i < 256+1; ++i)
+ {
+ influence_zone_front_2d(timer, build_input2d(4,i),mln::c4(),w2d_c04);
+ std::cout << "c04|" << i << "x" << i
<< "|16 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c04, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c04, "front.c04.2d.size.sh");
+
+ // Test the size of the image
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size_c08(256+1);
+
+ mln::data::fill(chart_size_c08, mln::literal::zero);
+
+ for (unsigned i = 16; i < 256+1; ++i)
+ {
+ influence_zone_front_2d(timer, build_input2d(4,i),mln::c8(),w2d_c08);
+ std::cout << "c08|" << i << "x" << i
<< "|16 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size_c08, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size_c08, "front.c08.2d.size.sh");
+}
+/// \}
+
+
+
+/// Benchmark euclidian distance.
+/// \{
+/// \brief The euclidian material for the benchmark process.
+///
+/// This part of the file contains all we need to benchmarck the
+/// euclidian distance. First of all, we have the calling functions
+/// that encapsulate the real call to geodesic routine. They bring us
+/// a clean place where starting and stopping the timer without any
+/// other code interference. Printing results could be done at this step.
+/// At least, we have the test routine that call the previous functions
+/// by passing arguments like different size of inputs and different
+/// neighbouring. The test routines save their results in gnuplot script shell
+/// file that enable to show charts.
+void influence_zone_euclidian_2d(mln::util::timer& timer,
+ const mln::image2d<mln::value::label_8>& input,
+ const mln::util::array<mln::point2d>& seed)
+{
+ mln::image2d<mln::value::label_8> output;
+
+ timer.start();
+
+ mln::initialize(output, input);
+
+ mln_piter_(mln::image2d<mln::value::label_8>) p(output.domain());
+ mln_eiter_(mln::util::array<mln::point2d>) e(seed);
+
+ for_all(p)
+ {
+ unsigned d = 0;
+ unsigned min_d = mln_max(unsigned);
+ unsigned min_l = 0;
+
+ for_all(e)
+ {
+ d = distance(p, seed(e.index_()));
+
+ if (min_d > d)
+ {
+ min_d = d;
+ min_l = input(e);
+ }
+ }
+
+ output(p) = min_l;
+ }
+
+ timer.stop();
+
+ //mln::io::pgm::save(output, "output.pgm");
+}
+
+
+void influence_zone_euclidian_3d(mln::util::timer& timer,
+ const mln::image3d<mln::value::label_8>& input,
+ const mln::util::array<mln::point3d>& seed)
+{
+ mln::image3d<mln::value::label_8> output;
+
+ timer.start();
+
+ mln::initialize(output, input);
+
+ mln_piter_(mln::image3d<mln::value::label_8>) p(output.domain());
+ mln_eiter_(mln::util::array<mln::point3d>) e(seed);
+
+ for_all(p)
+ {
+ unsigned d = 0;
+ unsigned min_d = mln_max(unsigned);
+ unsigned min_l = 0;
+
+ for_all(e)
+ {
+ d = distance(p, seed(e.index_()));
+
+ if (min_d > d)
+ {
+ min_d = d;
+ min_l = input(e);
+ }
+ }
+
+ output(p) = min_l;
+ }
+
+ timer.stop();
+}
+
+void test_influence_zone_euclidian_2d()
+{
+ mln::util::timer timer;
+/*
+ // Global test
+ mln::image2d<float> chart(mln::box2d(mln::point2d(0,0),
+ mln::point2d(16*16+2,256+1)));
+
+ mln::data::fill(chart, mln::literal::zero);
+
+ for (unsigned i = 1; i < 256+1; ++i) // size
+ for (unsigned j = 1; j < i*i && j < 16+1; ++j) // seed
+ {
+ influence_zone_euclidian_2d(timer,build_input2d(j,i),build_seed2d(j,i));
+ std::cout << "xxx|" << i << "x" << i
<< "|" << j << " = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart, j*j,i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart, "chart.sh");
+*/
+
+ // Test the number of labels
+ mln::image1d<float> chart_seed(16*16+2);
+
+ mln::data::fill(chart_seed, mln::literal::zero);
+
+ for (unsigned i = 1; i < 16+1; ++i)
+ {
+ influence_zone_euclidian_2d(timer,build_input2d(i,256),build_seed2d(i,256));
+ std::cout << "xxx|256x256|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed, i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed, "euclidian.2d.seed.sh");
+
+ // Test the size of the image
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size(256+1);
+
+ mln::data::fill(chart_size, mln::literal::zero);
+
+ for (unsigned i = 16; i < 256+1; ++i)
+ {
+ influence_zone_euclidian_2d(timer, build_input2d(4,i), build_seed2d(4,i));
+ std::cout << "xxx|" << i << "x" << i
<< "|16 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size, "euclidian.2d.size.sh");
+}
+
+void test_influence_zone_euclidian_3d()
+{
+ mln::util::timer timer;
+
+ // Test the number of labels
+ mln::image1d<float> chart_seed(5*5*5+2);
+
+ mln::data::fill(chart_seed, mln::literal::zero);
+
+ for (unsigned i = 1; i < 5+1; ++i)
+ {
+ influence_zone_euclidian_3d(timer,build_input3d(i,128),build_seed3d(i,128));
+ std::cout << "xxx|128x128x128|" << i << " = "
<< timer.read() << std::endl;
+ mln::opt::at(chart_seed, i*i*i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_seed, "euclidian.3d.seed.sh");
+
+ // Test the size of the image
+ // 1, 2, 4, 8, 16, 32, 64, 128, 256
+ mln::image1d<float> chart_size(128+1);
+
+ mln::data::fill(chart_size, mln::literal::zero);
+
+ for (unsigned i = 6; i < 128+1; ++i)
+ {
+ influence_zone_euclidian_3d(timer, build_input3d(2,i), build_seed3d(2,i));
+ std::cout << "xxx|" << i << "x" << i
<< "x" << i << "|8 = "
+ << timer.read() << std::endl;
+ mln::opt::at(chart_size, i) = timer.read();
+ }
+
+ mln::io::plot::save_image_sh(chart_size, "euclidian.3d.size.sh");
+}
+/// \}
+
+//------------------------------------------------------------------------------
+// Main
+//
+// Point de fonctionnement du système [image de taille entre 1 et 256]
+// Moins de 16 labels
+//
+//------------------------------------------------------------------------------
+
+/// \brief The main routine that call all the benchmark tests.
+///
+/// This benchmark aim at comparing different kind of distance. It
+/// looks after the influence geodesic, the influence front and
+/// euclidian distance. Many files are generated. Some rules exist to
+/// build the name of the file:
+/// distance.neighbouring.dimension.(size|seed). The distance could be
+/// the front distance (front), the geodesic distance (geodesic) or
+/// the euclidian distance (euclidian). The neighbouring could be c04
+/// or c08 in 2d, c06, c18 or c26 in 3d. The dimension could be 2d or 3d.
+/// Finally, the flag size or seed precises the nature of that test, increasing
+/// gradualy the size of the image or increasing gradualy the number of seeds.
+/// The file contains the time benchmark of the distance studied.
+///
+/// \fixme test_influence_zone_geodesic_3d doesn't compile.
+int main()
+{
+ test_influence_zone_euclidian_2d();
+ test_influence_zone_front_2d();
+ test_influence_zone_geodesic_2d();
+
+ // FIXME : It doesn't compile because of a bad calling function at_ in
+ // FIXME : the influence_zone_geodesic.hh line 127.
+ // test_influence_zone_geodesic_3d();
+ test_influence_zone_front_3d();
+ test_influence_zone_euclidian_3d();
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
b/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
new file mode 100644
index 0000000..4455a07
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean1d/Makefile.am
@@ -0,0 +1,153 @@
+#
+# Generic Makefile
+#
+
+#########
+# TOOLS #
+#########
+
+#LOADLIBES= -lboost_filesystem
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+CXXFLAGS= -ggdb -O0 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O1 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O3 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+ECHO= echo
+RM= rm
+MKDIR= mkdir -p
+CP= cp
+
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
+
+
+ifeq ($(findstring $(BUILD__PATTERN),$(PWD)), $(BUILD__PATTERN))
+# Case where make is done from build directory.
+SOURCE_DIR= $(subst $(BUILD__PATTERN),$(SOURCE_PATTERN),$(PWD))
+BUILD__DIR= $(PWD)/
+else
+# Case where make is done from source directory.
+SOURCE_DIR= $(PWD)/
+BUILD__DIR= $(subst $(SOURCE_PATTERN),$(BUILD__PATTERN),$(PWD))
+endif
+
+SRC= $(notdir $(wildcard $(SOURCE_DIR)/*.cc))
+OLD= $(notdir $(wildcard $(SOURCE_DIR)/*~))
+OBJ= $(patsubst %.cc,%.o,$(SRC))
+SOURCE_MAKEFILE=Makefile.am
+BUILD__MAKEFILE=Makefile
+TARGET_FILE= $(notdir $(PWD))
+SOURCE_FILES= $(notdir $(wildcard $(SOURCE_DIR)/*.*))
+BUILD__FILES= $(filter-out $(SRC) $(SOURCE_MAKEFILE), $(SOURCE_FILES))
+
+BUILD__F_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__FILES))
+SOURCE_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_FILES))
+
+BUILD__M_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__MAKEFILE))
+SOURCE_M_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_MAKEFILE))
+
+TARGET_F_PATH= $(addprefix $(BUILD__DIR)/,$(TARGET_FILE))
+OBJ_F_PATH= $(addprefix $(BUILD__DIR)/,$(OBJ))
+SRC_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SRC))
+OLD_F_PATH= $(addprefix $(SOURCE_DIR)/,$(OLD))
+
+#############
+# BOOTSTRAP #
+#############
+
+
+bootstrap: $(BUILD__DIR) $(BUILD__F_PATH) $(BUILD__M_PATH)
+
+# Create, if nessary, the destination directory
+$(BUILD__DIR):
+ $(MKDIR) $(BUILD__DIR)
+
+# Copy, if nessary, all the files, except the Makefile.am
+$(BUILD__F_PATH): $(SOURCE_F_PATH)
+ $(CP) $(addprefix $(SOURCE_DIR),$(@F)) $@
+
+# Copy if nessary, the Makefile.am into Makefile
+$(BUILD__M_PATH): $(SOURCE_M_PATH)
+ $(CP) $(SOURCE_M_PATH) $(BUILD__M_PATH)
+
+
+#######
+# ALL #
+#######
+
+# We assume that the call is done from the build directory.
+# With the directive vpath, hidden files are found in the source directory.
+
+all: $(TARGET_F_PATH)
+
+
+$(TARGET_F_PATH): $(OBJ_F_PATH)
+ $(LINK.cc) $< $(LOADLIBES) $(LDLIBS) -o $@
+
+$(OBJ_F_PATH):$(SRC_F_PATH)
+ $(COMPILE.cc) $(OUTPUT_OPTION) $<
+
+
+#########
+# CLEAN #
+#########
+
+# Force every time the deletion
+clean: clean_target clean_obj clean_dst clean_old #clean_make
+
+
+clean_target:
+ -@$(RM) $(TARGET_F_PATH) &> /dev/null
+
+clean_obj:
+ -@$(RM) $(OBJ_F_PATH) &> /dev/null
+
+clean_dst:
+ -@$(RM) $(BUILD_F_PATH) &> /dev/null
+
+clean_make:
+ -@$(RM) $(BUILD_M_PATH) &> /dev/null
+
+clean_old:
+ -@$(RM) $(OLD_F_PATH) &> /dev/null
+
+
+#########
+# PRINT #
+#########
+
+print: print_tools print_bootstrap
+
+print_tools:
+ @$(ECHO) "HOME = $(HOME)"
+ @$(ECHO) "INCLUDES = $(INCLUDES)"
+ @$(ECHO) "CXXFLAGS = $(CXXFLAGS)"
+ @$(ECHO) "ECHO = $(ECHO)"
+ @$(ECHO) "RM = $(RM)"
+ @$(ECHO) "MKDIR = $(MKDIR)"
+ @$(ECHO) "CP = $(CP)"
+ @$(ECHO)
+
+print_bootstrap:
+ @$(ECHO) "PWD = $(PWD)"
+ @$(ECHO) "SOURCE_PATTERN = $(SOURCE_PATTERN)"
+ @$(ECHO) "BUILD__PATTERN = $(BUILD__PATTERN)"
+ @$(ECHO) "SOURCE_DIR = $(SOURCE_DIR)"
+ @$(ECHO) "BUILD__DIR = $(BUILD__DIR)"
+ @$(ECHO) "SOURCE_MAKEFILE = $(SOURCE_MAKEFILE)"
+ @$(ECHO) "BUILD__MAKEFILE = $(BUILD__MAKEFILE)"
+ @$(ECHO) "TARGET_FILE = $(TARGET_FILE)"
+ @$(ECHO) "SOURCE_FILES = $(SOURCE_FILES)"
+ @$(ECHO) "SOURCE_F_PATH = $(SOURCE_F_PATH)"
+ @$(ECHO) "BUILD__FILES = $(BUILD__FILES)"
+ @$(ECHO) "BUILD__F_PATH = $(BUILD__F_PATH)"
+ @$(ECHO) "BUILD__M_PATH = $(BUILD__M_PATH)"
+ @$(ECHO) "SOURCE_M_PATH = $(SOURCE_M_PATH)"
+ @$(ECHO) "SRC = $(SRC)"
+ @$(ECHO) "OBJ = $(OBJ)"
+ @$(ECHO) "OLD = $(OLD)"
+ @$(ECHO) "SRC_F_PATH = $(SRC_F_PATH)"
+ @$(ECHO) "OBJ_F_PATH = $(OBJ_F_PATH)"
+ @$(ECHO) "OLD_F_PATH = $(OLD_F_PATH)"
+ @$(ECHO)
diff --git a/scribo/sandbox/green/demo/clustering/kmean1d/kmean1d.cc
b/scribo/sandbox/green/demo/clustering/kmean1d/kmean1d.cc
new file mode 100644
index 0000000..22eae91
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean1d/kmean1d.cc
@@ -0,0 +1,258 @@
+// 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 This is a demonstrator for kmean1d.
+///
+/// The demonstrator produces five kind of results. The file
+/// "color.ppm" allow us to localize the different center in the
+/// image. There is an equivalent file "label.pgm" that's do the same
+/// thing but inplace of a specific color, it gives the label of each
+/// center. It's quit easy with xv, to transform the label image in
+/// the color one. The file "mean.pgm" replaces each label by the mean
+/// of the points that contributate to their center. It is a kind of
+/// abstraction of the reality of the image, of its complexity. In
+/// file "variance_cnv.sh" abscissa axis stands for the convergence
+/// evolution and the ordinate axis for each runs. The "mean_cnv.sh"
+/// file shows the evolution of the centers, whatever the run. The
+/// x-axis represents the id of the center, the y-axis the iteration
+/// in the convergence process and the z-axis the id of the particular
+/// run. The graphic is very bad, but textual interpretation is still
+/// available.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/img_path.hh>
+
+#include <mln/clustering/kmean1d.hh>
+
+#include <mln/core/image/image2d.hh>
+
+#include <mln/io/pgm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/ppm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/int_u8.hh>
+
+
+/// \brief The real code for launching the kmean optimised algorithm.
+///
+/// \param[in] image : the 8 bits greylevel image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// This is the real lauching code. In fact, the stuff consists in loading the
+/// image, setting the parameters, calling the routine, extracting the results
+/// and saving them for the user.
+///
+/// \fixme The result is not safe because we don't test kmean.is_valid()
+
+void do_demo(const std::string& image,
+ const unsigned k_center,
+ const unsigned n_times,
+ const unsigned watch_dog)
+{
+ typedef mln::clustering::kmean1d<double,8> t_kmean;
+ typedef mln::value::int_u8 t_int_u8;
+ typedef mln::image2d<t_int_u8> t_image2d_int_u8;
+
+ t_image2d_int_u8 img;
+
+ mln::io::pgm::load(img, image.c_str());
+
+ t_kmean kmean(img,
+ k_center,
+ watch_dog,
+ n_times);
+
+ //mln::trace::quiet = false;
+
+ kmean.launch_n_times();
+
+ // FIXME : Not safe because we don't test kmean.is_valid()
+
+ t_kmean::t_color_dbg color_img = kmean.get_color_dbg();
+ t_kmean::t_mean_dbg mean_img = kmean.get_mean_dbg();
+ t_kmean::t_label_dbg label_img = kmean.get_label_dbg();
+ t_kmean::t_variance_cnv var_cnv = kmean.get_variance_cnv();
+ t_kmean::t_mean_cnv mean_cnv = kmean.get_mean_cnv();
+
+ mln::io::pgm::save(mean_img, "mean.pgm");
+ mln::io::ppm::save(color_img, "color.ppm");
+ mln::io::pgm::save(label_img, "label.pgm");
+
+ mln::io::plot::save_image_sh(mean_cnv, "mean_cnv.sh");
+ mln::io::plot::save_image_sh(var_cnv, "variance_cnv.sh");
+}
+
+
+/// \brief Front hand for the demonstrator.
+///
+/// \param[in] image : the 8 bits greylevel image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// The front hand enables the setting of the default values for the
+/// parameters. it allows us to print the real parameter set used by
+/// the demonstrator.
+void demo(const std::string& image = OLENA_IMG_PATH"/house.pgm",
+ const unsigned k_center = 3,
+ const unsigned n_times = 10,
+ const unsigned watch_dog = 10)
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "Launching the demo with these parameters" <<
std::endl;
+ std::cout << "image : " << image <<
std::endl;
+ std::cout << "k_center : " << k_center <<
std::endl;
+ std::cout << "n_times : " << n_times <<
std::endl;
+ std::cout << "watch_dog : " << watch_dog <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+
+ do_demo(image, k_center, n_times, watch_dog);
+}
+
+
+/// \brief Convert character get in the input stream to unsigned integer.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_unsigned(const bool status, const char *arg, unsigned& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ result = !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Convert character get in the input stream to string.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_string(const bool status, const char *arg, std::string& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ return !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Print usage recommandation for this binary.
+///
+/// \param[in] argc : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+void usage(const int argc, const char *args[])
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "argc : " << argc <<
std::endl;
+
+ for (int i = 0; i < argc; ++i)
+ std::cout << "args[" << i << "] : " <<
args[i] << std::endl;
+
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "usage: kmean1d [image [k_center [n_times [watch_dog]]]]"
+ << std::endl;
+ std::cout << "pbm image (points to work with)" <<
std::endl;
+ std::cout << "unsigned k_center (number of centers)" <<
std::endl;
+ std::cout << "unsigned n_times (number of launching)" <<
std::endl;
+ std::cout << "unsigned watch_dog (convergence loop)" <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+}
+
+
+/// \brief The main routine launchs the kmean optimised algoritm.
+///
+/// \param[in] image : the 8 bits greylevel image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// All the parameters are optional, but we must respect strictly a
+/// specific order. In fact, we can launch five programs with some
+/// default parameters: demo(), demo(image), demo(image,k_center),
+/// demo(image,k_center,n_times) and
+/// demo(image,k_center,n_times,watch_dog).
+int main(const int argc, const char *args[])
+{
+ std::string image("top");
+ unsigned k_center;
+ unsigned watch_dog;
+ unsigned n_times;
+ bool status = true;
+
+ switch (argc)
+ {
+ case 5: status = char_to_unsigned(status, args[4], watch_dog);
+ case 4: status = char_to_unsigned(status, args[3], n_times);
+ case 3: status = char_to_unsigned(status, args[2], k_center);
+ case 2: status = char_to_string(status, args[1], image); break;
+ case 1: status = true; break;
+ default: status = false;
+ }
+
+ if (status)
+ {
+ switch (argc)
+ {
+ case 1: demo(); break;
+ case 2: demo(image); break;
+ case 3: demo(image, k_center); break;
+ case 4: demo(image, k_center, n_times); break;
+ case 5: demo(image, k_center, n_times, watch_dog); break;
+ }
+ }
+ else
+ usage(argc, args);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean2d/Makefile.am
b/scribo/sandbox/green/demo/clustering/kmean2d/Makefile.am
new file mode 100644
index 0000000..4455a07
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean2d/Makefile.am
@@ -0,0 +1,153 @@
+#
+# Generic Makefile
+#
+
+#########
+# TOOLS #
+#########
+
+#LOADLIBES= -lboost_filesystem
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+CXXFLAGS= -ggdb -O0 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O1 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O3 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+ECHO= echo
+RM= rm
+MKDIR= mkdir -p
+CP= cp
+
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
+
+
+ifeq ($(findstring $(BUILD__PATTERN),$(PWD)), $(BUILD__PATTERN))
+# Case where make is done from build directory.
+SOURCE_DIR= $(subst $(BUILD__PATTERN),$(SOURCE_PATTERN),$(PWD))
+BUILD__DIR= $(PWD)/
+else
+# Case where make is done from source directory.
+SOURCE_DIR= $(PWD)/
+BUILD__DIR= $(subst $(SOURCE_PATTERN),$(BUILD__PATTERN),$(PWD))
+endif
+
+SRC= $(notdir $(wildcard $(SOURCE_DIR)/*.cc))
+OLD= $(notdir $(wildcard $(SOURCE_DIR)/*~))
+OBJ= $(patsubst %.cc,%.o,$(SRC))
+SOURCE_MAKEFILE=Makefile.am
+BUILD__MAKEFILE=Makefile
+TARGET_FILE= $(notdir $(PWD))
+SOURCE_FILES= $(notdir $(wildcard $(SOURCE_DIR)/*.*))
+BUILD__FILES= $(filter-out $(SRC) $(SOURCE_MAKEFILE), $(SOURCE_FILES))
+
+BUILD__F_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__FILES))
+SOURCE_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_FILES))
+
+BUILD__M_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__MAKEFILE))
+SOURCE_M_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_MAKEFILE))
+
+TARGET_F_PATH= $(addprefix $(BUILD__DIR)/,$(TARGET_FILE))
+OBJ_F_PATH= $(addprefix $(BUILD__DIR)/,$(OBJ))
+SRC_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SRC))
+OLD_F_PATH= $(addprefix $(SOURCE_DIR)/,$(OLD))
+
+#############
+# BOOTSTRAP #
+#############
+
+
+bootstrap: $(BUILD__DIR) $(BUILD__F_PATH) $(BUILD__M_PATH)
+
+# Create, if nessary, the destination directory
+$(BUILD__DIR):
+ $(MKDIR) $(BUILD__DIR)
+
+# Copy, if nessary, all the files, except the Makefile.am
+$(BUILD__F_PATH): $(SOURCE_F_PATH)
+ $(CP) $(addprefix $(SOURCE_DIR),$(@F)) $@
+
+# Copy if nessary, the Makefile.am into Makefile
+$(BUILD__M_PATH): $(SOURCE_M_PATH)
+ $(CP) $(SOURCE_M_PATH) $(BUILD__M_PATH)
+
+
+#######
+# ALL #
+#######
+
+# We assume that the call is done from the build directory.
+# With the directive vpath, hidden files are found in the source directory.
+
+all: $(TARGET_F_PATH)
+
+
+$(TARGET_F_PATH): $(OBJ_F_PATH)
+ $(LINK.cc) $< $(LOADLIBES) $(LDLIBS) -o $@
+
+$(OBJ_F_PATH):$(SRC_F_PATH)
+ $(COMPILE.cc) $(OUTPUT_OPTION) $<
+
+
+#########
+# CLEAN #
+#########
+
+# Force every time the deletion
+clean: clean_target clean_obj clean_dst clean_old #clean_make
+
+
+clean_target:
+ -@$(RM) $(TARGET_F_PATH) &> /dev/null
+
+clean_obj:
+ -@$(RM) $(OBJ_F_PATH) &> /dev/null
+
+clean_dst:
+ -@$(RM) $(BUILD_F_PATH) &> /dev/null
+
+clean_make:
+ -@$(RM) $(BUILD_M_PATH) &> /dev/null
+
+clean_old:
+ -@$(RM) $(OLD_F_PATH) &> /dev/null
+
+
+#########
+# PRINT #
+#########
+
+print: print_tools print_bootstrap
+
+print_tools:
+ @$(ECHO) "HOME = $(HOME)"
+ @$(ECHO) "INCLUDES = $(INCLUDES)"
+ @$(ECHO) "CXXFLAGS = $(CXXFLAGS)"
+ @$(ECHO) "ECHO = $(ECHO)"
+ @$(ECHO) "RM = $(RM)"
+ @$(ECHO) "MKDIR = $(MKDIR)"
+ @$(ECHO) "CP = $(CP)"
+ @$(ECHO)
+
+print_bootstrap:
+ @$(ECHO) "PWD = $(PWD)"
+ @$(ECHO) "SOURCE_PATTERN = $(SOURCE_PATTERN)"
+ @$(ECHO) "BUILD__PATTERN = $(BUILD__PATTERN)"
+ @$(ECHO) "SOURCE_DIR = $(SOURCE_DIR)"
+ @$(ECHO) "BUILD__DIR = $(BUILD__DIR)"
+ @$(ECHO) "SOURCE_MAKEFILE = $(SOURCE_MAKEFILE)"
+ @$(ECHO) "BUILD__MAKEFILE = $(BUILD__MAKEFILE)"
+ @$(ECHO) "TARGET_FILE = $(TARGET_FILE)"
+ @$(ECHO) "SOURCE_FILES = $(SOURCE_FILES)"
+ @$(ECHO) "SOURCE_F_PATH = $(SOURCE_F_PATH)"
+ @$(ECHO) "BUILD__FILES = $(BUILD__FILES)"
+ @$(ECHO) "BUILD__F_PATH = $(BUILD__F_PATH)"
+ @$(ECHO) "BUILD__M_PATH = $(BUILD__M_PATH)"
+ @$(ECHO) "SOURCE_M_PATH = $(SOURCE_M_PATH)"
+ @$(ECHO) "SRC = $(SRC)"
+ @$(ECHO) "OBJ = $(OBJ)"
+ @$(ECHO) "OLD = $(OLD)"
+ @$(ECHO) "SRC_F_PATH = $(SRC_F_PATH)"
+ @$(ECHO) "OBJ_F_PATH = $(OBJ_F_PATH)"
+ @$(ECHO) "OLD_F_PATH = $(OLD_F_PATH)"
+ @$(ECHO)
diff --git a/scribo/sandbox/green/demo/clustering/kmean2d/kmean2d.cc
b/scribo/sandbox/green/demo/clustering/kmean2d/kmean2d.cc
new file mode 100644
index 0000000..2538dce
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean2d/kmean2d.cc
@@ -0,0 +1,278 @@
+// 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 This is a demonstrator for kmean2d.
+///
+/// The demonstrator produces five kind of results. The file
+/// "color.ppm" allow us to localize the different center in the
+/// image. There is an equivalent file "label.pgm" that's do the same
+/// thing but inplace of a specific color, it gives the label of each
+/// center. It's quit easy with xv, to transform the label image in
+/// the color one. The file "mean.pgm" replaces each label by the mean
+/// of the points that contributate to their center. It is a kind of
+/// abstraction of the reality of the image, of its complexity. The
+/// "variance_cnv.sh" changes its representation and becomes more
+/// readable. The "mean_cnv.sh" have got a generation problem. We can
+/// bypass it by adding printing lines in the 'splot'
+/// instruction. However, the graphic is correct and mainly shows the
+/// convergence of the center value. Finally, as the work takes place in
+/// the r/g space, the "point.ppm" file shows us the exact input space.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/img_path.hh>
+
+#include <mln/clustering/kmean2d.hh>
+
+#include <mln/core/image/image2d.hh>
+
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb_to_rg.hh>
+#include <mln/fun/v2v/rg_to_rgb.hh>
+
+#include <mln/io/pgm/save.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/io/ppm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/rg.hh>
+#include <mln/value/rgb8.hh>
+
+
+/// \brief The real code for launching the kmean optimised algorithm.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// This is the real lauching code. In fact, the stuff consists in loading the
+/// image, setting the parameters, calling the routine, extracting the results
+/// and saving them for the user.
+///
+/// \fixme The result is not safe because we don't test kmean.is_valid()
+void do_demo(const std::string& image,
+ const unsigned k_center,
+ const unsigned n_times,
+ const unsigned watch_dog)
+{
+ typedef mln::clustering::kmean2d<double,8> t_kmean;
+ typedef mln::value::rg<8> t_rg8;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rg8> t_image2d_rg8;
+ typedef mln::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+ typedef mln::fun::v2v::rg_to_rgb<8> t_rg_to_rgb;
+
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rgb8 point_img_rgb8;
+ t_image2d_rgb8 mean_img_rgb8;
+ t_image2d_rgb8 mean_dbg_rgb8;
+ t_image2d_rg8 img_rg8;
+
+ // Read input.
+ mln::io::ppm::load(img_rgb8, image.c_str());
+ img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+
+ // Call kmean.
+ t_kmean kmean(img_rg8, k_center, watch_dog, n_times);
+
+ mln::trace::quiet = false;
+ kmean.launch_n_times();
+
+ // FIXME : Not safe because we don't test kmean.is_valid()
+
+ // Get outputs.
+ t_kmean::t_point_img point_img = kmean.get_point();
+ t_kmean::t_color_dbg color_img = kmean.get_color_dbg();
+ t_kmean::t_mean_dbg mean_img = kmean.get_mean_dbg();
+ t_kmean::t_label_dbg label_img = kmean.get_label_dbg();
+ t_kmean::t_variance_cnv variance_cnv = kmean.get_variance_cnv();
+ t_kmean::t_mean_cnv mean_cnv = kmean.get_mean_cnv();
+
+ // Convert outputs.
+ point_img_rgb8 = mln::data::transform(point_img, t_rg_to_rgb());
+ mean_img_rgb8 = mln::data::transform(mean_img, t_rg_to_rgb());
+
+ mln::io::ppm::save(mean_img_rgb8, "mean.ppm");
+ mln::io::ppm::save(color_img, "color.ppm");
+ mln::io::pgm::save(label_img, "label.pgm");
+ mln::io::ppm::save(point_img_rgb8, "point.ppm");
+
+ mln::io::plot::save_image_sh(mean_cnv, "mean_cnv.sh");
+ mln::io::plot::save_image_sh(variance_cnv, "variance_cnv.sh");
+}
+
+
+/// \brief Front hand for the demonstrator.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// The front hand enables the setting of the default values for the
+/// parameters. it allows us to print the real parameter set used by
+/// the demonstrator.
+void demo(const std::string& image = OLENA_IMG_PATH"/house.ppm",
+ const unsigned k_center = 3,
+ const unsigned n_times = 10,
+ const unsigned watch_dog = 10)
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "Launching the demo with these parameters" <<
std::endl;
+ std::cout << "image : " << image <<
std::endl;
+ std::cout << "k_center : " << k_center <<
std::endl;
+ std::cout << "n_times : " << n_times <<
std::endl;
+ std::cout << "watch_dog : " << watch_dog <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+
+ do_demo(image, k_center, n_times, watch_dog);
+}
+
+
+/// \brief Convert character get in the input stream to unsigned integer.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_unsigned(const bool status, const char *arg, unsigned& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ result = !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Convert character get in the input stream to string.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_string(const bool status, const char *arg, std::string& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ return !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Print usage recommandation for this binary.
+///
+/// \param[in] argc : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+void usage(const int argc, const char *args[])
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "argc : " << argc <<
std::endl;
+
+ for (int i = 0; i < argc; ++i)
+ std::cout << "args[" << i << "] : " <<
args[i] << std::endl;
+
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "usage: kmean2d [image [k_center [n_times [watch_dog]]]]"
+ << std::endl;
+ std::cout << "ppm image (points to work with)" <<
std::endl;
+ std::cout << "unsigned k_center (number of centers)" <<
std::endl;
+ std::cout << "unsigned n_times (number of launching)" <<
std::endl;
+ std::cout << "unsigned watch_dog (convergence loop)" <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+}
+
+
+/// \brief The main routine launchs the kmean optimised algoritm.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// All the parameters are optional, but we must respect strictly a
+/// specific order. In fact, we can launch five programs with some
+/// default parameters: demo(), demo(image), demo(image,k_center),
+/// demo(image,k_center,n_times) and
+/// demo(image,k_center,n_times,watch_dog).
+int main(const int argc, const char *args[])
+{
+ std::string image("top");
+ unsigned k_center;
+ unsigned watch_dog;
+ unsigned n_times;
+ bool status = true;
+
+ switch (argc)
+ {
+ case 5: status = char_to_unsigned(status, args[4], watch_dog);
+ case 4: status = char_to_unsigned(status, args[3], n_times);
+ case 3: status = char_to_unsigned(status, args[2], k_center);
+ case 2: status = char_to_string(status, args[1], image); break;
+ case 1: status = true; break;
+ default: status = false;
+ }
+
+ if (status)
+ {
+ switch (argc)
+ {
+ case 1: demo(); break;
+ case 2: demo(image); break;
+ case 3: demo(image, k_center); break;
+ case 4: demo(image, k_center, n_times); break;
+ case 5: demo(image, k_center, n_times, watch_dog); break;
+ }
+ }
+ else
+ usage(argc, args);
+
+ return 0;
+}
+
diff --git a/scribo/sandbox/green/demo/clustering/kmean3d/Makefile.am
b/scribo/sandbox/green/demo/clustering/kmean3d/Makefile.am
new file mode 100644
index 0000000..4455a07
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean3d/Makefile.am
@@ -0,0 +1,153 @@
+#
+# Generic Makefile
+#
+
+#########
+# TOOLS #
+#########
+
+#LOADLIBES= -lboost_filesystem
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+CXXFLAGS= -ggdb -O0 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O1 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O3 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+ECHO= echo
+RM= rm
+MKDIR= mkdir -p
+CP= cp
+
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
+
+
+ifeq ($(findstring $(BUILD__PATTERN),$(PWD)), $(BUILD__PATTERN))
+# Case where make is done from build directory.
+SOURCE_DIR= $(subst $(BUILD__PATTERN),$(SOURCE_PATTERN),$(PWD))
+BUILD__DIR= $(PWD)/
+else
+# Case where make is done from source directory.
+SOURCE_DIR= $(PWD)/
+BUILD__DIR= $(subst $(SOURCE_PATTERN),$(BUILD__PATTERN),$(PWD))
+endif
+
+SRC= $(notdir $(wildcard $(SOURCE_DIR)/*.cc))
+OLD= $(notdir $(wildcard $(SOURCE_DIR)/*~))
+OBJ= $(patsubst %.cc,%.o,$(SRC))
+SOURCE_MAKEFILE=Makefile.am
+BUILD__MAKEFILE=Makefile
+TARGET_FILE= $(notdir $(PWD))
+SOURCE_FILES= $(notdir $(wildcard $(SOURCE_DIR)/*.*))
+BUILD__FILES= $(filter-out $(SRC) $(SOURCE_MAKEFILE), $(SOURCE_FILES))
+
+BUILD__F_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__FILES))
+SOURCE_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_FILES))
+
+BUILD__M_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__MAKEFILE))
+SOURCE_M_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_MAKEFILE))
+
+TARGET_F_PATH= $(addprefix $(BUILD__DIR)/,$(TARGET_FILE))
+OBJ_F_PATH= $(addprefix $(BUILD__DIR)/,$(OBJ))
+SRC_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SRC))
+OLD_F_PATH= $(addprefix $(SOURCE_DIR)/,$(OLD))
+
+#############
+# BOOTSTRAP #
+#############
+
+
+bootstrap: $(BUILD__DIR) $(BUILD__F_PATH) $(BUILD__M_PATH)
+
+# Create, if nessary, the destination directory
+$(BUILD__DIR):
+ $(MKDIR) $(BUILD__DIR)
+
+# Copy, if nessary, all the files, except the Makefile.am
+$(BUILD__F_PATH): $(SOURCE_F_PATH)
+ $(CP) $(addprefix $(SOURCE_DIR),$(@F)) $@
+
+# Copy if nessary, the Makefile.am into Makefile
+$(BUILD__M_PATH): $(SOURCE_M_PATH)
+ $(CP) $(SOURCE_M_PATH) $(BUILD__M_PATH)
+
+
+#######
+# ALL #
+#######
+
+# We assume that the call is done from the build directory.
+# With the directive vpath, hidden files are found in the source directory.
+
+all: $(TARGET_F_PATH)
+
+
+$(TARGET_F_PATH): $(OBJ_F_PATH)
+ $(LINK.cc) $< $(LOADLIBES) $(LDLIBS) -o $@
+
+$(OBJ_F_PATH):$(SRC_F_PATH)
+ $(COMPILE.cc) $(OUTPUT_OPTION) $<
+
+
+#########
+# CLEAN #
+#########
+
+# Force every time the deletion
+clean: clean_target clean_obj clean_dst clean_old #clean_make
+
+
+clean_target:
+ -@$(RM) $(TARGET_F_PATH) &> /dev/null
+
+clean_obj:
+ -@$(RM) $(OBJ_F_PATH) &> /dev/null
+
+clean_dst:
+ -@$(RM) $(BUILD_F_PATH) &> /dev/null
+
+clean_make:
+ -@$(RM) $(BUILD_M_PATH) &> /dev/null
+
+clean_old:
+ -@$(RM) $(OLD_F_PATH) &> /dev/null
+
+
+#########
+# PRINT #
+#########
+
+print: print_tools print_bootstrap
+
+print_tools:
+ @$(ECHO) "HOME = $(HOME)"
+ @$(ECHO) "INCLUDES = $(INCLUDES)"
+ @$(ECHO) "CXXFLAGS = $(CXXFLAGS)"
+ @$(ECHO) "ECHO = $(ECHO)"
+ @$(ECHO) "RM = $(RM)"
+ @$(ECHO) "MKDIR = $(MKDIR)"
+ @$(ECHO) "CP = $(CP)"
+ @$(ECHO)
+
+print_bootstrap:
+ @$(ECHO) "PWD = $(PWD)"
+ @$(ECHO) "SOURCE_PATTERN = $(SOURCE_PATTERN)"
+ @$(ECHO) "BUILD__PATTERN = $(BUILD__PATTERN)"
+ @$(ECHO) "SOURCE_DIR = $(SOURCE_DIR)"
+ @$(ECHO) "BUILD__DIR = $(BUILD__DIR)"
+ @$(ECHO) "SOURCE_MAKEFILE = $(SOURCE_MAKEFILE)"
+ @$(ECHO) "BUILD__MAKEFILE = $(BUILD__MAKEFILE)"
+ @$(ECHO) "TARGET_FILE = $(TARGET_FILE)"
+ @$(ECHO) "SOURCE_FILES = $(SOURCE_FILES)"
+ @$(ECHO) "SOURCE_F_PATH = $(SOURCE_F_PATH)"
+ @$(ECHO) "BUILD__FILES = $(BUILD__FILES)"
+ @$(ECHO) "BUILD__F_PATH = $(BUILD__F_PATH)"
+ @$(ECHO) "BUILD__M_PATH = $(BUILD__M_PATH)"
+ @$(ECHO) "SOURCE_M_PATH = $(SOURCE_M_PATH)"
+ @$(ECHO) "SRC = $(SRC)"
+ @$(ECHO) "OBJ = $(OBJ)"
+ @$(ECHO) "OLD = $(OLD)"
+ @$(ECHO) "SRC_F_PATH = $(SRC_F_PATH)"
+ @$(ECHO) "OBJ_F_PATH = $(OBJ_F_PATH)"
+ @$(ECHO) "OLD_F_PATH = $(OLD_F_PATH)"
+ @$(ECHO)
diff --git a/scribo/sandbox/green/demo/clustering/kmean3d/kmean3d.cc
b/scribo/sandbox/green/demo/clustering/kmean3d/kmean3d.cc
new file mode 100644
index 0000000..0e2b16e
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean3d/kmean3d.cc
@@ -0,0 +1,265 @@
+// 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 This is a demonstrator for kmean3d.
+///
+/// The demonstrator produces five kind of results. The file
+/// "color.ppm" allow us to localize the different center in the
+/// image. There is an equivalent file "label.pgm" that's do the same
+/// thing but inplace of a specific color, it gives the label of each
+/// center. It's quit easy with xv, to transform the label image in
+/// the color one. The file "mean.pgm" replaces each label by the mean
+/// of the points that contributate to their center. It is a kind of
+/// abstraction of the reality of the image, of its complexity. The
+/// "variance_cnv.sh" changes its representation and becomes more
+/// readable. The "mean_cnv.sh" have got a generation problem. We can
+/// bypass it by adding printing lines in the 'splot'
+/// instruction. However, the graphic is correct and mainly shows the
+/// convergence of the center value.
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/clustering/kmean3d.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/image/image2d.hh>
+
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/ppm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/label_8.hh>
+#include <mln/value/rgb8.hh>
+
+
+/// \brief The real code for launching the kmean optimised algorithm.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// This is the real lauching code. In fact, the stuff consists in loading the
+/// image, setting the parameters, calling the routine, extracting the results
+/// and saving them for the user.
+///
+/// \fixme The result is not safe because we don't test kmean.is_valid()
+void do_demo(const std::string& image,
+ const unsigned k_center,
+ const unsigned n_times,
+ const unsigned watch_dog)
+{
+ typedef mln::clustering::kmean3d<double,5> t_kmean;
+ typedef mln::value::label_8 t_label_8;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::value::rgb<5> t_rgb5;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rgb5> t_image2d_rgb5;
+
+ t_image2d_rgb8 house_rgb8;
+ t_image2d_rgb5 house_rgb5;
+
+ mln::io::ppm::load(house_rgb8, image.c_str());
+ house_rgb5=mln::data::transform(house_rgb8,mln::fun::v2v::rgb8_to_rgbn<5>());
+
+ t_kmean kmean(house_rgb5, k_center, watch_dog, n_times);
+
+ mln::trace::quiet = false;
+
+ kmean.launch_n_times();
+
+ // FIXME : Not safe because we don't test kmean.is_valid()
+
+ t_kmean::t_color_dbg color_img = kmean.get_color_dbg();
+ t_kmean::t_mean_dbg mean_img = kmean.get_mean_dbg();
+ t_kmean::t_label_dbg label_img = kmean.get_label_dbg();
+ t_kmean::t_variance_cnv variance_cnv = kmean.get_variance_cnv();
+ t_kmean::t_mean_cnv mean_cnv = kmean.get_mean_cnv();
+
+ mln::io::ppm::save(mean_img, "mean.ppm");
+ mln::io::ppm::save(color_img, "color.ppm");
+ mln::io::pgm::save(label_img, "label.pgm");
+
+ mln::io::plot::save_image_sh(mean_img, "mean.sh");
+ mln::io::plot::save_image_sh(mean_cnv, "mean_cnv.sh");
+ mln::io::plot::save_image_sh(variance_cnv, "variance_cnv.sh");
+}
+
+/// \brief Front hand for the demonstrator.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// The front hand enables the setting of the default values for the
+/// parameters. it allows us to print the real parameter set used by
+/// the demonstrator.
+void demo(const std::string& image = OLENA_IMG_PATH"/house.ppm",
+ const unsigned k_center = 3,
+ const unsigned n_times = 10,
+ const unsigned watch_dog = 10)
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "Launching the demo with these parameters" <<
std::endl;
+ std::cout << "image : " << image <<
std::endl;
+ std::cout << "k_center : " << k_center <<
std::endl;
+ std::cout << "n_times : " << n_times <<
std::endl;
+ std::cout << "watch_dog : " << watch_dog <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+
+ do_demo(image, k_center, n_times, watch_dog);
+}
+
+
+/// \brief Convert character get in the input stream to unsigned integer.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_unsigned(const bool status, const char *arg, unsigned& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ result = !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Convert character get in the input stream to string.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_string(const bool status, const char *arg, std::string& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ return !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Print usage recommandation for this binary.
+///
+/// \param[in] argc : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+void usage(const int argc, const char *args[])
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "argc : " << argc <<
std::endl;
+
+ for (int i = 0; i < argc; ++i)
+ std::cout << "args[" << i << "] : " <<
args[i] << std::endl;
+
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "usage: kmean1d [image [k_center [n_times [watch_dog]]]]"
+ << std::endl;
+ std::cout << "pbm image (points to work with)" <<
std::endl;
+ std::cout << "unsigned k_center (number of centers)" <<
std::endl;
+ std::cout << "unsigned n_times (number of launching)" <<
std::endl;
+ std::cout << "unsigned watch_dog (convergence loop)" <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+}
+
+
+/// \brief The main routine launchs the kmean optimised algoritm.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// All the parameters are optional, but we must respect strictly a
+/// specific order. In fact, we can launch five programs with some
+/// default parameters: demo(), demo(image), demo(image,k_center),
+/// demo(image,k_center,n_times) and
+/// demo(image,k_center,n_times,watch_dog).
+int main(const int argc, const char *args[])
+{
+ std::string image("top");
+ unsigned k_center;
+ unsigned watch_dog;
+ unsigned n_times;
+ bool status = true;
+
+ switch (argc)
+ {
+ case 5: status = char_to_unsigned(status, args[4], watch_dog);
+ case 4: status = char_to_unsigned(status, args[3], n_times);
+ case 3: status = char_to_unsigned(status, args[2], k_center);
+ case 2: status = char_to_string(status, args[1], image); break;
+ case 1: status = true; break;
+ default: status = false;
+ }
+
+ if (status)
+ {
+ switch (argc)
+ {
+ case 1: demo(); break;
+ case 2: demo(image); break;
+ case 3: demo(image, k_center); break;
+ case 4: demo(image, k_center, n_times); break;
+ case 5: demo(image, k_center, n_times, watch_dog); break;
+ }
+ }
+ else
+ usage(argc, args);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/demo/clustering/kmean_rgb/Makefile.am
b/scribo/sandbox/green/demo/clustering/kmean_rgb/Makefile.am
new file mode 100644
index 0000000..4455a07
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean_rgb/Makefile.am
@@ -0,0 +1,153 @@
+#
+# Generic Makefile
+#
+
+#########
+# TOOLS #
+#########
+
+#LOADLIBES= -lboost_filesystem
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+CXXFLAGS= -ggdb -O0 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O1 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O3 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+ECHO= echo
+RM= rm
+MKDIR= mkdir -p
+CP= cp
+
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
+
+
+ifeq ($(findstring $(BUILD__PATTERN),$(PWD)), $(BUILD__PATTERN))
+# Case where make is done from build directory.
+SOURCE_DIR= $(subst $(BUILD__PATTERN),$(SOURCE_PATTERN),$(PWD))
+BUILD__DIR= $(PWD)/
+else
+# Case where make is done from source directory.
+SOURCE_DIR= $(PWD)/
+BUILD__DIR= $(subst $(SOURCE_PATTERN),$(BUILD__PATTERN),$(PWD))
+endif
+
+SRC= $(notdir $(wildcard $(SOURCE_DIR)/*.cc))
+OLD= $(notdir $(wildcard $(SOURCE_DIR)/*~))
+OBJ= $(patsubst %.cc,%.o,$(SRC))
+SOURCE_MAKEFILE=Makefile.am
+BUILD__MAKEFILE=Makefile
+TARGET_FILE= $(notdir $(PWD))
+SOURCE_FILES= $(notdir $(wildcard $(SOURCE_DIR)/*.*))
+BUILD__FILES= $(filter-out $(SRC) $(SOURCE_MAKEFILE), $(SOURCE_FILES))
+
+BUILD__F_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__FILES))
+SOURCE_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_FILES))
+
+BUILD__M_PATH= $(addprefix $(BUILD__DIR)/,$(BUILD__MAKEFILE))
+SOURCE_M_PATH= $(addprefix $(SOURCE_DIR)/,$(SOURCE_MAKEFILE))
+
+TARGET_F_PATH= $(addprefix $(BUILD__DIR)/,$(TARGET_FILE))
+OBJ_F_PATH= $(addprefix $(BUILD__DIR)/,$(OBJ))
+SRC_F_PATH= $(addprefix $(SOURCE_DIR)/,$(SRC))
+OLD_F_PATH= $(addprefix $(SOURCE_DIR)/,$(OLD))
+
+#############
+# BOOTSTRAP #
+#############
+
+
+bootstrap: $(BUILD__DIR) $(BUILD__F_PATH) $(BUILD__M_PATH)
+
+# Create, if nessary, the destination directory
+$(BUILD__DIR):
+ $(MKDIR) $(BUILD__DIR)
+
+# Copy, if nessary, all the files, except the Makefile.am
+$(BUILD__F_PATH): $(SOURCE_F_PATH)
+ $(CP) $(addprefix $(SOURCE_DIR),$(@F)) $@
+
+# Copy if nessary, the Makefile.am into Makefile
+$(BUILD__M_PATH): $(SOURCE_M_PATH)
+ $(CP) $(SOURCE_M_PATH) $(BUILD__M_PATH)
+
+
+#######
+# ALL #
+#######
+
+# We assume that the call is done from the build directory.
+# With the directive vpath, hidden files are found in the source directory.
+
+all: $(TARGET_F_PATH)
+
+
+$(TARGET_F_PATH): $(OBJ_F_PATH)
+ $(LINK.cc) $< $(LOADLIBES) $(LDLIBS) -o $@
+
+$(OBJ_F_PATH):$(SRC_F_PATH)
+ $(COMPILE.cc) $(OUTPUT_OPTION) $<
+
+
+#########
+# CLEAN #
+#########
+
+# Force every time the deletion
+clean: clean_target clean_obj clean_dst clean_old #clean_make
+
+
+clean_target:
+ -@$(RM) $(TARGET_F_PATH) &> /dev/null
+
+clean_obj:
+ -@$(RM) $(OBJ_F_PATH) &> /dev/null
+
+clean_dst:
+ -@$(RM) $(BUILD_F_PATH) &> /dev/null
+
+clean_make:
+ -@$(RM) $(BUILD_M_PATH) &> /dev/null
+
+clean_old:
+ -@$(RM) $(OLD_F_PATH) &> /dev/null
+
+
+#########
+# PRINT #
+#########
+
+print: print_tools print_bootstrap
+
+print_tools:
+ @$(ECHO) "HOME = $(HOME)"
+ @$(ECHO) "INCLUDES = $(INCLUDES)"
+ @$(ECHO) "CXXFLAGS = $(CXXFLAGS)"
+ @$(ECHO) "ECHO = $(ECHO)"
+ @$(ECHO) "RM = $(RM)"
+ @$(ECHO) "MKDIR = $(MKDIR)"
+ @$(ECHO) "CP = $(CP)"
+ @$(ECHO)
+
+print_bootstrap:
+ @$(ECHO) "PWD = $(PWD)"
+ @$(ECHO) "SOURCE_PATTERN = $(SOURCE_PATTERN)"
+ @$(ECHO) "BUILD__PATTERN = $(BUILD__PATTERN)"
+ @$(ECHO) "SOURCE_DIR = $(SOURCE_DIR)"
+ @$(ECHO) "BUILD__DIR = $(BUILD__DIR)"
+ @$(ECHO) "SOURCE_MAKEFILE = $(SOURCE_MAKEFILE)"
+ @$(ECHO) "BUILD__MAKEFILE = $(BUILD__MAKEFILE)"
+ @$(ECHO) "TARGET_FILE = $(TARGET_FILE)"
+ @$(ECHO) "SOURCE_FILES = $(SOURCE_FILES)"
+ @$(ECHO) "SOURCE_F_PATH = $(SOURCE_F_PATH)"
+ @$(ECHO) "BUILD__FILES = $(BUILD__FILES)"
+ @$(ECHO) "BUILD__F_PATH = $(BUILD__F_PATH)"
+ @$(ECHO) "BUILD__M_PATH = $(BUILD__M_PATH)"
+ @$(ECHO) "SOURCE_M_PATH = $(SOURCE_M_PATH)"
+ @$(ECHO) "SRC = $(SRC)"
+ @$(ECHO) "OBJ = $(OBJ)"
+ @$(ECHO) "OLD = $(OLD)"
+ @$(ECHO) "SRC_F_PATH = $(SRC_F_PATH)"
+ @$(ECHO) "OBJ_F_PATH = $(OBJ_F_PATH)"
+ @$(ECHO) "OLD_F_PATH = $(OLD_F_PATH)"
+ @$(ECHO)
diff --git a/scribo/sandbox/green/demo/clustering/kmean_rgb/kmean_rgb.cc
b/scribo/sandbox/green/demo/clustering/kmean_rgb/kmean_rgb.cc
new file mode 100644
index 0000000..d02c497
--- /dev/null
+++ b/scribo/sandbox/green/demo/clustering/kmean_rgb/kmean_rgb.cc
@@ -0,0 +1,239 @@
+// 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 This is a demonstrator for kmean_rgb.
+///
+/// The code is provided as is. It is an alpha version, so very very
+/// experimental. Take care !!
+
+#include <iostream>
+#include <sstream>
+
+#include <mln/clustering/kmean_rgb.hh>
+
+#include <mln/core/macros.hh>
+#include <mln/core/image/image2d.hh>
+
+#include <mln/data/transform.hh>
+
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+
+#include <mln/io/ppm/load.hh>
+#include <mln/io/pgm/load.hh>
+#include <mln/io/pgm/save.hh>
+#include <mln/io/ppm/save.hh>
+#include <mln/io/plot/save_image_sh.hh>
+
+#include <mln/img_path.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/label_8.hh>
+#include <mln/value/rgb8.hh>
+
+
+/// \brief The real code for launching the kmean optimised algorithm.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// This is the real lauching code. In fact, the stuff consists in loading the
+/// image, setting the parameters, calling the routine, extracting the results
+/// and saving them for the user.
+///
+/// \fixme The result is not safe because we don't test kmean.is_valid()
+void do_demo(const std::string& image,
+ const unsigned k_center,
+ const unsigned n_times,
+ const unsigned watch_dog)
+{
+ typedef mln::value::label_8 t_lbl8;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::value::rgb<5> t_rgb5;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rgb5> t_image2d_rgb5;
+ typedef mln::image2d<t_lbl8> t_image2d_lbl8;
+
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rgb5 img_rgb5;
+ t_image2d_lbl8 img_lbl8;
+
+ mln::io::ppm::load(img_rgb8, image.c_str());
+ img_rgb5 = mln::data::transform(img_rgb8,mln::fun::v2v::rgb8_to_rgbn<5>());
+ img_lbl8 = mln::clustering::kmean_rgb<double,5>(img_rgb5,
+ k_center,
+ watch_dog,
+ n_times);
+
+ mln::io::pgm::save(img_lbl8, "label.pgm");
+}
+
+/// \brief Front hand for the demonstrator.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// The front hand enables the setting of the default values for the
+/// parameters. it allows us to print the real parameter set used by
+/// the demonstrator.
+void demo(const std::string& image = OLENA_IMG_PATH"/house.ppm",
+ const unsigned k_center = 3,
+ const unsigned n_times = 3,
+ const unsigned watch_dog = 3)
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "Launching the demo with these parameters" <<
std::endl;
+ std::cout << "image : " << image <<
std::endl;
+ std::cout << "k_center : " << k_center <<
std::endl;
+ std::cout << "n_times : " << n_times <<
std::endl;
+ std::cout << "watch_dog : " << watch_dog <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+
+ do_demo(image, k_center, n_times, watch_dog);
+}
+
+
+/// \brief Convert character get in the input stream to unsigned integer.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_unsigned(const bool status, const char *arg, unsigned& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ result = !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Convert character get in the input stream to string.
+///
+/// \param[in] status : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+/// \param[out] val : the converted value to output.
+///
+/// \return a flag that tell us if every thing is ok, if the result can be used.
+bool char_to_string(const bool status, const char *arg, std::string& val)
+{
+ bool result = false;
+
+ if (status)
+ {
+ std::istringstream arg_stream(arg);
+
+ arg_stream >> val;
+
+ return !arg_stream.fail();
+ }
+
+ return result;
+}
+
+
+/// \brief Print usage recommandation for this binary.
+///
+/// \param[in] argc : the exiting flag tell us to exit without doing any job.
+/// \param[in] arg : the input argument to convert.
+void usage(const int argc, const char *args[])
+{
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "argc : " << argc <<
std::endl;
+
+ for (int i = 0; i < argc; ++i)
+ std::cout << "args[" << i << "] : " <<
args[i] << std::endl;
+
+ std::cout << "----------------------------------------" <<
std::endl;
+ std::cout << "usage: kmean1d [image [k_center [n_times [watch_dog]]]]"
+ << std::endl;
+ std::cout << "pbm image (points to work with)" <<
std::endl;
+ std::cout << "unsigned k_center (number of centers)" <<
std::endl;
+ std::cout << "unsigned n_times (number of launching)" <<
std::endl;
+ std::cout << "unsigned watch_dog (convergence loop)" <<
std::endl;
+ std::cout << "----------------------------------------" <<
std::endl;
+}
+
+
+/// \brief The main routine launchs the kmean optimised algoritm.
+///
+/// \param[in] image : the color image.
+/// \param[in] k_center : the number of centers.
+/// \param[in] n_times : the number of launching.
+/// \param[in] watch_dog : the number of iterations to manage the convergence.
+///
+/// All the parameters are optional, but we must respect strictly a
+/// specific order. In fact, we can launch five programs with some
+/// default parameters: demo(), demo(image), demo(image,k_center),
+/// demo(image,k_center,n_times) and
+/// demo(image,k_center,n_times,watch_dog).
+int main(const int argc, const char *args[])
+{
+ std::string image("top");
+ unsigned k_center;
+ unsigned watch_dog;
+ unsigned n_times;
+ bool status = true;
+
+ switch (argc)
+ {
+ case 5: status = char_to_unsigned(status, args[4], watch_dog);
+ case 4: status = char_to_unsigned(status, args[3], n_times);
+ case 3: status = char_to_unsigned(status, args[2], k_center);
+ case 2: status = char_to_string(status, args[1], image); break;
+ case 1: status = true; break;
+ default: status = false;
+ }
+
+ if (status)
+ {
+ switch (argc)
+ {
+ case 1: demo(); break;
+ case 2: demo(image); break;
+ case 3: demo(image, k_center); break;
+ case 4: demo(image, k_center, n_times); break;
+ case 5: demo(image, k_center, n_times, watch_dog); break;
+ }
+ }
+ else
+ usage(argc, args);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/mln/clustering/k_mean.hh
b/scribo/sandbox/green/mln/clustering/k_mean.hh
index db3f34c..74acda7 100644
--- a/scribo/sandbox/green/mln/clustering/k_mean.hh
+++ b/scribo/sandbox/green/mln/clustering/k_mean.hh
@@ -1,6 +1,4 @@
-// Copyright (C) 2007 EPITA Research and Development Laboratory (LRDE)
-// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE)
-// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2007,2008,2009,2010 EPITA LRDE
//
// This file is part of Olena.
//
@@ -26,43 +24,89 @@
// executable file might be covered by the GNU General Public License.
#ifndef MLN_CLUSTERING_K_MEAN_HH
-#define MLN_CLUSTERING_K_MEAN_HH
+# define MLN_CLUSTERING_K_MEAN_HH
/// \file
///
-/// \brief Implements the K MEAN algorithm.
-/// DO
-/// - ASSIGNEMENT STEP
-/// - UPDATE STEP
-/// LOOP UNTIL CONVERGENCE
+/// \brief Implement the K MEAN algorithm with matrix and vectors.
///
-/// ASSIGNEMENT STEP
+/// This is the first impementation of the kmean algorithm. There is no
+/// specific optimisation but every part of the algorithm is here and
+/// it works. As it used vectors and matrices, it is not very convenient to
+/// work with this version.
+///
+/// \verbatim
+/// This is the main lines of the kmean algorithm:
+///
+/// PROCEDURE MAIN
+/// BEGIN
+/// DO
+/// - CALL ASSIGNEMENT STEP
+/// - CALL UPDATE STEP
+/// LOOP UNTIL CONVERGENCE
+/// END
+///
+/// PROCEDURE ASSIGNEMENT STEP
/// BEGIN
-/// - COMPUTE THE DISTANCE MATRIX FROM POINTS TO CENTERS
-/// - COMPUTE GROUP MATRIX WHERE EACH POINT IS ASSIGNED TO NEAREST CENTER
+/// - COMPUTE THE DISTANCE MATRIX FROM POINTS TO CENTERS
+/// - COMPUTE GROUP MATRIX WHERE EACH POINT IS ASSIGNED TO THE NEAREST CENTER
/// END
///
-/// UPDATE STEP
+/// PROCEDURE UPDATE STEP
/// BEGIN
-/// - COMPUTE THE MEAN OF THE GROUPS WHICH ARE THE NEW CENTERS
+/// - COMPUTE THE MEAN OF THE GROUPS WHICH ARE NOW THE NEW CENTERS
/// END
+/// \endvarbitim
+///
+/// The following sample is the standard use of this first
+/// implementation. The number of centers is a decision left to the
+/// final user. As the representation uses vectors and matices, size
+/// of each objects must be known at compile time, and so NB_POINT must be
+/// a constant expression (mln::geom::nsites couldn't be called).
+///
+/// #include <mln/clustering/k_mean.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/img_path.hh>
+/// #include <mln/io/ppm/load.hh>
+/// #include <mln/trait/value_.hh>
+/// #include <mln/value/rgb8.hh>
+///
+/// #define NB_CENTER 9
+/// #define NB_POINT (128*128)
+/// #define POINT_SIZE mln_dim(mln::value::rgb8)
+/// #define POINT_TYPE double
+///
+/// int main()
+/// {
+/// typedef mln::value::rgb8 t_rgb8;
+/// mln::image2d<t_rgb8> img_rgb8;
+///
+/// mln::io::ppm::load(img_ref, OLENA_IMG_PATH"/house.ppm");
+/// mln::clustering::k_mean<NB_POINT,NB_CENTER,POINT_SIZE,POINT_TYPE> kmean;
+///
+/// kmean.init_point(img_rgb8);
+/// kmean.loop(img_rgb8);
+///
+/// return 0;
+/// }
+
+# include <limits.h>
+# include <iostream>
-#include <limits.h>
-#include <iostream>
-#include <mln/trace/entering.hh>
-#include <mln/trace/exiting.hh>
+# include <mln/algebra/mat.hh>
+# include <mln/algebra/vec.hh>
-#include <mln/core/contract.hh>
-#include <mln/trait/value_.hh>
+# include <mln/core/concept/image.hh>
+# include <mln/core/contract.hh>
+# include <mln/core/macros.hh>
-#include <mln/algebra/mat.hh>
-#include <mln/algebra/vec.hh>
+# include <mln/math/min.hh>
+# include <mln/norm/l2.hh>
-#include <mln/math/min.hh>
-#include <mln/norm/l2.hh>
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
-#include <mln/core/concept/image.hh>
-#include <mln/core/macros.hh>
+# include <mln/trait/value_.hh>
namespace mln
{
@@ -78,149 +122,221 @@ namespace mln
namespace clustering
{
-
- //
- // PARAM : DIM VECTOR, NUMBER OF CLASSES
- // INPUT : MATRIX 1..N (SAMPLE)
- // WORK
- //
-
- // n is the size of the sample.
- // k is the number of centers.
- // p is the number of attributes for a point.
- // T is the type for computations.
+
+ /// \brief Implements the K MEAN algorithm with matrix and vectors.
+ ///
+ /// Param n is the size of the sample (the number of point to be
+ /// classified). Param k is the number of centers, at the end,
+ /// each point is link to one the nearest center. Param p is the
+ /// number of attributes of a point, in fact its dimension (int_u8
+ /// = 1, rgb8 = 3, etc ...). Param T is the type used for
+ /// computations, the type of the point, typiccaly float or
+ /// double.
+ ///
+ /// \ingroup modclustering
template <unsigned n, unsigned k, unsigned p, typename T>
struct k_mean
{
- //------------------------------------------------------------------------
- // Constructor and destructor
- //------------------------------------------------------------------------
-
+ /// Constructors and destructors.
+ /// \{
+ /// \brief Allocate or deallocate the data structure.
+ ///
+ /// Allocate or deallocate the _point, _distance, _group,
+ /// _center, _variance data structure with the correct size.
k_mean();
~k_mean();
+ /// \}
- //------------------------------------------------------------------------
- // Accessors
- //------------------------------------------------------------------------
-
+ /// Accessors.
+ /// \{
+ /// \brief Hack to view temporary results of the kmean algorithm.
+ ///
+ /// These methods are necessary for unitary testing and debugging.
algebra::mat<n, p, T>& get_point();
algebra::mat<k, p, T>& get_center();
algebra::mat<n, k, T>& get_distance();
algebra::mat<n, k, T>& get_group();
algebra::vec<k, T>& get_variance();
+ /// \}
-
- //------------------------------------------------------------------------
- // Tools
- //------------------------------------------------------------------------
+ /// Tools.
+ /// \{
+ /// \brief Define elementary function that are not available from milena.
+ ///
+ /// These methods are not interesting from the kmean'point of
+ /// view but are required for the gluing process.
- /// \brief Return the euclidian distance beetween vector x and vector y.
+ /// \brief Return the euclidian distance beetween two vectors x and y.
///
/// Compute the f$\sqrt(\sum_{i=0}^P ((x_i - y_i)^2)$f
///
- /// \param[in] x a vector of dimension 1xP.
- /// \param[in] y a second vector of dimension 1xP.
+ /// \param[in] x a vector of dimension p.
+ /// \param[in] y a second vector of dimension p.
/// \return the distance between x and y.
-
mln_sum_product(T,T) euclidian_distance(const algebra::vec<p,T>& x,
const algebra::vec<p,T>& y) const;
- /// \brief Return the ith column.
- ///
- /// \param[in] m a matrix of dimension {N or K}xP.
- /// \return the ith column as a vector of dimension 1xP.
-
- /// \brief Return the ith column.
+ /// \brief Return a stack copy of the ith column.
///
- /// \param[in] m a matrix of dimension {N or K}xP.
- /// \return the ith column as a vector of dimension 1xP.
+ /// \param[in] m a matrix of dimension r x q.
+ /// \param[in] _col the index of the selected column.
+ /// \return a stack copy of the ith column as a vector of dimension q.
template <unsigned q, unsigned r>
algebra::vec<q,T> col(const algebra::mat<r, q, T>& m,
const unsigned _col) const;
+
+ /// \brief Return a heap copy of the ith col.
+ ///
+ /// \param[in] m a matrix of dimension r x q.
+ /// \param[in] _col the index of the selected column.
+ /// \return a heap copy of the ith column as a vector of dimension q.
template <unsigned q, unsigned r>
algebra::vec<q,T>* ptr_col(const algebra::mat<r, q, T>& m,
const unsigned _col) const;
+
+ /// \brief Return a stack copy of the ith row.
+ ///
+ /// \param[in] m a matrix of dimension r x q.
+ /// \param[in] _row the index of the selected row.
+ /// \return a stack copy of the ith row as a vector of dimension q.
template <unsigned q, unsigned r>
algebra::vec<r,T> row(const algebra::mat<r, q, T>& m,
const unsigned _row) const;
+
+ /// \brief Divide inplace a column of the matrix by a scalar.
+ ///
+ /// \param[in] m a matrix of dimension r x q.
+ /// \param[in] _col the index of the selected column.
+ /// \param[in] value the scalar by which dividing the column.
template <unsigned q, unsigned r>
void div_col(algebra::mat<r, q, T>& m,
const unsigned _col,
const T value);
+
+ /// \brief Sum all the elements of one row.
+ ///
+ /// \param[in] m a matrix of dimension r x q.
+ /// \param[in] _row the index of the selected row.
+ /// \return the sum of every attributes of the row.
template <unsigned q, unsigned r>
mln_sum(T) sum_row(const algebra::mat<r, q, T>& m,
const unsigned _row) const;
+
+ /// \brief Return the minimum of a vector.
+ ///
+ /// \param[in] x a vector of dimension q.
+ /// \return the mininum of that input vector.
template <unsigned q, typename M>
M min_col(const algebra::vec<q, M>& x) const;
+ /// \}
- //------------------------------------------------------------------------
- // Initializations of points and centers
- //------------------------------------------------------------------------
-
- /// \brief Initialize the matrix _point with the pixels of an image.
+ /// Initializations.
+ /// \{
+ /// \brief Initialize the _point and _center data structure.
///
- /// \param[in] input an image which contains the data points.
+ /// The _point data structure is fed with the value of the input
+ /// image. The _center data structure is fed with random points
+ /// taken from the input image.
template <typename I>
void init_point(const Image<I>& _input);
void init_center();
+ /// \}
-
- //------------------------------------------------------------------------
- // Computations of distance, group, center, within variance
- //------------------------------------------------------------------------
+ /// Computations.
+ /// \{
+ /// \brief Define the core routines of the kmean algorithm.
+ ///
+ /// The update_distance, update_group, update_center and update_variance
+ /// define the core kmean routines. If some optimization muste be done,
+ /// one may looks here.
+
+
+ /// \brief Update the _distance data structure.
+ ///
+ /// Compute the square distance between each point of the data
+ /// cloud and each center.
void update_distance();
+
+ /// \brief Update the _group data structure.
+ ///
+ /// For each point of the data cloud, find the group which has
+ /// the minimum distance from it.
void update_group();
- void update_center();
- T update_variance();
+ /// \brief Update the _center data structure.
+ ///
+ /// For each group, compute the center of mass in therm of
+ /// points of the data cloud.
+ void update_center();
- //------------------------------------------------------------------------
- // Main loop
- //------------------------------------------------------------------------
+ /// \brief Update the _variance.
+ ///
+ /// Compute the within variance. Sum every shortest distance.
+ T update_variance();
+ /// \}
+ /// \brief Define the orchestration of the kmean core routines.
+ ///
+ /// \param[in] _input the initial image which initialize the data cloud.
+ ///
+ /// The orchestration is in a fact a loop which call one after
+ /// each other the core routines. Ending the loop means managing
+ /// the statistical convergence or having some clues of
+ /// divergence (watch_dog).
template <typename I>
void loop(const Image<I>& _input);
- //void loop();
private:
+ /// \brief watch_dog define the maximum of iterations that can be done.
+ ///
+ /// That constant help us to decide if divergence has been
+ /// occurred or not.
static const unsigned watch_dog = 100;
-
+
+
/// \brief _points contains the concatenation of every data points.
///
- /// One data point is a vector 1xP where P is the number of attributes.
- /// _points is a matrix NxP where N is the number of data points.
+ /// One data point is a vector 1 x p where p is the number of attributes.
+ /// So _points is a matrix n x P where n is the number of data points.
algebra::mat<n, p, T>* _point;
+
/// \brief _distance contains all the euclidian distances between points
/// and the centers.
///
- /// _distance is a matrix NxK where N is the number of data points and
- /// K the number of centers.
+ /// _distance is a matrix n x k where n is the number of data points and
+ /// k the number of centers.
algebra::mat<n, k, mln_sum_product(T,T)>* _distance;
+
/// \brief _group contains the point assignement to one center.
///
- /// _group is a boolean matrix NxK where N is the number of data points
- /// and K the number of centers.
+ /// _group is a boolean matrix n x k where n is the number of data points
+ /// and k the number of centers.
algebra::mat<n, k, T>* _group;
- /// \brief _center contains the coordonnate of the K centers.
+
+ /// \brief _center contains the coordonnate of the k centers.
///
- /// _center is a matrix KxP where K is the number of centers and P is the
- /// number of attributes.
+ /// _center is a matrix k x p where k is the number of centers
+ /// and p is the number of attributes.
algebra::mat<k, p, T>* _center;
+
+ /// \brief _variance contains the variance of each group.
+ ///
+ /// _variance is a vector 1 x k where k is the number of centers.
algebra::vec<k, T>* _variance;
};
@@ -234,7 +350,7 @@ namespace mln
inline
k_mean<n,k,p,T>::k_mean()
{
- trace::entering("mln::clustering::k_mean::k_mean");
+ trace::entering("mln::clustering::k_mean::cstor");
_point = new algebra::mat<n, p, T>();
_distance = new algebra::mat<n, k, mln_sum_product(T,T)>();
@@ -248,14 +364,14 @@ namespace mln
mln_postcondition(_center != 0);
mln_postcondition(_variance != 0);
- trace::exiting("mln::clustering::k_mean::k_mean");
+ trace::exiting("mln::clustering::k_mean::cstor");
}
template <unsigned n, unsigned k, unsigned p, typename T>
inline
k_mean<n,k,p,T>::~k_mean()
{
- trace::entering("mln::clustering::k_mean::~k_mean");
+ trace::entering("mln::clustering::k_mean::dstor");
delete _point;
delete _distance;
@@ -263,7 +379,7 @@ namespace mln
delete _center;
delete _variance;
- trace::exiting("mln::clustering::k_mean::~k_mean");
+ trace::exiting("mln::clustering::k_mean::dstor");
}
//--------------------------------------------------------------------------
@@ -350,7 +466,7 @@ namespace mln
template <unsigned n, unsigned k, unsigned p, typename T>
template <unsigned q, unsigned r>
inline
- algebra::vec<q,T> k_mean<n,k,p,T>::col(const algebra::mat<r, q,
T>& m,
+ algebra::vec<q,T> k_mean<n,k,p,T>::col(const algebra::mat<r, q,
T>& m,
const unsigned _col) const
{
trace::entering("mln::clustering::k_mean::col");
@@ -368,7 +484,7 @@ namespace mln
template <unsigned n, unsigned k, unsigned p, typename T>
template <unsigned q, unsigned r>
inline
- algebra::vec<q,T>* k_mean<n,k,p,T>::ptr_col(const algebra::mat<r, q,
T>& m,
+ algebra::vec<q,T>* k_mean<n,k,p,T>::ptr_col(const algebra::mat<r, q,
T>& m,
const unsigned _col) const
{
trace::entering("mln::clustering::k_mean::ptr_col");
@@ -386,7 +502,7 @@ namespace mln
template <unsigned n, unsigned k, unsigned p, typename T>
template <unsigned q, unsigned r>
inline
- mln_sum(T) k_mean<n,k,p,T>::sum_row(const algebra::mat<r, q, T>& m,
+ mln_sum(T) k_mean<n,k,p,T>::sum_row(const algebra::mat<r, q, T>& m,
const unsigned _row) const
{
trace::entering("mln::clustering::k_mean::sum_row");
@@ -404,7 +520,7 @@ namespace mln
template <unsigned n, unsigned k, unsigned p, typename T>
template <unsigned q, unsigned r>
inline
- void k_mean<n,k,p,T>::div_col(algebra::mat<r, q, T>& m,
+ void k_mean<n,k,p,T>::div_col(algebra::mat<r, q, T>& m,
const unsigned _col,
const T value)
{
@@ -422,21 +538,21 @@ namespace mln
inline
M k_mean<n,k,p,T>::min_col(const algebra::vec<q, M>& x) const
{
- trace::entering("mln::clustering::k_mean<n,k,p,T>::min_col");
-
+ trace::entering("mln::clustering::k_mean::min_col");
+
M result = x[0];
for (unsigned i = 1; i < q; ++i)
result = math::min(result, x[i]);
- trace::exiting("mln::clustering::k_mean<n,k,p,T>::min_col");
+ trace::exiting("mln::clustering::k_mean::min_col");
return result;
}
template <unsigned n, unsigned k, unsigned p, typename T>
inline
mln_sum_product(T,T)
- k_mean<n,k,p,T>::euclidian_distance(const algebra::vec<p, T>& x,
+ k_mean<n,k,p,T>::euclidian_distance(const algebra::vec<p, T>& x,
const algebra::vec<p, T>& y) const
{
trace::entering("mln::clustering::k_mean::euclidian_distance");
@@ -458,8 +574,8 @@ namespace mln
inline
void k_mean<n,k,p,T>::init_point(const Image<I>& _input)
{
- trace::entering("mln::clustering::k_mean<n,k,p,T>::init");
-
+ trace::entering("mln::clustering::k_mean::init");
+
const I& input = exact(_input);
algebra::mat<n, p, T>& point = *_point;
@@ -474,28 +590,28 @@ namespace mln
for_all(pi)
{
//std::cout << pi << std::endl;
-
+
++i;
for (unsigned j = 0; j < p; ++j)
{
-
+
point(i,j) = input(pi).comp(j);
//point(i,j) = input(pi);
}
}
- trace::exiting("mln::clustering::k_mean<n,k,p,T>::init");
+ trace::exiting("mln::clustering::k_mean::init");
}
template <unsigned n, unsigned k, unsigned p, typename T>
inline
void k_mean<n,k,p,T>::init_center()
{
- trace::entering("mln::clustering::k_mean<n,k,p,T>::init_center");
-
+ trace::entering("mln::clustering::k_mean::init_center");
+
algebra::mat<n, p, T>& point = *_point;
algebra::mat<k, p, T>& center = *_center;
-
+
// A random point is choosen to be the initial value for a center.
for (unsigned i = 0; i < k; ++i)
{
@@ -503,16 +619,16 @@ namespace mln
for (unsigned j = 0; j < p; ++j)
{
- center(i,j) = point(random, j);
+ center(i,j) = point(random, j);
}
//std::cout << "center(" << i << ")" <<
col(center, i) << std::endl;
}
- trace::exiting("mln::clustering::k_mean<n,k,p,T>::init_center");
+ trace::exiting("mln::clustering::k_mean::init_center");
}
-
+
//--------------------------------------------------------------------------
// Computations of distance, group, center, within variance
//--------------------------------------------------------------------------
@@ -528,7 +644,7 @@ namespace mln
algebra::mat<n, p, T>& point = *_point;
algebra::mat<n, k, T>& distance = *_distance;
algebra::mat<k, p, T>& center = *_center;
-
+
// for all points in the data cloud.
for (unsigned i = 0; i < n; ++i)
{
@@ -546,7 +662,7 @@ namespace mln
inline
void k_mean<n,k,p,T>::update_group()
{
- trace::entering("mln::clustering::k_mean<n,k,p,T>::update_group");
+ trace::entering("mln::clustering::k_mean::update_group");
algebra::mat<n, k, mln_sum_product(T,T)>& distance = *_distance;
algebra::mat<n, k, T>& group = *_group;
@@ -563,14 +679,14 @@ namespace mln
}
// mln_postcondition(sum(col(distance(i,j)) == 1) Vi
- trace::exiting("mln::clustering::k_mean<n,k,p,T>::update_group");
+ trace::exiting("mln::clustering::k_mean::update_group");
}
template <unsigned n, unsigned k, unsigned p, typename T>
inline
void k_mean<n,k,p,T>::update_center()
{
-
trace::entering("mln::clustering::k_mean<n,k,p,T>::update_center");
+ trace::entering("mln::clustering::k_mean::update_center");
algebra::mat<n, p, T>& point = *_point;
algebra::mat<k, p, T>& center = *_center;
@@ -592,14 +708,14 @@ namespace mln
for (unsigned i = 0; i < k; ++i)
div_col(center, i, sum_row(group, i));
- trace::exiting("mln::clustering::k_mean<n,k,p,T>::update_center");
+ trace::exiting("mln::clustering::k_mean::update_center");
}
template <unsigned n, unsigned k, unsigned p, typename T>
inline
T k_mean<n,k,p,T>::update_variance()
{
-
trace::entering("mln::clustering::k_mean<n,k,p,T>::update_variance");
+ trace::entering("mln::clustering::k_mean::update_variance");
algebra::vec<k, T>& variance = *_variance;
algebra::mat<n, k, T>& distance = *_distance;
@@ -613,10 +729,10 @@ namespace mln
result += variance[i];
}
-
trace::exiting("mln::clustering::k_mean<n,k,p,T>::update_variance");
+ trace::exiting("mln::clustering::k_mean::update_variance");
return result;
- }
-
+ }
+
//--------------------------------------------------------------------------
// Main loop
@@ -626,9 +742,8 @@ namespace mln
template <typename I>
inline
void k_mean<n,k,p,T>::loop(const Image<I>& _input)
- //void k_mean<n,k,p,T>::loop()
{
- trace::entering("mln::clustering::k_mean<n,k,p,T>::loop");
+ trace::entering("mln::clustering::k_mean::loop");
T within_variance = INT_MAX-1;
T old_variance = INT_MAX;
@@ -658,12 +773,10 @@ namespace mln
std::cout << i << " : " << within_variance <<
std::endl;
}
- trace::exiting("mln::clustering::k_mean<n,k,p,T>::loop");
- }
-
-
+ trace::exiting("mln::clustering::k_mean::loop");
+ }
-#endif // ! MLN_INCLUDE_ONLY
+# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln::clustering
diff --git a/scribo/sandbox/green/mln/clustering/kmean1d.hh
b/scribo/sandbox/green/mln/clustering/kmean1d.hh
index c3c1add..57d246b 100644
--- a/scribo/sandbox/green/mln/clustering/kmean1d.hh
+++ b/scribo/sandbox/green/mln/clustering/kmean1d.hh
@@ -1,4 +1,4 @@
-// Copyright (C) 2008,2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2007,2008,2009,2010 EPITA LRDE
//
// This file is part of Olena.
//
@@ -24,7 +24,7 @@
// executable file might be covered by the GNU General Public License.
#ifndef MLN_CLUSTERING_KMEAN1D_HH
-#define MLN_CLUSTERING_KMEAN1D_HH
+# define MLN_CLUSTERING_KMEAN1D_HH
/// \file
///
@@ -34,36 +34,63 @@
/// the greylevel attribute inspite of the pixel attribute. The
/// algorithm is independant from the image dimension. But, we have to
/// compute one time the histogram. In fact, we move a recurrent cost
-/// to a fix cost in the complexity. This version is very adapted to
+/// by a fix cost in the complexity. This version is very adapted to
/// images with small quantification.
+///
+/// The following sample is a typical use of the new kmean implementation.
+///
+/// #include <iostream>
+/// #include <mln/clustering/kmean1d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/img_path.hh>
+/// #include <mln/io/pgm/load.hh>
+/// #include <mln/value/int_u8.hh>
+///
+/// int main()
+/// {
+/// typedef mln::value::int_u8 t_int_u8;
+/// typedef mln::image2d<t_int_u8> t_image2d_int_u8;
+/// t_image2d_int_u8 img_int_u8;
+///
+/// mln::io::pgm::load(img_int_u8, OLENA_IMG_PATH"/house.pgm");
+/// mln::clustering::kmean1d<double, 8> kmean(img_int_u8, 3);
+///
+/// kmean.launch_n_times();
+///
+/// return 0;
+/// }
+
+# include <limits.h>
+# include <iostream>
-#include <limits.h>
-#include <iostream>
-#include <mln/trace/entering.hh>
-#include <mln/trace/exiting.hh>
+# include <mln/accu/stat/histo1d.hh>
-#include <mln/core/contract.hh>
-#include <mln/trait/value_.hh>
-#include <mln/accu/stat/histo1d.hh>
+# include <mln/core/contract.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/macros.hh>
-#include <mln/math/min.hh>
-#include <mln/math/sqr.hh>
-#include <mln/norm/l2.hh>
+# include <mln/data/compute.hh>
+# include <mln/data/fill.hh>
+# include <mln/debug/println.hh>
-#include <mln/core/image/image2d.hh>
-#include <mln/value/int_u.hh>
-#include <mln/value/rgb8.hh>
-#include <mln/core/macros.hh>
+# include <mln/io/ppm/save.hh>
+# include <mln/io/pgm/save.hh>
-#include <mln/data/compute.hh>
-#include <mln/debug/println.hh>
-#include <mln/data/fill.hh>
-#include <mln/literal/zero.hh>
-#include <mln/labeling/colorize.hh>
-#include <mln/labeling/mean_values.hh>
+# include <mln/literal/zero.hh>
+# include <mln/labeling/colorize.hh>
+# include <mln/labeling/mean_values.hh>
-#include <mln/io/ppm/save.hh>
-#include <mln/io/pgm/save.hh>
+# include <mln/math/min.hh>
+# include <mln/math/sqr.hh>
+# include <mln/norm/l2.hh>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/trait/value_.hh>
+
+# include <mln/value/int_u.hh>
+# include <mln/value/rgb8.hh>
namespace mln
{
@@ -85,8 +112,8 @@ namespace mln
/// temporary images for computations and produces images as result. Images
/// play the role of matrix or vector in standard statistic algoritm.
///
- /// T is the type used for computations (float or double).
- /// n is the quantification for the image grayscale.
+ /// Param T is the type used for computations (float or double).
+ /// Param n is the quantification for the image grayscale.
template <typename T, unsigned n>
struct kmean1d
{
@@ -117,32 +144,22 @@ namespace mln
///}
- //------------------------------------------------------------------------
- // Constructor
- //------------------------------------------------------------------------
-
- /// \brief Constructor
+ /// \brief Constructor.
/// \param[in] point : the image as the population of pixels.
/// \param[in] k_center : the number of centers.
/// \param[in] watch_dog : the limit to observe the convergence (10).
/// \param[in] n_times : the number of times that we executed kmean(10).
-
kmean1d(const t_point_img& point,
const unsigned k_center,
const unsigned watch_dog = 10,
const unsigned n_times = 10);
- //------------------------------------------------------------------------
- // Accessors
- //------------------------------------------------------------------------
-
- /// Mutator and accessors.
+ /// Mutators and accessors.
/// \{
/// \brief Mutator and accessors are required for debugging and testing.
///
/// Testing needs to hack the kmean loop process in order to verify each
/// step of the algorithm.
-
void set_point(t_point_img& point);
void set_histo(t_histo_img& histo);
void set_number(t_number_img& number);
@@ -173,31 +190,21 @@ namespace mln
/// \}
- //------------------------------------------------------------------------
- // Initializations of centers
- //------------------------------------------------------------------------
-
/// Initialization of centers.
/// \{
- /// \brief Two ways: Regular greylevel tick or random greylevel value or.
+ /// \brief Initialize centers by regular tick or random position.
///
/// There is two way to proceed the initialization. First of all, we
/// divide the greyscale in regular tick and we assigne them to the mean
/// of the centers. Finaly, we can ask random initialization along the
/// greyscale axis. The second process is needed to launch_n_times the
/// kmean and converge to the best descent.
-
void init_mean();
void init_mean_regular();
void init_mean_random();
-
/// \}
- //------------------------------------------------------------------------
- // Computations of distance, group, center, within variance
- //------------------------------------------------------------------------
-
/// Computations of distance, group, center, within variance.
/// \{
/// \brief Update the statistical information needed by the kmean process.
@@ -206,36 +213,27 @@ namespace mln
/// first compute. Then we assign the pixels to their nearest center.
/// The new location of each center can then update. Finaly, hommogeneity
/// in group is observed by the within variance.
-
void update_distance();
void update_group();
void update_mean();
void update_variance();
-
/// \}
- //------------------------------------------------------------------------
- // Main loop
- //------------------------------------------------------------------------
/// kmean main loop
/// \{
/// \brief User interface to launch the kmean process.
///
- /// There are two ways to launch the kmean process. The first one allow to
- /// run it one time until convergence. As the process is a descent, it
- /// depends on the initial center locations. The second call allow us to
- /// rerun the process many times and to keep the best result (the one
- /// with the smallest within variance).
-
+ /// There are two ways to launch the kmean process. The first
+ /// one allows to run it one time until convergence. As the
+ /// process is a descent, it depends on the initial center
+ /// location. The second call allow us to rerun the process
+ /// many times and to keep the best result (the one with the
+ /// smallest within variance).
void launch_one_time();
void launch_n_times();
-
/// \}
- //------------------------------------------------------------------------
- // Checking the validiy of the results
- //------------------------------------------------------------------------
/// Checking the validity of the results.
/// \{
@@ -244,15 +242,10 @@ namespace mln
/// After each launching the kmean process one time, we need to know if
/// the descent was successfull or not. The method is_valid_descent do it
/// for us. The method looks for a bad center (a class with no greylevel
- /// associate to it) and a failure in the convergence.
-
+ /// associate to it) or a failure in the convergence.
bool is_descent_valid();
-
/// \}
- //------------------------------------------------------------------------
- // Debugging tools
- //------------------------------------------------------------------------
/// Debugging tools
/// \{
@@ -264,12 +257,10 @@ namespace mln
/// greylevel image. The update_cnv and finalize_cnv methods are used to
/// trace the convergence. They fill two images with the mean info and
/// the within variance info along the convergence and the tries.
-
void build_label_dbg();
void build_all_dbg();
void update_cnv();
void finalize_cnv();
-
/// \}
@@ -279,20 +270,19 @@ namespace mln
/// \brief These parameters control the convergence of the process.
///
/// The first parameter, k_center, defines the number of center for kmean.
- /// In fact, watch_dog limit the number of iteration that a simple kmean
+ /// In fact, watch_dog limits the number of iteration that a simple kmean
/// loop can do. If the process reaches the watch_dog limit, it means
/// that the process will not converge at all. The second parameter
/// n_times is the number of times we launch again and again the simple
/// kmean loop. As the kmean process is a descent, restarting the process
/// from different location will confort us in that we found a global
/// minima, not just a local one.
-
unsigned _k_center;
unsigned _watch_dog;
unsigned _n_times;
-
/// \}
+
/// Convergence information.
/// \{
/// \brief This information is used to follow the convergence.
@@ -300,26 +290,25 @@ namespace mln
/// The within_variance is the homogeniety indicator for the
/// kmean process. The ideal situation is to find the center
/// with the minimum variance around them. The within variance
- /// is just the sum of all variance around the centers. The
- /// current_step variable allows us to remember the current
- /// iteration in the kmean loop. This information is needed by
- /// is_descent_valid routine which decide if convergence occurs
- /// or not. The current_step info explicit where we are in the
- /// kmean iteration. The last information, current_launching,
- /// traces the progress while iterates kmean loop again and
- /// again. The flag is_number_valid is set when a empty class
- /// appears. This flag inhibit the process and force to restart
- /// a try.
-
+ /// is just the sum of all ponderated variances around the
+ /// centers. The current_step variable allows us to remember the
+ /// current iteration in the kmean loop. This information is
+ /// needed by is_descent_valid routine which decide if
+ /// convergence occurs or not. The current_step info explicit
+ /// where we are in the kmean iteration. The last information,
+ /// current_launching, traces the progress while iterates kmean
+ /// loop again and again. The flag is_number_valid is set when a
+ /// empty class appears. This flag inhibit the process and
+ /// force to restart a try.
t_result _within_variance;
unsigned _current_step;
unsigned _current_launching;
bool _is_number_valid;
static const unsigned _N_TRIES = 3;
-
/// \}
+
/// Result of the kmean process.
/// \{
/// \brief The center location are the major results of the kmean process.
@@ -327,23 +316,23 @@ namespace mln
/// The kmean process result is composed by three information. The best
/// launching iteration, the best within variance obtained and the
/// location of the centers associated.
-
unsigned _launching_min;
t_result _variance_min;
t_mean_img _mean_min;
+ /// \}
+
/// Inputs.
/// \{
- /// \brief The inputs are the distribution of the values and the values.
+ /// \brief The inputs are the distribution of the values.
///
/// The point image is a saving data for the real inputs. In fact, we use
/// the histogram information in the optimized kmean process.
-
t_point_img _point;
t_histo_img _histo;
-
///\}
+
/// Centers description.
/// \{
/// \brief Centers are described by the first moment of their group.
@@ -354,13 +343,12 @@ namespace mln
/// convergence. The number of pixels is used as integrity indicator.
/// A center with no point is a non sense. Theses informations are updated
/// after each kmean iteration.
-
t_number_img _number; // k x 1
t_mean_img _mean; // k x 1
t_variance_img _variance; // k x 1 within group
-
/// \}
+
/// Greylevels description.
/// \{
/// \brief The information are concerned with the greylevel input image.
@@ -369,15 +357,14 @@ namespace mln
/// which pixel) is assigned to a center. The distance image give us a
/// clue on how a greylevel could contribute to a center. The summation
/// over the greylevels of a center give us the within variance.
-
t_group_img _group; // g x 1 because dim(t_value) = 1
t_distance_img _distance; // label x graylevel
-
/// \}
+
/// Debugging, calibrating and testing results.
/// \{
- /// \brief Some exports information to control the results.
+ /// \brief Some information exports to control the results.
///
/// We come back in the input space. Label is the image which associates
/// each pixel to its center. Color is the image which gives a random rgb
@@ -385,14 +372,13 @@ namespace mln
/// label (assigned to the same center) in the image. The mean image
/// associate the mean of each pixel center to each pixel. We obtain thus
/// a rebuilded image.
-
t_label_dbg _label_dbg;
t_color_dbg _color_dbg;
t_mean_dbg _mean_dbg;
-
/// \}
- /// Debugging, calibrating and testing convergence.
+
+ /// Variance and center evolutions.
/// \{
/// \brief Trace the variance and the center evolution.
///
@@ -401,10 +387,8 @@ namespace mln
/// kmean loop or along the different launch. The variance_cnv is a trace
/// of the within variance along the kmean loop or along the different
/// launch.
-
t_mean_cnv _mean_cnv;
t_variance_cnv _variance_cnv;
-
/// \}
};
@@ -803,8 +787,6 @@ namespace mln
{
trace::entering("mln::clustering::kmean1d::update_mean");
- /// FIXME VERIFIER QUE L'ON PEUT OBTENIR UNE IMAGE EN NDG SIGNE
-
// avec g le niveau de gris (signed or not signed)
// w[g] la classe de g sous forme d'image
// h[g] l'histogramme de l'image sous forme d'image
@@ -872,7 +854,7 @@ namespace mln
for_all(g)
{
- if (l.ind() == _group(g))
+ if (static_cast<t_label>(l.ind()) == _group(g))
_variance(l) += _distance(point2d(g.ind(), l.ind()));
}
@@ -1091,7 +1073,7 @@ namespace mln
trace::exiting("mln::clustering::kmean1d::launch_n_times");
}
-#endif // ! MLN_INCLUDE_ONLY
+# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln::clustering
diff --git a/scribo/sandbox/green/mln/clustering/kmean2d.hh
b/scribo/sandbox/green/mln/clustering/kmean2d.hh
index e4918db..51aaf49 100644
--- a/scribo/sandbox/green/mln/clustering/kmean2d.hh
+++ b/scribo/sandbox/green/mln/clustering/kmean2d.hh
@@ -1,4 +1,4 @@
-// Copyright (C) 2008,2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2007,2008,2009,2010 EPITA LRDE
//
// This file is part of Olena.
//
@@ -24,52 +24,102 @@
// executable file might be covered by the GNU General Public License.
#ifndef MLN_CLUSTERING_KMEAN2D_HH
-#define MLN_CLUSTERING_KMEAN2D_HH
+# define MLN_CLUSTERING_KMEAN2D_HH
/// \file
///
-/// \brief Implements the optimized kmean algorithm.
+/// \brief Implements the optimized kmean algorithm in 2d.
///
/// This algorithm is optimized in the way it proceeds directly with
/// the greylevel attribute inspite of the pixel attribute. The
/// algorithm is independant from the image dimension. But, we have to
/// compute one time the histogram. In fact, we move a recurrent cost
-/// to a fix cost in the complexity. This version is very adapted to
-/// images with small quantification.
-
-#include <limits.h>
-#include <iostream>
-#include <mln/trace/entering.hh>
-#include <mln/trace/exiting.hh>
-
-#include <mln/core/contract.hh>
-#include <mln/trait/value_.hh>
-#include <mln/accu/stat/histo2d.hh>
-
-#include <mln/math/min.hh>
-#include <mln/math/sqr.hh>
-#include <mln/norm/l2.hh>
-
-#include <mln/core/image/image2d.hh>
-#include <mln/core/concept/image.hh>
-#include <mln/value/int_u.hh>
-#include <mln/value/rgb8.hh>
-#include <mln/value/rg.hh>
-#include <mln/core/macros.hh>
-
-#include <mln/data/compute.hh>
-#include <mln/debug/println.hh>
-#include <mln/data/fill.hh>
-#include <mln/literal/zero.hh>
-#include <mln/literal/one.hh>
-#include <mln/labeling/colorize.hh>
-#include <mln/labeling/mean_values.hh>
-
-#include <mln/io/ppm/save.hh>
-#include <mln/io/pgm/save.hh>
-
-#include <mln/util/array.hh>
-#include <mln/algebra/vec.hh>
+/// by a fix cost in the complexity. This version is very adapted to
+/// images with small quantification. But, in 2d, the execution
+/// becomes very slow. It's just normal because the quantification is
+/// 8 bits per axis. So the actual histogram is bigger than the image.
+///
+/// Take care to the following point: The within variance is still a
+/// scalar value because we take the distance between two points and
+/// the result is a scalar from the geometrical point of view. An
+/// alternative implementation could study the variance/covariance
+/// matrix of each sub data clouds and works with the trace of the
+/// within variance matrix (as we do for the fisher criteria in N-d).
+///
+/// The following sample is a typical use of the new kmean implementation.
+///
+/// #include <iostream>
+/// #include <mln/clustering/kmean2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/transform.hh>
+/// #include <mln/fun/v2v/rgb_to_rg.hh>
+/// #include <mln/img_path.hh>
+/// #include <mln/io/ppm/load.hh>
+/// #include <mln/value/rg.hh>
+/// #include <mln/value/rgb8.hh>
+///
+/// int main()
+/// {
+/// typedef mln::value::rg<8> t_rg8;
+/// typedef mln::value::rgb8 t_rgb8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+///
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+///
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+///
+/// mln::clustering::kmean2d<double, 8> kmean(img_rg8, 3);
+///
+/// kmean.launch_n_times();
+///
+/// return 0;
+/// }
+
+# include <limits.h>
+# include <iostream>
+
+# include <mln/accu/stat/histo2d.hh>
+
+# include <mln/algebra/vec.hh>
+
+# include <mln/core/concept/image.hh>
+# include <mln/core/contract.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/macros.hh>
+
+# include <mln/data/compute.hh>
+# include <mln/data/fill.hh>
+
+# include <mln/debug/println.hh>
+
+# include <mln/io/pgm/save.hh>
+# include <mln/io/ppm/save.hh>
+
+# include <mln/labeling/colorize.hh>
+# include <mln/labeling/mean_values.hh>
+
+# include <mln/literal/one.hh>
+# include <mln/literal/zero.hh>
+
+# include <mln/math/min.hh>
+# include <mln/math/sqr.hh>
+# include <mln/norm/l2.hh>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/trait/value_.hh>
+
+# include <mln/util/array.hh>
+
+# include <mln/value/int_u.hh>
+# include <mln/value/rgb8.hh>
+# include <mln/value/rg.hh>
namespace mln
{
@@ -85,21 +135,22 @@ namespace mln
namespace clustering
{
+
/// \brief Implements the kmean algorithm in a specific way.
///
- /// This version of the kmean algorithm uses a greyscale image as input,
- /// temporary images for computations and produces images as result. Images
- /// play the role of matrix or vector in standard statistic algoritm.
+ /// This version of the kmean algorithm uses a 2-channels
+ /// (red/green channel) image as input, temporary images for
+ /// computations and produces images as result. Images play the
+ /// role of matrix or vector in standard statistic algoritm.
///
- /// T is the type used for computations (float or double).
- /// n is the quantification for the image grayscale.
+ /// Param T is the type used for computations (float or double).
+ /// Param n is the quantification for the image grayscale.
template <typename T, unsigned n>
struct kmean2d
{
/// 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;
@@ -108,7 +159,7 @@ namespace mln
typedef T t_result1d;
typedef algebra::vec<2,T> t_result2d;
- /// FIXME t_point n'est pas forcément une image 2d, bien au contraire.
+ /// \fixme t_point_img is not an image2d ... but it works like this ...
typedef image2d<t_value> t_point_img;
typedef image2d<unsigned> t_histo_img;
typedef util::array<t_result1d> t_number_img;
@@ -128,35 +179,24 @@ 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;
-
///}
- //------------------------------------------------------------------------
- // Constructor
- //------------------------------------------------------------------------
-
- /// \brief Constructor
+ /// \brief Constructor.
/// \param[in] point : the image as the population of pixels.
/// \param[in] k_center : the number of centers.
/// \param[in] watch_dog : the limit to observe the convergence (10).
/// \param[in] n_times : the number of times that we executed kmean(10).
-
kmean2d(const t_point_img& point,
const unsigned k_center,
const unsigned watch_dog = 10,
const unsigned n_times = 10);
- //------------------------------------------------------------------------
- // Accessors
- //------------------------------------------------------------------------
-
- /// Mutator and accessors.
+ /// Mutators and accessors.
/// \{
/// \brief Mutator and accessors are required for debugging and testing.
///
/// Testing needs to hack the kmean loop process in order to verify each
/// step of the algorithm.
-
void set_point(t_point_img& point);
void set_histo(t_histo_img& histo);
void set_number(t_number_img& number);
@@ -187,10 +227,10 @@ namespace mln
/// \}
- //------------------------------------------------------------------------
- // Printing temporary results
- //------------------------------------------------------------------------
-
+ /// Show temporary results.
+ /// \{
+ /// \brief Formating temporary outputs for debugging.
+ ///
void print_mean();
void print_number();
void print_variance();
@@ -198,32 +238,18 @@ namespace mln
void print_group();
void print_point();
void print_histo();
-
- //------------------------------------------------------------------------
- // Initializations of centers
- //------------------------------------------------------------------------
+ /// \}
/// Initialization of centers.
/// \{
- /// \brief Two ways: Regular greylevel tick or random greylevel value or.
+ /// \brief Initialize centers by random position.
///
- /// There is two way to proceed the initialization. First of all, we
- /// divide the greyscale in regular tick and we assigne them to the mean
- /// of the centers. Finaly, we can ask random initialization along the
- /// greyscale axis. The second process is needed to launch_n_times the
- /// kmean and converge to the best descent.
-
+ /// Assign a random position in the 2-channel space to each center.
void init_mean();
- void init_mean_regular();
void init_mean_random();
-
/// \}
- //------------------------------------------------------------------------
- // Computations of distance, group, center, within variance
- //------------------------------------------------------------------------
-
/// Computations of distance, group, center, within variance.
/// \{
/// \brief Update the statistical information needed by the kmean process.
@@ -232,36 +258,27 @@ namespace mln
/// first compute. Then we assign the pixels to their nearest center.
/// The new location of each center can then update. Finaly, hommogeneity
/// in group is observed by the within variance.
-
void update_distance();
void update_group();
void update_mean();
void update_variance();
-
/// \}
- //------------------------------------------------------------------------
- // Main loop
- //------------------------------------------------------------------------
/// kmean main loop
/// \{
/// \brief User interface to launch the kmean process.
///
- /// There are two ways to launch the kmean process. The first one allow to
- /// run it one time until convergence. As the process is a descent, it
- /// depends on the initial center locations. The second call allow us to
- /// rerun the process many times and to keep the best result (the one
- /// with the smallest within variance).
-
+ /// There are two ways to launch the kmean process. The first
+ /// one allows to run it one time until convergence. As the
+ /// process is a descent, it depends on the initial center
+ /// location. The second call allow us to rerun the process
+ /// many times and to keep the best result (the one with the
+ /// smallest within variance).
void launch_one_time();
void launch_n_times();
-
/// \}
- //------------------------------------------------------------------------
- // Checking the validiy of the results
- //------------------------------------------------------------------------
/// Checking the validity of the results.
/// \{
@@ -269,16 +286,11 @@ namespace mln
///
/// After each launching the kmean process one time, we need to know if
/// the descent was successfull or not. The method is_valid_descent do it
- /// for us. The method looks for a bad center (a class with no greylevel
- /// associate to it) and a failure in the convergence.
-
+ /// for us. The method looks for a bad center (a class with no r/g color
+ /// associate to it) or a failure in the convergence.
bool is_descent_valid();
-
/// \}
- //------------------------------------------------------------------------
- // Debugging tools
- //------------------------------------------------------------------------
/// Debugging tools
/// \{
@@ -290,13 +302,11 @@ namespace mln
/// greylevel image. The update_cnv and finalize_cnv methods are used to
/// trace the convergence. They fill two images with the mean info and
/// the within variance info along the convergence and the tries.
-
void build_label_dbg();
void build_mean_dbg();
void build_all_dbg();
void update_cnv();
void finalize_cnv();
-
/// \}
@@ -313,13 +323,12 @@ namespace mln
/// kmean loop. As the kmean process is a descent, restarting the process
/// from different location will confort us in that we found a global
/// minima, not just a local one.
-
unsigned _k_center;
unsigned _watch_dog;
unsigned _n_times;
-
/// \}
+
/// Convergence information.
/// \{
/// \brief This information is used to follow the convergence.
@@ -337,16 +346,15 @@ namespace mln
/// again. The flag is_number_valid is set when a empty class
/// appears. This flag inhibit the process and force to restart
/// a try.
-
t_result1d _within_variance;
unsigned _current_step;
unsigned _current_launching;
bool _is_number_valid;
static const unsigned _N_TRIES = 3;
-
/// \}
+
/// Result of the kmean process.
/// \{
/// \brief The center location are the major results of the kmean process.
@@ -354,10 +362,11 @@ namespace mln
/// The kmean process result is composed by three information. The best
/// launching iteration, the best within variance obtained and the
/// location of the centers associated.
-
unsigned _launching_min;
t_result1d _variance_min;
t_mean_img _mean_min;
+ /// \}
+
/// Inputs.
/// \{
@@ -365,12 +374,11 @@ namespace mln
///
/// The point image is a saving data for the real inputs. In fact, we use
/// the histogram information in the optimized kmean process.
-
t_point_img _point;
t_histo_img _histo;
-
///\}
+
/// Centers description.
/// \{
/// \brief Centers are described by the first moment of their group.
@@ -381,27 +389,25 @@ namespace mln
/// convergence. The number of pixels is used as integrity indicator.
/// A center with no point is a non sense. Theses informations are updated
/// after each kmean iteration.
-
t_number_img _number; // k x 1
- t_mean_img _mean; // k x 1
+ t_mean_img _mean; // k x 2
t_variance_img _variance; // k x 1 within group
-
/// \}
+
/// Greylevels description.
/// \{
- /// \brief The information are concerned with the greylevel input image.
+ /// \brief The information are concerned with the 2-channel input image.
///
- /// The group image allow us to decide which greylevel (and of course
+ /// The group image allow us to decide which r/g value (and of course
/// which pixel) is assigned to a center. The distance image give us a
- /// clue on how a greylevel could contribute to a center. The summation
- /// over the greylevels of a center give us the within variance.
-
- t_group_img _group; // g x 1 because dim(t_value) = 1
- t_distance_img _distance; // label x graylevel
-
+ /// clue on how a r/g value could contribute to a center. The summation
+ /// over the r/g values of a center give us the within variance.
+ t_group_img _group; // g x 2 because dim(t_value) = 2
+ t_distance_img _distance; // label x r/g value
/// \}
+
/// Debugging, calibrating and testing results.
/// \{
/// \brief Some exports information to control the results.
@@ -412,14 +418,13 @@ namespace mln
/// label (assigned to the same center) in the image. The mean image
/// associate the mean of each pixel center to each pixel. We obtain thus
/// a rebuilded image.
-
t_label_dbg _label_dbg;
t_color_dbg _color_dbg;
t_mean_dbg _mean_dbg;
-
/// \}
- /// Debugging, calibrating and testing convergence.
+
+ /// Variance and center evolutions.
/// \{
/// \brief Trace the variance and the center evolution.
///
@@ -428,10 +433,8 @@ namespace mln
/// kmean loop or along the different launch. The variance_cnv is a trace
/// of the within variance along the kmean loop or along the different
/// launch.
-
t_mean_cnv _mean_cnv;
t_variance_cnv _variance_cnv;
-
/// \}
};
@@ -448,7 +451,7 @@ namespace mln
const unsigned watch_dog,
const unsigned n_times)
{
- trace::entering("mln::clustering::kmean2d::kmean2d");
+ trace::entering("mln::clustering::kmean2d::cstor");
mln_precondition(point.is_valid());
_k_center = k_center;
@@ -516,7 +519,7 @@ namespace mln
_mean_cnv.append(mean_set);
}
- trace::exiting("mln::clustering::kmean2d::kmean2d");
+ trace::exiting("mln::clustering::kmean2d::cstor");
}
//--------------------------------------------------------------------------
@@ -796,15 +799,15 @@ namespace mln
{
trace::entering("mln::clustering::kmean2d::print_histo");
- mln_piter(t_histo_img) rgb(_histo.domain());
+ mln_piter(t_histo_img) rg(_histo.domain());
- for_all(rgb)
+ for_all(rg)
{
- if (0 < _histo(rgb))
+ if (0 < _histo(rg))
{
- std::cout << "histo(r=" << rgb.row();
- std::cout << ", g=" << rgb.col();
- std::cout << ")= " << _histo(rgb);
+ std::cout << "histo(r=" << rg.row();
+ std::cout << ", g=" << rg.col();
+ std::cout << ")= " << _histo(rg);
std::cout << std::endl;
}
}
@@ -818,15 +821,15 @@ namespace mln
{
trace::entering("mln::clustering::kmean2d::print_group");
- mln_piter(t_group_img) rgb(_group.domain());
+ mln_piter(t_group_img) rg(_group.domain());
- for_all(rgb)
+ for_all(rg)
{
- if (0 < _histo(rgb))
+ if (0 < _histo(rg))
{
- std::cout << "group(r=" << rgb.row();
- std::cout << ", g=" << rgb.col();
- std::cout << ")= " << _group(rgb);
+ std::cout << "group(r=" << rg.row();
+ std::cout << ", g=" << rg.col();
+ std::cout << ")= " << _group(rg);
std::cout << std::endl;
}
}
@@ -844,16 +847,16 @@ namespace mln
for_all(l)
{
- mln_piter(t_distance_val) rgb(_distance[l.index_()].domain());
+ mln_piter(t_distance_val) rg(_distance[l.index_()].domain());
- for_all(rgb)
+ for_all(rg)
{
- if (0 < _histo(rgb))
+ if (0 < _histo(rg))
{
std::cout << "distance(l=" << l.index_();
- std::cout << ",r=" << rgb.row();
- std::cout << ", g=" << rgb.col();
- std::cout << ")= " << _distance[l.index_()](rgb);
+ std::cout << ",r=" << rg.row();
+ std::cout << ", g=" << rg.col();
+ std::cout << ")= " << _distance[l.index_()](rg);
std::cout << std::endl;
}
}
@@ -960,9 +963,9 @@ namespace mln
{
trace::entering("mln::clustering::kmean2d::update_group");
- mln_piter(t_group_img) rgb(_group.domain());
+ mln_piter(t_group_img) rg(_group.domain());
- for_all(rgb)
+ for_all(rg)
{
mln_eiter(t_distance_img) l(_distance);
t_result1d min = mln_max(t_result1d);
@@ -972,9 +975,9 @@ namespace mln
for_all(l)
{
- if (min > _distance[l.index_()](rgb))
+ if (min > _distance[l.index_()](rg))
{
- min = _distance[l.index_()](rgb);
+ min = _distance[l.index_()](rg);
label = l.index_();
}
@@ -984,7 +987,7 @@ namespace mln
//std::cout << "g = " << g << std::endl;
- _group(rgb) = label;
+ _group(rg) = label;
//std::cout << "group = " << _group(g) << std::endl;
//std::cout << "-----------" << std::endl;
}
@@ -998,8 +1001,6 @@ namespace mln
{
trace::entering("mln::clustering::kmean2d::update_mean");
- /// FIXME VERIFIER QUE L'ON PEUT OBTENIR UNE IMAGE EN NDG SIGNE
-
// avec g le niveau de gris (signed or not signed)
// w[g] la classe de g sous forme d'image
// h[g] l'histogramme de l'image sous forme d'image
@@ -1021,14 +1022,14 @@ namespace mln
_mean[em.index_()] = literal::zero;
}
- mln_piter(t_group_img) rgb(_group.domain());
+ mln_piter(t_group_img) rg(_group.domain());
- for_all(rgb)
+ for_all(rg)
{
// peut être faut-il le decomposer par composantes
- _mean[_group(rgb)][0] += rgb.row() * _histo(rgb);
- _mean[_group(rgb)][1] += rgb.col() * _histo(rgb);
- _number(_group(rgb)) += _histo(rgb);
+ _mean[_group(rg)][0] += rg.row() * _histo(rg);
+ _mean[_group(rg)][1] += rg.col() * _histo(rg);
+ _number(_group(rg)) += _histo(rg);
}
mln_eiter(t_mean_img) l(_mean);
@@ -1072,12 +1073,12 @@ namespace mln
{
_variance[l.index_()] = literal::zero;
- mln_piter(t_group_img) rgb(_group.domain());
+ mln_piter(t_group_img) rg(_group.domain());
- for_all(rgb)
+ for_all(rg)
{
- if (l.index_() == _group(rgb))
- _variance[l.index_()] += _distance[l.index_()](rgb);
+ if (l.index_() == _group(rg))
+ _variance[l.index_()] += _distance[l.index_()](rg);
}
_within_variance += _variance[l.index_()];
@@ -1334,7 +1335,7 @@ namespace mln
trace::exiting("mln::clustering::kmean2d::launch_n_times");
}
-#endif // ! MLN_INCLUDE_ONLY
+# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln::clustering
diff --git a/scribo/sandbox/green/mln/clustering/kmean3d.hh
b/scribo/sandbox/green/mln/clustering/kmean3d.hh
index fb1a8df..c35d2a7 100644
--- a/scribo/sandbox/green/mln/clustering/kmean3d.hh
+++ b/scribo/sandbox/green/mln/clustering/kmean3d.hh
@@ -1,4 +1,4 @@
-// Copyright (C) 2008,2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2007,2008,2009,2010 EPITA LRDE
//
// This file is part of Olena.
//
@@ -24,51 +24,102 @@
// executable file might be covered by the GNU General Public License.
#ifndef MLN_CLUSTERING_KMEAN3D_HH
-#define MLN_CLUSTERING_KMEAN3D_HH
+# define MLN_CLUSTERING_KMEAN3D_HH
/// \file
///
-/// \brief Implements the optimized kmean algorithm.
+/// \brief Implements the optimized kmean algorithm in 3d.
///
/// This algorithm is optimized in the way it proceeds directly with
-/// the rgb values inspite of the pixel attribute. The
+/// the rgb value inspite of the pixel attribute. The
/// algorithm is independant from the image dimension. But, we have to
/// compute one time the histogram. In fact, we move a recurrent cost
-/// to a fix cost in the complexity. This version is adapted to
-/// image with small quantification.
-
-#include <limits.h>
-#include <iostream>
-#include <mln/trace/entering.hh>
-#include <mln/trace/exiting.hh>
-
-#include <mln/core/contract.hh>
-#include <mln/trait/value_.hh>
-#include <mln/accu/stat/histo3d_rgb.hh>
-
-#include <mln/math/min.hh>
-#include <mln/math/sqr.hh>
-#include <mln/norm/l2.hh>
-
-#include <mln/core/image/image2d.hh>
-#include <mln/core/concept/image.hh>
-#include <mln/value/int_u.hh>
-#include <mln/value/rgb8.hh>
-#include <mln/core/macros.hh>
-
-#include <mln/data/compute.hh>
-#include <mln/debug/println.hh>
-#include <mln/data/fill.hh>
-#include <mln/literal/zero.hh>
-#include <mln/literal/one.hh>
-#include <mln/labeling/colorize.hh>
-#include <mln/labeling/mean_values.hh>
-
-#include <mln/io/ppm/save.hh>
-#include <mln/io/pgm/save.hh>
-
-#include <mln/util/array.hh>
-#include <mln/algebra/vec.hh>
+/// by a fix cost in the complexity. This version is very adapted to
+/// images with small quantification. But, in 3d, the execution
+/// becomes very slow. It's just normal because the quantification is
+/// n bits per axis. So the actual histogram may be bigger than the image.
+///
+/// Take care to the following point: The within variance is still a
+/// scalar value because we take the distance between two points and
+/// the result is a scalar from the geometrical point of view. An
+/// alternative implementation could study the variance/covariance
+/// matrix of each sub data clouds and works with the trace of the
+/// within variance matrix (as we do for the fisher criteria in N-d).
+///
+/// The following sample is a typical use of the new kmean implementation.
+///
+/// #include <iostream>
+/// #include <mln/clustering/kmean3d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/transform.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>
+///
+/// int main()
+/// {
+/// typedef mln::clustering::kmean3d<double,5> t_kmean;
+/// typedef mln::value::rgb8 t_rgb8;
+/// typedef mln::value::rgb<5> t_rgb5;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<t_rgb5> t_image2d_rgb5;
+/// typedef mln::fun::v2v::rgb8_to_rgbn<5> t_rgb8_to_rgb5;
+///
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rgb5 img_rgb5;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+///
+/// img_rgb5=mln::data::transform(img_rgb8, t_rgb8_to_rgb5());
+///
+/// t_kmean kmean(img_rgb5, 3);
+///
+/// kmean.launch_n_times();
+///
+/// return 0;
+/// }
+
+# include <limits.h>
+# include <iostream>
+
+# include <mln/accu/stat/histo3d_rgb.hh>
+
+# include <mln/algebra/vec.hh>
+
+# include <mln/math/min.hh>
+# include <mln/math/sqr.hh>
+# include <mln/norm/l2.hh>
+
+# include <mln/core/concept/image.hh>
+# include <mln/core/contract.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/macros.hh>
+
+# include <mln/data/compute.hh>
+# include <mln/data/fill.hh>
+# include <mln/debug/println.hh>
+
+# include <mln/labeling/colorize.hh>
+# include <mln/labeling/mean_values.hh>
+
+# include <mln/literal/one.hh>
+# include <mln/literal/zero.hh>
+
+# include <mln/io/ppm/save.hh>
+# include <mln/io/pgm/save.hh>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/trait/value_.hh>
+
+# include <mln/util/array.hh>
+
+# include <mln/value/int_u.hh>
+# include <mln/value/rgb8.hh>
+
namespace mln
{
@@ -98,7 +149,6 @@ 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::rgb<n> t_value;
@@ -108,7 +158,7 @@ namespace mln
typedef T t_result1d;
typedef algebra::vec<3,T> t_result3d;
- /// FIXME t_point n'est pas forcément une image 2d, bien au contraire.
+ /// \fixme t_point is not an image2d, it may be something else ...
typedef image2d<t_value> t_point_img;
typedef image3d<unsigned> t_histo_img;
typedef util::array<t_result1d> t_number_img;
@@ -128,35 +178,26 @@ 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;
-
///}
- //------------------------------------------------------------------------
- // Constructor
- //------------------------------------------------------------------------
- /// \brief Constructor
+ /// \brief Constructor.
+ ///
/// \param[in] point : the image as the population of pixels.
/// \param[in] k_center : the number of centers.
/// \param[in] watch_dog : the limit to observe the convergence (10).
/// \param[in] n_times : the number of times that we executed kmean(10).
-
kmean3d(const t_point_img& point,
const unsigned k_center,
const unsigned watch_dog = 10,
const unsigned n_times = 10);
- //------------------------------------------------------------------------
- // Accessors
- //------------------------------------------------------------------------
-
- /// Mutator and accessors.
+ /// Mutators and accessors.
/// \{
/// \brief Mutator and accessors are required for debugging and testing.
///
/// Testing needs to hack the kmean loop process in order to verify each
/// step of the algorithm.
-
void set_point(t_point_img& point);
void set_histo(t_histo_img& histo);
void set_number(t_number_img& number);
@@ -184,13 +225,13 @@ namespace mln
// Normal outputs
t_mean_img& to_result();
-
/// \}
- //------------------------------------------------------------------------
- // Printing temporary results
- //------------------------------------------------------------------------
+ /// Show temporary results.
+ /// \{
+ /// \brief Formating temporary outputs for debugging.
+ ///
void print_mean();
void print_number();
void print_variance();
@@ -198,32 +239,19 @@ namespace mln
void print_group();
void print_point();
void print_histo();
+ /// \}
- //------------------------------------------------------------------------
- // Initializations of centers
- //------------------------------------------------------------------------
/// Initialization of centers.
/// \{
- /// \brief Two ways: Regular greylevel tick or random greylevel value or.
+ /// \brief Initialize centers by random position.
///
- /// There is two way to proceed the initialization. First of all, we
- /// divide the rgb space in regular tick and we assigne them to the mean
- /// of the centers. Finaly, we can ask random initialization along the
- /// greyscale axis. The second process is needed to launch_n_times the
- /// kmean and converge to the best descent.
-
+ /// Assign a random position in the rgb space to each center.
void init_mean();
- void init_mean_regular();
void init_mean_random();
-
/// \}
- //------------------------------------------------------------------------
- // Computations of distance, group, center, within variance
- //------------------------------------------------------------------------
-
/// Computations of distance, group, center, within variance.
/// \{
/// \brief Update the statistical information needed by the kmean process.
@@ -232,36 +260,27 @@ namespace mln
/// first compute. Then we assign the pixels to their nearest center.
/// The new location of each center can then update. Finaly, hommogeneity
/// in group is observed by the within variance.
-
void update_distance();
void update_group();
void update_mean();
void update_variance();
-
/// \}
- //------------------------------------------------------------------------
- // Main loop
- //------------------------------------------------------------------------
/// kmean main loop
/// \{
/// \brief User interface to launch the kmean process.
///
- /// There are two ways to launch the kmean process. The first one allow to
- /// run it one time until convergence. As the process is a descent, it
- /// depends on the initial center locations. The second call allow us to
- /// rerun the process many times and to keep the best result (the one
- /// with the smallest within variance).
-
+ /// There are two ways to launch the kmean process. The first
+ /// one allows to run it one time until convergence. As the
+ /// process is a descent, it depends on the initial center
+ /// location. The second call allow us to rerun the process
+ /// many times and to keep the best result (the one with the
+ /// smallest within variance).
void launch_one_time();
void launch_n_times();
-
/// \}
- //------------------------------------------------------------------------
- // Checking the validiy of the results
- //------------------------------------------------------------------------
/// Checking the validity of the results.
/// \{
@@ -271,32 +290,22 @@ namespace mln
/// the descent was successfull or not. The method is_valid_descent do it
/// for us. The method looks for a bad center (a class with no greylevel
/// associate to it) and a failure in the convergence.
-
bool is_descent_valid();
-
/// \}
- //------------------------------------------------------------------------
- // Debugging tools
- //------------------------------------------------------------------------
-
- /// Debugging tools
+ /// Checking the validity of the results.
/// \{
- /// \brief These methods help to interpret results.
+ /// \brief These methods help us to determine the validity of the results.
///
- /// The methods build_label_dbg and build_all_dbg work in the input data
- /// space. The first one build the 2d image of labels. The second call the
- /// first one and then builds the colorize label' image and the mean
- /// greylevel image. The update_cnv and finalize_cnv methods are used to
- /// trace the convergence. They fill two images with the mean info and
- /// the within variance info along the convergence and the tries.
-
+ /// After each launching the kmean process one time, we need to know if
+ /// the descent was successfull or not. The method is_valid_descent do it
+ /// for us. The method looks for a bad center (a class with no color
+ /// associate to it) or a failure in the convergence.
void build_label_dbg();
void build_mean_dbg();
void build_all_dbg();
void update_cnv();
void finalize_cnv();
-
/// \}
@@ -313,13 +322,12 @@ namespace mln
/// kmean loop. As the kmean process is a descent, restarting the process
/// from different location will confort us in that we found a global
/// minima, not just a local one.
-
unsigned _k_center;
unsigned _watch_dog;
unsigned _n_times;
-
/// \}
+
/// Convergence information.
/// \{
/// \brief This information is used to follow the convergence.
@@ -337,14 +345,12 @@ namespace mln
/// again. The flag is_number_valid is set when a empty class
/// appears. This flag inhibit the process and force to restart
/// a try.
-
t_result1d _within_variance;
unsigned _current_step;
unsigned _current_launching;
bool _is_number_valid;
static const unsigned _N_TRIES = 3;
-
/// \}
/// Result of the kmean process.
@@ -354,10 +360,10 @@ namespace mln
/// The kmean process result is composed by three information. The best
/// launching iteration, the best within variance obtained and the
/// location of the centers associated.
-
unsigned _launching_min;
t_result1d _variance_min;
t_mean_img _mean_min;
+ /// \}
/// Inputs.
/// \{
@@ -365,12 +371,11 @@ namespace mln
///
/// The point image is a saving data for the real inputs. In fact, we use
/// the histogram information in the optimized kmean process.
-
t_point_img _point;
t_histo_img _histo;
-
///\}
+
/// Centers description.
/// \{
/// \brief Centers are described by the first moment of their group.
@@ -381,11 +386,9 @@ namespace mln
/// convergence. The number of pixels is used as integrity indicator.
/// A center with no point is a non sense. Theses informations are updated
/// after each kmean iteration.
-
t_number_img _number; // k x 1
- t_mean_img _mean; // k x 1
+ t_mean_img _mean; // k x 3
t_variance_img _variance; // k x 1 within group
-
/// \}
/// rgb image description.
@@ -396,12 +399,11 @@ namespace mln
/// which pixel) is assigned to a center. The distance image give us a
/// clue on how a greylevel could contribute to a center. The summation
/// over the rgb space of a center give us the within variance.
-
t_group_img _group; // g x 3 because dim(t_value) = 3
t_distance_img _distance; // label x rgb space
-
/// \}
+
/// Debugging, calibrating and testing results.
/// \{
/// \brief Some exports information to control the results.
@@ -412,14 +414,12 @@ namespace mln
/// label (assigned to the same center) in the image. The mean image
/// associate the mean of each pixel center to each pixel. We obtain thus
/// a rebuilded image.
-
t_label_dbg _label_dbg;
t_color_dbg _color_dbg;
t_mean_dbg _mean_dbg;
-
/// \}
- /// Debugging, calibrating and testing convergence.
+ /// Variance and center evolutions.
/// \{
/// \brief Trace the variance and the center evolution.
///
@@ -428,10 +428,8 @@ namespace mln
/// kmean loop or along the different launch. The variance_cnv is a trace
/// of the within variance along the kmean loop or along the different
/// launch.
-
t_mean_cnv _mean_cnv;
t_variance_cnv _variance_cnv;
-
/// \}
};
@@ -448,7 +446,7 @@ namespace mln
const unsigned watch_dog,
const unsigned n_times)
{
- trace::entering("mln::clustering::kmean3d::kmean3d");
+ trace::entering("mln::clustering::kmean3d::cstor");
mln_precondition(point.is_valid());
_k_center = k_center;
@@ -520,7 +518,7 @@ namespace mln
_mean_cnv.append(mean_set);
}
- trace::exiting("mln::clustering::kmean3d::kmean3d");
+ trace::exiting("mln::clustering::kmean3d::cstor");
}
//--------------------------------------------------------------------------
@@ -1338,7 +1336,7 @@ namespace mln
trace::exiting("mln::clustering::kmean3d::launch_n_times");
}
-#endif // ! MLN_INCLUDE_ONLY
+# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln::clustering
diff --git a/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
b/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
index 253745b..544066b 100644
--- a/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
+++ b/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
@@ -1,4 +1,4 @@
-// Copyright (C) 2008,2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2007,2008,2009,2010 EPITA LRDE
//
// This file is part of Olena.
//
@@ -28,16 +28,68 @@
/// \file
///
-/// \brief Implements the optimized kmean algorithm.
+/// \brief Implements the optimized kmean algorithm in the 3d-RGB space.
///
/// This algorithm is optimized in the way it proceeds directly with
-/// the rgb values inspite of the pixel attribute. The
+/// the rgb value inspite of the pixel attribute. The
/// algorithm is independant from the image dimension. But, we have to
/// compute one time the histogram. In fact, we move a recurrent cost
-/// to a fix cost in the complexity. This version is adapted to
-/// image with small quantification.
-
-/// APLATISSEMENT DES KMEAN3D
+/// by a fix cost in the complexity. This version is very adapted to
+/// images with small quantification. But, in 3d, the execution
+/// becomes very slow. It's just normal because the quantification is
+/// n bits per axis. So the actual histogram may be bigger than the image.
+///
+/// Take care to the following point: The within variance is still a
+/// scalar value because we take the distance between two points and
+/// the result is a scalar from the geometrical point of view. An
+/// alternative implementation could study the variance/covariance
+/// matrix of each sub data clouds and works with the trace of the
+/// within variance matrix (as we do for the fisher criteria in N-d).
+///
+/// The following sample is a typical use of the functional (versus
+/// object) kmean implementation.
+///
+/// #include <iostream>
+/// #include <mln/clustering/kmean_rgb.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/transform.hh>
+/// #include <mln/fun/v2v/rgb8_to_rgbn.hh>
+/// #include <mln/img_path.hh>
+/// #include <mln/io/ppm/load.hh>
+/// #include <mln/value/label_8.hh>
+/// #include <mln/value/rgb.hh>
+/// #include <mln/value/rgb8.hh>
+///
+/// int main()
+/// {
+/// typedef mln::value::label_8 t_lbl8;
+/// typedef mln::value::rgb8 t_rgb8;
+/// typedef mln::value::rgb<5> t_rgb5;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<t_rgb5> t_image2d_rgb5;
+/// typedef mln::image2d<t_lbl8> t_image2d_lbl8;
+/// typedef mln::fun::v2v::rgb8_to_rgbn<5> t_rgb8_to_rgb5;
+///
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rgb5 img_rgb5;
+/// t_image2d_lbl8 img_lbl8;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+///
+/// img_rgb5 = mln::data::transform(img_rgb8, t_rgb8_to_rgb5());
+/// img_lbl8 = mln::clustering::kmean_rgb<double,5>(img_rgb5, 3);
+///
+/// return 0;
+/// }
+///
+/// \fixme The execution shows a bug in printing outputs and it seems severe.
+///
+/// The last execution with the following set of parameters
+/// {house.ppm,3,10,10} shows that if the binary starts correctly, it
+/// ends before returning the label image and with disturbing outputs.
+/// Dumping the outputs in a file reveals that the number of
+/// trace::entering differs from the number of trace::exiting. May the
+/// program exit from a loop without ending a trace ???
# include <limits.h>
# include <iostream>
@@ -86,7 +138,7 @@
//--------------------------------------------------------------------------
-// CODE APLATI
+// FUNCTIONAL CODE
//--------------------------------------------------------------------------
@@ -95,7 +147,24 @@ namespace mln
namespace clustering
{
-
+ /// \brief Implements the functional kmean algorithm.
+ ///
+ /// This functional version of the kmean is very specific. All the
+ /// code is view as a one-block function. This code is provided as
+ /// is. I (YJ) don't know where i stopped this version. It may not
+ /// work. Debugging tools are not yet provided. This code is just
+ /// the functional transcription of the kmean3d version. The code
+ /// has the very experimental status.
+ ///
+ /// T is the type used for computations (float or double).
+ /// n is the quantification for the rgb image.
+ ///
+ /// \param[in] point : the image as the population of pixels.
+ /// \param[in] k_center : the number of centers.
+ /// \param[in] watch_dog : the limit to observe the convergence (10).
+ /// \param[in] n_times : the number of times that we executed kmean(10).
+ ///
+ /// \return an image which represents the pixel classification.
template <typename T, unsigned n, typename I>
inline
image2d<value::label_8>
diff --git a/scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
b/scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
index ca7ba51..e89edad 100644
--- a/scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
+++ b/scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
@@ -1,6 +1,4 @@
-// Copyright (C) 2007 EPITA Research and Development Laboratory (LRDE)
-// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE)
-// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2007,2008,2009,2010 EPITA LRDE
//
// This file is part of Olena.
//
@@ -34,7 +32,51 @@
/// \file
///
-/// \brief Convert rg value to rgb
+/// \brief Convert a rg value to a rgb value.
+///
+/// This source implements the conversion between rg space and rgb space.
+///
+/// The following sample is a typical use of the rg/rgb conversion function.
+///
+/// #include <iostream>
+/// #include <mln/clustering/kmean2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/transform.hh>
+/// #include <mln/fun/v2v/rgb_to_rg.hh>
+/// #include <mln/fun/v2v/rg_to_rgb.hh>
+/// #include <mln/img_path.hh>
+/// #include <mln/io/ppm/load.hh>
+/// #include <mln/value/rg.hh>
+/// #include <mln/value/rgb8.hh>
+///
+/// int main()
+/// {
+/// typedef mln::value::rg<8> t_rg8;
+/// typedef mln::value::rgb8 t_rgb8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::fun::v2v::rg_to_rgb<8> t_rg_to_rgb;
+///
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rgb8 point_img_rgb8;
+/// t_image2d_rg8 img_rg8;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+///
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+///
+/// mln::clustering::kmean2d<double, 8> kmean(img_rg8, 3);
+///
+/// kmean.launch_n_times();
+///
+/// mln::clustering::kmean2d<double,8>::t_point_img point_img =
+/// kmean.get_point();
+///
+/// point_img_rgb8 = mln::data::transform(point_img, t_rg_to_rgb());
+///
+/// return 0;
+/// }
namespace mln
{
@@ -47,14 +89,21 @@ namespace mln
/// \brief Convert rg value to rgb.
///
+ /// Param n defines the quantification used for rgb space and rg space.
+ ///
/// \ingroup modfunv2v
-
template <unsigned n>
struct rg_to_rgb : Function_v2v< rg_to_rgb<n> >
{
typedef value::rg<n> argument;
typedef value::rgb<n> result;
+ /// \brief Convert rg value to rgb value.
+ ///
+ /// \param[in] v the rg value to convert.
+ ///
+ /// Conversion is done by calling the rgb constructor and fill
+ /// the empty attirbute by 127.
result operator()(const argument& v) const
{
return value::rgb<n>(v.red(), v.green(), 127);
diff --git a/scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
b/scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
index 5f00678..77f9015 100644
--- a/scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
+++ b/scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
@@ -6,8 +6,13 @@
# TOOLS #
#########
-INCLUDES= -I$(HOME)/svn/oln/trunk/milena/sandbox/green
+#LOADLIBES= -lboost_filesystem
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
CXXFLAGS= -ggdb -O0 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O1 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
+#CXXFLAGS= -DNDEBUG -O3 -Wall -W -pedantic -ansi -pipe $(INCLUDES)
ECHO= echo
RM= rm
MKDIR= mkdir -p
@@ -20,10 +25,10 @@ BUILD__PATTERN= green/build/tests
ifeq ($(findstring $(BUILD__PATTERN),$(PWD)), $(BUILD__PATTERN))
# Case where make is done from build directory.
SOURCE_DIR= $(subst $(BUILD__PATTERN),$(SOURCE_PATTERN),$(PWD))
-BUILD__DIR= $(PWD)
+BUILD__DIR= $(PWD)/
else
# Case where make is done from source directory.
-SOURCE_DIR= $(PWD)
+SOURCE_DIR= $(PWD)/
BUILD__DIR= $(subst $(SOURCE_PATTERN),$(BUILD__PATTERN),$(PWD))
endif
@@ -89,7 +94,7 @@ $(OBJ_F_PATH):$(SRC_F_PATH)
#########
# Force every time the deletion
-clean: print clean_target clean_obj clean_dst clean_old #clean_make
+clean: clean_target clean_obj clean_dst clean_old #clean_make
clean_target:
diff --git a/scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
b/scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
index 27751fd..a839ece 100644
--- a/scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
+++ b/scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
@@ -1,34 +1,68 @@
-// UNARY TESTS ON K_MEAN
-
-#include <mln/clustering/k_mean.hh>
+// 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 This source manages unitary testing on the kmean implementation.
+///
+/// Tests are performed from 2 bits up to 8 bits quantification. The goal
+/// is to go through each programmatic flow to verify the conformity of the
+/// code. It sounds like a theoritic model of unitary testing for milena.
+/// The last test enables statistic computations on that component.
#include <iostream>
-#include <mln/pw/value.hh>
-
-#include <mln/value/int_u8.hh>
-#include <mln/value/rgb8.hh>
-
#include <mln/literal/colors.hh>
#include <mln/algebra/vec.hh>
#include <mln/algebra/mat.hh>
+#include <mln/clustering/k_mean.hh>
+
#include <mln/core/macros.hh>
#include <mln/core/contract.hh>
#include <mln/core/image/image2d.hh>
#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/data/transform.hh>
+
+#include <mln/img_path.hh>
+
#include <mln/io/ppm/load.hh>
#include <mln/io/pgm/load.hh>
#include <mln/io/pgm/save.hh>
#include <mln/io/ppm/save.hh>
-#include <mln/data/transform.hh>
-
#include <mln/trait/value/print.hh>
#include <mln/trait/image/print.hh>
+#include <mln/pw/value.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/rgb8.hh>
+
#define SIZE_IMAGE 512
#define SIZE_SAMPLE1 (512*512)
#define SIZE_SAMPLE2 4
@@ -44,20 +78,18 @@
#define MAT_GROUP2 mln::algebra::mat<SIZE_SAMPLE2, NB_CENTER, TYPE_POINT>
#define VEC_VAR mln::algebra::vec<NB_CENTER, TYPE_POINT>
-
-void test_instantiation()
-{
- mln::clustering::k_mean<SIZE_SAMPLE2,NB_CENTER, DIM_POINT, TYPE_POINT> kmean;
-
- // test the compilation
-
- std::cout << "test instantiation : ok" << std::endl;
-}
+/// Tools.
+/// \{
+/// \brief Define some tools which are used in unitary testing.
+///
+/// This kind of tools help to fill an image with only 4 tons or
+/// computing a distance between two colors. Just keep an eye, nothing
+/// really difficult in this code.
struct rgb8_to_4colors : mln::Function_v2v<rgb8_to_4colors>
{
typedef mln::value::rgb8 result;
-
+
mln::value::rgb8 operator()(const mln::value::rgb8& color) const
{
mln::value::rgb8 result;
@@ -78,11 +110,12 @@ struct rgb8_to_4colors : mln::Function_v2v<rgb8_to_4colors>
void print_color(const mln::value::rgb8& color)
{
- std::cout << "{r=" << color.red() << ", ";
+ std::cout << "{r=" << color.red() << ", ";
std::cout << "g=" << color.green() << ", ";
std::cout << "b=" << color.blue() << "}"
<< std::endl;
}
+
void fill_image_with_4colors(mln::image2d<mln::value::rgb8>& img)
{
const mln::value::rgb8 lime = mln::literal::lime;
@@ -98,6 +131,140 @@ void
fill_image_with_4colors(mln::image2d<mln::value::rgb8>& img)
//print_color(purple);
}
+
+double dist(mln::value::rgb8 color1, mln::value::rgb8 color2)
+{
+ double red = color1.red() - color2.red();
+ double green = color1.green() - color2.green();
+ double blue = color1.blue() - color2.blue();
+ double result= red * red + green * green + blue * blue;
+
+ return result;
+}
+
+/// \}
+
+
+/// External mutators.
+/// \{
+/// \brief Replace the kmean data structure values.
+///
+/// This is a hack that provides low level routines to access key data
+/// structure like point, center, distance and group.
+
+void set_point(MAT_POINT2& point,
+ const unsigned index,
+ const mln::value::rgb8& color)
+{
+ point(index,0) = color.red();
+ point(index,1) = color.green();
+ point(index,2) = color.blue();
+}
+
+void set_center(MAT_CENTER& center,
+ const unsigned index,
+ const mln::value::rgb8& color)
+{
+ center(index,0) = color.red();
+ center(index,1) = color.green();
+ center(index,2) = color.blue();
+}
+
+void set_distance(MAT_DISTANCE2& distance,
+ const unsigned index,
+ const double d1,
+ const double d2)
+{
+ distance(index,0) = d1;
+ distance(index,1) = d2;
+}
+
+void set_group(MAT_GROUP2& group,
+ const unsigned index,
+ const unsigned min)
+{
+ group(index, min) = 1.0;
+ group(index, 1-min) = 0.0;
+}
+
+/// \}
+
+/// Fake states.
+/// \{
+/// \brief Help to build from scratch temporary states for the kmean algorithm.
+///
+/// This hack allow us to build temporary results used in the previous step to
+/// make us very the behaviour of the current step. There is a fake state for
+/// every key data structure (point, group, center and distance).
+
+void fake_init_point(MAT_POINT2& point,
+ const mln::value::rgb8& point1,
+ const mln::value::rgb8& point2,
+ const mln::value::rgb8& point3,
+ const mln::value::rgb8& point4)
+{
+ set_point(point, 0, point1);
+ set_point(point, 1, point2);
+ set_point(point, 2, point3);
+ set_point(point, 3, point4);
+}
+
+
+void fake_update_group(MAT_GROUP2& group,
+ const unsigned& point1_min,
+ const unsigned& point2_min,
+ const unsigned& point3_min,
+ const unsigned& point4_min)
+{
+ set_group(group, 0, point1_min);
+ set_group(group, 1, point2_min);
+ set_group(group, 2, point3_min);
+ set_group(group, 3, point4_min);
+}
+
+
+void fake_init_center(MAT_CENTER& center,
+ const mln::value::rgb8 center1,
+ const mln::value::rgb8 center2)
+{
+
+ set_center(center, 0, center1);
+ set_center(center, 1, center2);
+}
+
+
+
+
+void fake_update_distance(MAT_DISTANCE2& distance,
+ const mln::value::rgb8& point1,
+ const mln::value::rgb8& point2,
+ const mln::value::rgb8& point3,
+ const mln::value::rgb8& point4,
+ const mln::value::rgb8& center1,
+ const mln::value::rgb8& center2)
+{
+ set_distance(distance, 0, dist(point1, center1), dist(point1, center2));
+ set_distance(distance, 1, dist(point2, center1), dist(point2, center2));
+ set_distance(distance, 2, dist(point3, center1), dist(point3, center2));
+ set_distance(distance, 3, dist(point4, center1), dist(point4, center2));
+
+ /*
+ for (int i = 0; i < SIZE_SAMPLE2; ++i)
+ for (int j = 0; j < NB_CENTER; ++j)
+ std::cout << "d(" << i << "," << j
<< ") = " << distance(i,j) <<std::endl;
+ */
+}
+
+/// \}
+
+/// Equivalence.
+/// \{
+/// \brief Test equivalence between point and image, center and color.
+///
+/// Two kinds of equivalence are defined here. The first one tests the
+/// equality between the data cloud and the initial image, while the
+/// second one tests the equality between a center and a color.
+
bool is_equivalent(const mln::image2d<mln::value::rgb8>& img,
const MAT_POINT1& point)
{
@@ -118,11 +285,11 @@ bool is_equivalent(const mln::image2d<mln::value::rgb8>&
img,
if (!test)
{
std::cout << pi;
- std::cout << "{r=" << img(pi).red() << ",
";
+ std::cout << "{r=" << img(pi).red() << ",
";
std::cout << "g=" << img(pi).green() << ",
";
std::cout << "b=" << img(pi).blue() <<
"}";
std::cout << index;
- std::cout << "[r=" << point(index,0) << ",
";
+ std::cout << "[r=" << point(index,0) << ",
";
std::cout << "g=" << point(index,1) << ",
";
std::cout << "b=" << point(index,2) << "]"
<< std::endl;
@@ -135,6 +302,44 @@ bool is_equivalent(const mln::image2d<mln::value::rgb8>&
img,
return result;
}
+bool is_equal(const mln::value::rgb8& ref,
+ const MAT_CENTER& center,
+ const unsigned i)
+{
+ bool result = true;
+
+ result = result && (center(i, 0) - ref.red() < 1.0);
+ result = result && (center(i, 1) - ref.green() < 1.0);
+ result = result && (center(i, 2) - ref.blue() < 1.0);
+
+ return result;
+}
+
+/// \}
+
+
+/// kmean unitary testing
+/// \{
+/// \brief This part of the code manages the unitary testing.
+///
+/// Many tests are performed and new kind of unitary testing
+/// appears. In fact, we must simulate the previous steps of the line
+/// currently testing and so making some fake steps. Bad and deep
+/// hacking in data structure are required. We test the instantiation
+/// of the kmean object, its initialization (points and centers), its
+/// core routines (update_center, update_group, update_distance,
+/// update_variance) and the final loop.
+
+void test_instantiation()
+{
+ mln::clustering::k_mean<SIZE_SAMPLE2,NB_CENTER, DIM_POINT, TYPE_POINT> kmean;
+
+ // test the compilation
+
+ std::cout << "test instantiation : ok" << std::endl;
+}
+
+
void test_init_point()
{
typedef mln::value::rgb8 rgb8;
@@ -147,45 +352,12 @@ void test_init_point()
fill_image_with_4colors(img_ref);
kmean.init_point(img_ref);
-
+
mln_assertion(true == is_equivalent(img_ref, kmean.get_point()));
std::cout << "Test init point : ok" << std::endl;
}
-void set_point(MAT_POINT2& point,
- const unsigned index,
- const mln::value::rgb8& color)
-{
- point(index,0) = color.red();
- point(index,1) = color.green();
- point(index,2) = color.blue();
-}
-
-void fake_init_point(MAT_POINT2& point,
- const mln::value::rgb8& point1,
- const mln::value::rgb8& point2,
- const mln::value::rgb8& point3,
- const mln::value::rgb8& point4)
-{
- set_point(point, 0, point1);
- set_point(point, 1, point2);
- set_point(point, 2, point3);
- set_point(point, 3, point4);
-}
-
-bool is_equal(const mln::value::rgb8& ref,
- const MAT_CENTER& center,
- const unsigned i)
-{
- bool result = true;
-
- result = result && (center(i, 0) - ref.red() < 1.0);
- result = result && (center(i, 1) - ref.green() < 1.0);
- result = result && (center(i, 2) - ref.blue() < 1.0);
-
- return result;
-}
void test_init_center()
{
@@ -195,10 +367,10 @@ void test_init_center()
const mln::value::rgb8 brown = mln::literal::brown;
const mln::value::rgb8 teal = mln::literal::teal;
const mln::value::rgb8 purple = mln::literal::purple;
-
+
fake_init_point(kmean.get_point(), lime, brown, teal, purple);
kmean.init_center();
-
+
mln_assertion(is_equal(lime, kmean.get_center(), 0) ||
is_equal(brown, kmean.get_center(), 0) ||
is_equal(teal, kmean.get_center(), 0) ||
@@ -212,34 +384,6 @@ void test_init_center()
std::cout << "Test init center : ok" << std::endl;
}
-void set_center(MAT_CENTER& center,
- const unsigned index,
- const mln::value::rgb8& color)
-{
- center(index,0) = color.red();
- center(index,1) = color.green();
- center(index,2) = color.blue();
-}
-
-void fake_init_center(MAT_CENTER& center,
- const mln::value::rgb8 center1,
- const mln::value::rgb8 center2)
-{
-
- set_center(center, 0, center1);
- set_center(center, 1, center2);
-}
-
-
-double dist(mln::value::rgb8 color1, mln::value::rgb8 color2)
-{
- double red = color1.red() - color2.red();
- double green = color1.green() - color2.green();
- double blue = color1.blue() - color2.blue();
- double result= red * red + green * green + blue * blue;
-
- return result;
-}
void test_update_distance()
{
@@ -269,34 +413,6 @@ void test_update_distance()
std::cout << "Test update distance : ok" << std::endl;
}
-void set_distance(MAT_DISTANCE2& distance,
- const unsigned index,
- const double d1,
- const double d2)
-{
- distance(index,0) = d1;
- distance(index,1) = d2;
-}
-
-void fake_update_distance(MAT_DISTANCE2& distance,
- const mln::value::rgb8& point1,
- const mln::value::rgb8& point2,
- const mln::value::rgb8& point3,
- const mln::value::rgb8& point4,
- const mln::value::rgb8& center1,
- const mln::value::rgb8& center2)
-{
- set_distance(distance, 0, dist(point1, center1), dist(point1, center2));
- set_distance(distance, 1, dist(point2, center1), dist(point2, center2));
- set_distance(distance, 2, dist(point3, center1), dist(point3, center2));
- set_distance(distance, 3, dist(point4, center1), dist(point4, center2));
-
- /*
- for (int i = 0; i < SIZE_SAMPLE2; ++i)
- for (int j = 0; j < NB_CENTER; ++j)
- std::cout << "d(" << i << "," << j
<< ") = " << distance(i,j) <<std::endl;
- */
-}
void test_update_group()
{
@@ -331,26 +447,6 @@ void test_update_group()
std::cout << "Test update group : ok" << std::endl;
}
-void set_group(MAT_GROUP2& group,
- const unsigned index,
- const unsigned min)
-{
- group(index, min) = 1.0;
- group(index, 1-min) = 0.0;
-}
-
-
-void fake_update_group(MAT_GROUP2& group,
- const unsigned& point1_min,
- const unsigned& point2_min,
- const unsigned& point3_min,
- const unsigned& point4_min)
-{
- set_group(group, 0, point1_min);
- set_group(group, 1, point2_min);
- set_group(group, 2, point3_min);
- set_group(group, 3, point4_min);
-}
void test_update_center()
{
@@ -374,13 +470,14 @@ void test_update_center()
fake_update_distance(kmean.get_distance(), lime, brown, teal, purple, c1, c2);
fake_update_group(kmean.get_group(), pt1_min, pt2_min, pt3_min, pt4_min);
kmean.update_center();
-
+
mln_assertion(is_equal(mean_c1, kmean.get_center(), 0));
mln_assertion(is_equal(mean_c2, kmean.get_center(), 1));
std::cout << "Test update center : ok" << std::endl;
}
+
void test_update_variance()
{
mln::clustering::k_mean<SIZE_SAMPLE2, NB_CENTER, DIM_POINT, TYPE_POINT> kmean;
@@ -405,13 +502,15 @@ void test_update_variance()
fake_update_distance(kmean.get_distance(), lime, brown, teal, purple, c1, c2);
fake_update_group(kmean.get_group(), pt1_min, pt2_min, pt3_min, pt4_min);
kmean.update_variance();
-
+
mln_assertion(v1 == var[0]);
mln_assertion(v2 == var[1]);
std::cout << "Test update variance : ok" << std::endl;
}
+
+/// \fixme this procedure tests actually nothing.
void test_loop()
{
typedef mln::value::rgb8 rgb8;
@@ -426,24 +525,22 @@ void test_loop()
kmean.init_point(img_ref);
kmean.loop(img_ref);
-
- // std::cout << "Test update variance: ok" << std::endl;
+ // \FIXME: Which assertion must we define ?
+ // std::cout << "Test loop : ok" << std::endl;
}
+/// \}
int main()
{
- //test_instantiation();
- //test_init_point();
- //test_init_center();
- //test_update_distance();
- //test_update_group();
- //test_update_center();
- //test_update_variance();
-
- // mln::trace::quiet = false;
-
+ test_instantiation();
+ test_init_point();
+ test_init_center();
+ test_update_distance();
+ test_update_group();
+ test_update_center();
+ test_update_variance();
test_loop();
return 0;
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
b/scribo/sandbox/green/use/clustering/k_mean/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
copy to scribo/sandbox/green/use/clustering/k_mean/Makefile.am
diff --git a/scribo/sandbox/green/use/clustering/k_mean/k_mean.cc
b/scribo/sandbox/green/use/clustering/k_mean/k_mean.cc
new file mode 100644
index 0000000..9b00037
--- /dev/null
+++ b/scribo/sandbox/green/use/clustering/k_mean/k_mean.cc
@@ -0,0 +1,55 @@
+// 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 Minimal code to use the first implementation of the kmean algorithm.
+///
+
+#include <mln/clustering/k_mean.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/img_path.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/trait/value_.hh>
+#include <mln/value/rgb8.hh>
+
+#define NB_CENTER 9
+#define NB_POINT (128*128)
+#define POINT_SIZE mln_dim(mln::value::rgb8)
+#define POINT_TYPE double
+
+int main()
+{
+ typedef mln::value::rgb8 t_rgb8;
+ mln::image2d<t_rgb8> img_rgb8;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+ mln::clustering::k_mean<NB_POINT, NB_CENTER, POINT_SIZE, POINT_TYPE> kmean;
+
+ kmean.init_point(img_rgb8);
+ kmean.loop(img_rgb8);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
b/scribo/sandbox/green/use/clustering/kmean1d/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
copy to scribo/sandbox/green/use/clustering/kmean1d/Makefile.am
diff --git a/scribo/sandbox/green/use/clustering/kmean1d/kmean1d.cc
b/scribo/sandbox/green/use/clustering/kmean1d/kmean1d.cc
new file mode 100644
index 0000000..82b13c9
--- /dev/null
+++ b/scribo/sandbox/green/use/clustering/kmean1d/kmean1d.cc
@@ -0,0 +1,50 @@
+// 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 Minimal code to use the second implementation of the kmean algorithm.
+///
+
+#include <iostream>
+#include <mln/clustering/kmean1d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/img_path.hh>
+#include <mln/io/pgm/load.hh>
+#include <mln/value/int_u8.hh>
+
+int main()
+{
+ typedef mln::value::int_u8 t_int_u8;
+ typedef mln::image2d<t_int_u8> t_image2d_int_u8;
+ t_image2d_int_u8 img_int_u8;
+
+ mln::io::pgm::load(img_int_u8, OLENA_IMG_PATH"/house.pgm");
+ mln::clustering::kmean1d<double, 8> kmean(img_int_u8, 3);
+
+ kmean.launch_n_times();
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
b/scribo/sandbox/green/use/clustering/kmean2d/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
copy to scribo/sandbox/green/use/clustering/kmean2d/Makefile.am
diff --git a/scribo/sandbox/green/use/clustering/kmean2d/kmean2d.cc
b/scribo/sandbox/green/use/clustering/kmean2d/kmean2d.cc
new file mode 100644
index 0000000..d6bf05b
--- /dev/null
+++ b/scribo/sandbox/green/use/clustering/kmean2d/kmean2d.cc
@@ -0,0 +1,61 @@
+// 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 Minimal code to use the optimized version of the kmean2d algorithm.
+///
+
+#include <iostream>
+#include <mln/clustering/kmean2d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/data/transform.hh>
+#include <mln/fun/v2v/rgb_to_rg.hh>
+#include <mln/img_path.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/value/rg.hh>
+#include <mln/value/rgb8.hh>
+
+int main()
+{
+ typedef mln::value::rg<8> t_rg8;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rg8> t_image2d_rg8;
+ typedef mln::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rg8 img_rg8;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+
+ img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+
+ mln::clustering::kmean2d<double, 8> kmean(img_rg8, 3);
+
+ kmean.launch_n_times();
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
b/scribo/sandbox/green/use/clustering/kmean3d/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
copy to scribo/sandbox/green/use/clustering/kmean3d/Makefile.am
diff --git a/scribo/sandbox/green/use/clustering/kmean3d/kmean3d.cc
b/scribo/sandbox/green/use/clustering/kmean3d/kmean3d.cc
new file mode 100644
index 0000000..c57d48a
--- /dev/null
+++ b/scribo/sandbox/green/use/clustering/kmean3d/kmean3d.cc
@@ -0,0 +1,63 @@
+// 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 Minimal code to use the optimized version of the kmean3d algorithm.
+///
+
+#include <iostream>
+#include <mln/clustering/kmean3d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/data/transform.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>
+
+
+int main()
+{
+ typedef mln::clustering::kmean3d<double,5> t_kmean;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::value::rgb<5> t_rgb5;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rgb5> t_image2d_rgb5;
+ typedef mln::fun::v2v::rgb8_to_rgbn<5> t_rgb8_to_rgb5;
+
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rgb5 img_rgb5;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+
+ img_rgb5=mln::data::transform(img_rgb8, t_rgb8_to_rgb5());
+
+ t_kmean kmean(img_rgb5, 3);
+
+ kmean.launch_n_times();
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
b/scribo/sandbox/green/use/clustering/kmean_rgb/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
copy to scribo/sandbox/green/use/clustering/kmean_rgb/Makefile.am
diff --git a/scribo/sandbox/green/use/clustering/kmean_rgb/kmean_rgb.cc
b/scribo/sandbox/green/use/clustering/kmean_rgb/kmean_rgb.cc
new file mode 100644
index 0000000..3bf2241
--- /dev/null
+++ b/scribo/sandbox/green/use/clustering/kmean_rgb/kmean_rgb.cc
@@ -0,0 +1,63 @@
+// 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 Minimal code to use the the functional (versus object) kmean code.
+///
+
+#include <iostream>
+#include <mln/clustering/kmean_rgb.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/data/transform.hh>
+#include <mln/fun/v2v/rgb8_to_rgbn.hh>
+#include <mln/img_path.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/value/label_8.hh>
+#include <mln/value/rgb.hh>
+#include <mln/value/rgb8.hh>
+
+
+int main()
+{
+ typedef mln::value::label_8 t_lbl8;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::value::rgb<5> t_rgb5;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rgb5> t_image2d_rgb5;
+ typedef mln::image2d<t_lbl8> t_image2d_lbl8;
+ typedef mln::fun::v2v::rgb8_to_rgbn<5> t_rgb8_to_rgb5;
+
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rgb5 img_rgb5;
+ t_image2d_lbl8 img_lbl8;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+
+ img_rgb5 = mln::data::transform(img_rgb8, t_rgb8_to_rgb5());
+ img_lbl8 = mln::clustering::kmean_rgb<double,5>(img_rgb5, 3, 10, 10);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
b/scribo/sandbox/green/use/fun/v2v/rg_to_rgb/Makefile.am
similarity index 100%
copy from scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
copy to scribo/sandbox/green/use/fun/v2v/rg_to_rgb/Makefile.am
diff --git a/scribo/sandbox/green/use/fun/v2v/rg_to_rgb/rg_to_rgb.cc
b/scribo/sandbox/green/use/fun/v2v/rg_to_rgb/rg_to_rgb.cc
new file mode 100644
index 0000000..84ae33f
--- /dev/null
+++ b/scribo/sandbox/green/use/fun/v2v/rg_to_rgb/rg_to_rgb.cc
@@ -0,0 +1,68 @@
+// 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 Example of using rg_t_rgb transformation used with kmean2d.
+///
+
+#include <iostream>
+#include <mln/clustering/kmean2d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/data/transform.hh>
+#include <mln/fun/v2v/rgb_to_rg.hh>
+#include <mln/fun/v2v/rg_to_rgb.hh>
+#include <mln/img_path.hh>
+#include <mln/io/ppm/load.hh>
+#include <mln/value/rg.hh>
+#include <mln/value/rgb8.hh>
+
+int main()
+{
+ typedef mln::value::rg<8> t_rg8;
+ typedef mln::value::rgb8 t_rgb8;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<t_rg8> t_image2d_rg8;
+ typedef mln::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+ typedef mln::fun::v2v::rg_to_rgb<8> t_rg_to_rgb;
+
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rgb8 point_img_rgb8;
+ t_image2d_rg8 img_rg8;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/house.ppm");
+
+ img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+
+ mln::clustering::kmean2d<double, 8> kmean(img_rg8, 3);
+
+ kmean.launch_n_times();
+
+ mln::clustering::kmean2d<double,8>::t_point_img point_img = kmean.get_point();
+
+ point_img_rgb8 = mln::data::transform(point_img, t_rg_to_rgb());
+
+ return 0;
+}
--
1.5.6.5