last-svn-commit-179-g7bfa2cb Improve topo::skeleton::breadth_first_thinning.
by Roland Levillain
* mln/topo/skeleton/breadth_first_thinning.hh
(mln::topo::skeleton::breadth_first_thinning):
Fix a bias in the algorithm due to a buggy predicate.
Introduce a temporary psite to help the compiler.
Fix the type of `output'.
---
milena/ChangeLog | 10 ++++++++++
milena/mln/topo/skeleton/breadth_first_thinning.hh | 20 ++++++++++++++------
2 files changed, 24 insertions(+), 6 deletions(-)
diff --git a/milena/ChangeLog b/milena/ChangeLog
index 214b7e6..f1c1386 100644
--- a/milena/ChangeLog
+++ b/milena/ChangeLog
@@ -1,3 +1,13 @@
+2010-05-04 Roland Levillain <roland(a)lrde.epita.fr>
+
+ Improve topo::skeleton::breadth_first_thinning.
+
+ * mln/topo/skeleton/breadth_first_thinning.hh
+ (mln::topo::skeleton::breadth_first_thinning):
+ Fix a bias in the algorithm due to a buggy predicate.
+ Introduce a temporary psite to help the compiler.
+ Fix the type of `output'.
+
2010-04-26 Roland Levillain <roland(a)lrde.epita.fr>
Clean Milena's tests' outputs during `make mostlyclean'.
diff --git a/milena/mln/topo/skeleton/breadth_first_thinning.hh b/milena/mln/topo/skeleton/breadth_first_thinning.hh
index 42e1bef..8039ffb 100644
--- a/milena/mln/topo/skeleton/breadth_first_thinning.hh
+++ b/milena/mln/topo/skeleton/breadth_first_thinning.hh
@@ -1,4 +1,4 @@
-// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE)
+// Copyright (C) 2009, 2010 EPITA Research and Development Laboratory (LRDE)
//
// This file is part of Olena.
//
@@ -90,7 +90,7 @@ namespace mln
F& is_simple = exact(is_simple_);
const H& constraint = exact(constraint_);
- I output = duplicate(input);
+ mln_concrete(I) output = duplicate(input);
// Attach the work image to IS_SIMPLE.
is_simple.set_image(output);
@@ -133,15 +133,23 @@ namespace mln
/* FIXME: We compute the cell and attachment of P twice:
during the call to is_simple() and within detach().
How could we reuse this elegantly, without breaking
- the genericity of the skeleton algorithm? */
+ the genericity of the skeleton algorithm?
+ Also, keep in mind that functors can maintain an
+ internal state and make side effects, meaning that
+ e.g. constraint(p) might not be constant for a
+ given p during the thinning. */
if (constraint(p) && is_simple(p))
{
detach(p, output);
- mln_niter(N) n(nbh, p);
- for_all(n)
+ mln_niter(N) n_(nbh, p);
+ for_all(n_)
+ {
+ // Same remark as above regarding P and P_.
+ psite n = n_;
if (output.domain().has(n)
- && output(n) && constraint(p) && is_simple(n))
+ && output(n) && constraint(n) && is_simple(n))
next_set.insert(n);
+ }
}
}
set.clear();
--
1.5.6.5
14 years, 6 months
- 1
- 0
branch mesh-segm-skel updated: last-svn-commit-188-gf36081f
by git＠lrde.epita.fr
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Olena, a generic and efficient image processing platform".
The branch mesh-segm-skel has been updated
discards 300322ef688a1f38cd1e5918774f21b93b912e6e (commit)
discards c9b58ad8fbaa27a3eeeb4ab4167114ccdfe762ec (commit)
discards e4978ab662c8a70fdee99977032300c142235ccb (commit)
discards 47481b45cfb4e5c687596a52c3cb334e79f163d5 (commit)
discards 2da010175cca88a13c231da1007b98e16fca75c1 (commit)
discards 3cdb8bbd851688b0678ceeb5746cfe1d8353262b (commit)
discards 7c9b5a325426ee398304c873db49fc015e86d516 (commit)
discards 679f73c895982eee5b77c2ce1492474ac5957ff7 (commit)
discards 40ba1ad80da1ed71f7bccd589ff8aa4d82149d6e (commit)
discards 9a842d1a96866d1d54442fc9f582f8551e5e1a2b (commit)
via f36081f28428672f81cbb700a0a52da51b10d7ff (commit)
via 3f6e1c50761b9ca2c8c8f5403c9236c45d04e969 (commit)
via b5e8235b7e417cd015a4978999d1d51540645b7e (commit)
via f1c3f6a489dfa9606ce6fa0d13020ea314acd1e7 (commit)
via ead83a9b2e0b7269825675cb0a769c119d92ff16 (commit)
via 45fcb1970125f5bba8b68ecff943188234caf1ca (commit)
via 56c4e2c3c79bec09c11003e222f480443c1288c5 (commit)
via b359f8b1bcc79c8f7d1e4f6e22d49d09b82fd983 (commit)
via 0d9aa9caa5fe3bb69389b3d67bb53381f8b807f5 (commit)
via 7bfa2cb0923ff4103685c7c76feaf44fe8165b06 (commit)
via 71c9c144f233770f1b9652ba98d6137053e8ab47 (commit)
via 0d502d0cf9f3571471768db4f3833b0701ef39a0 (commit)
via ba369b62ba9d59fb093d4247284f2c437f42754e (commit)
via 165770feeac77f1dfab40f3173c3e6e483709df1 (commit)
This update added new revisions after undoing existing revisions. That is
to say, the old revision is not a strict subset of the new revision. This
situation occurs when you --force push a change and generate a repository
containing something like this:
* -- * -- B -- O -- O -- O (300322ef688a1f38cd1e5918774f21b93b912e6e)
\
N -- N -- N (f36081f28428672f81cbb700a0a52da51b10d7ff)
When this happens we assume that you've already had alert emails for all
of the O revisions, and so we here report only the revisions in the N
branch from the common base, B.
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
f36081f Actually use the maximal curvature in mesh-complex-max-curv-segm.
3f6e1c5 Improve the precision of some mesh-segm-skel apps.
b5e8235 Configure milena/apps/mesh-segm-skel/test-mesh-complex-max-curv-skel.
f1c3f6a New application: mesh-complex-max-curv-skel.
ead83a9 Clean up and new FIXMES in in apps/mesh-segm-skel.
45fcb19 Configure milena/apps/mesh-segm-skel/test-mesh-complex-max-curv-extrema.
56c4e2c New application: mesh-complex-max-curv-extrema.
b359f8b Revive, fix and update application mesh-segm.
0d9aa9c Fix a bug in the reimplementation of Trimesh algorithms.
7bfa2cb Improve topo::skeleton::breadth_first_thinning.
71c9c14 Add `mesh-segm-skel' to the branches to be uploaded (as snapshot).
-----------------------------------------------------------------------
Summary of changes:
ChangeLog | 6 +
lrde-upload.sh | 2 +-
milena/ChangeLog | 105 +++++++++++++++++++-
milena/apps/mesh-segm-skel/Makefile.am | 14 ++--
milena/apps/papers/levillain.09.ismm/Makefile.am | 2 +-
milena/tests/binarization/Makefile.am | 12 +--
milena/tests/binarization/threshold.cc | 7 +-
milena/tests/data/Makefile.am | 13 +--
milena/tests/data/approx/Makefile.am | 9 +-
milena/tests/data/approx/median.cc | 7 +-
milena/tests/data/median.cc | 7 +-
milena/tests/data/median_fast.cc | 5 +-
milena/tests/data/naive/Makefile.am | 6 +-
milena/tests/data/naive/median.cc | 5 +-
milena/tests/io/dump/Makefile.am | 12 ++-
milena/tests/io/dump/dump.cc | 24 +++--
milena/tests/io/fits/Makefile.am | 13 +--
milena/tests/io/fits/fits.cc | 11 +-
milena/tests/io/magick/Makefile.am | 12 +--
milena/tests/io/magick/save.cc | 9 +-
milena/tests/io/off/Makefile.am | 10 +--
milena/tests/io/off/load_save_bin.cc | 5 +-
milena/tests/io/pbm/Makefile.am | 14 ++--
milena/tests/io/pbm/pbm.cc | 7 +-
milena/tests/io/pbm/pbm_ascii.cc | 6 +-
milena/tests/io/pbms/Makefile.am | 6 +-
milena/tests/io/pbms/load.cc | 6 +-
milena/tests/io/pgm/Makefile.am | 33 ++++---
milena/tests/io/pgm/pgm.cc | 11 +-
milena/tests/io/pgm/pgm16.cc | 13 ++-
milena/tests/io/pgm/pgm19.cc | 9 +-
milena/tests/io/pgm/pgm27.cc | 9 +-
milena/tests/io/pgm/pgm_ascii.cc | 10 +-
milena/tests/io/pgms/Makefile.am | 7 +-
milena/tests/io/pgms/load.cc | 6 +-
milena/tests/io/ppm/Makefile.am | 24 ++---
milena/tests/io/ppm/ppm.cc | 7 +-
milena/tests/io/ppm/ppm16.cc | 11 +-
milena/tests/io/ppm/ppm23.cc | 11 +-
milena/tests/io/ppms/Makefile.am | 7 +-
milena/tests/io/ppms/load.cc | 8 +-
milena/tests/linear/Makefile.am | 13 ++-
milena/tests/linear/convolve.cc | 5 +-
milena/tests/linear/convolve_2x1d.cc | 5 +-
milena/tests/linear/convolve_directional.cc | 5 +-
milena/tests/linear/gaussian.cc | 5 +-
milena/tests/linear/gaussian/Makefile.am | 4 +-
milena/tests/linear/gaussian/filter.cc | 5 +-
milena/tests/linear/lap.cc | 5 +-
milena/tests/linear/log.cc | 5 +-
milena/tests/linear/sobel_2d.cc | 5 +-
milena/tests/morpho/Makefile.am | 32 ++++---
milena/tests/morpho/approx/Makefile.am | 13 +--
milena/tests/morpho/approx/dilation.cc | 6 +-
milena/tests/morpho/approx/erosion.cc | 6 +-
.../morpho/artificial_line_graph_image_wst.cc | 5 +-
milena/tests/morpho/closing/Makefile.am | 38 ++++----
milena/tests/morpho/closing/algebraic.cc | 6 +-
milena/tests/morpho/closing/approx/Makefile.am | 11 +--
milena/tests/morpho/closing/approx/structural.cc | 6 +-
milena/tests/morpho/closing/height.cc | 5 +-
milena/tests/morpho/closing/leveling.cc | 6 +-
milena/tests/morpho/closing/structural.cc | 4 +-
milena/tests/morpho/closing/sum.cc | 5 +-
milena/tests/morpho/closing/volume.cc | 7 +-
milena/tests/morpho/complex_image_wst.cc | 5 +-
milena/tests/morpho/contrast.cc | 5 +-
milena/tests/morpho/dilation.cc | 13 ++-
milena/tests/morpho/general.cc | 5 +-
milena/tests/morpho/gradient.cc | 7 +-
milena/tests/morpho/hit_or_miss.cc | 10 +--
milena/tests/morpho/laplacian.cc | 7 +-
milena/tests/morpho/lena_line_graph_image_wst1.cc | 5 +-
milena/tests/morpho/lena_line_graph_image_wst2.cc | 5 +-
milena/tests/morpho/meyer_wst.cc | 5 +-
milena/tests/morpho/meyer_wst_long.cc | 6 +-
milena/tests/morpho/opening/Makefile.am | 37 ++++---
milena/tests/morpho/opening/algebraic.cc | 6 +-
milena/tests/morpho/opening/approx/Makefile.am | 6 +-
milena/tests/morpho/opening/approx/structural.cc | 6 +-
milena/tests/morpho/opening/area.cc | 5 +-
milena/tests/morpho/opening/height.cc | 5 +-
milena/tests/morpho/opening/leveling.cc | 6 +-
milena/tests/morpho/opening/structural.cc | 4 +-
milena/tests/morpho/opening/sum.cc | 5 +-
milena/tests/morpho/opening/volume.cc | 5 +-
milena/tests/morpho/thinning.cc | 7 +-
milena/tests/morpho/watershed/Makefile.am | 13 +--
milena/tests/morpho/watershed/flooding.cc | 13 ++-
milena/tests/morpho/watershed/topological.cc | 5 +-
swilena/ChangeLog | 12 +++
swilena/python/Makefile.am | 26 +++---
swilena/python/morpho-fun.py | 23 +++--
swilena/python/morpho-segm.py | 7 +-
94 files changed, 567 insertions(+), 405 deletions(-)
hooks/post-receive
--
Olena, a generic and efficient image processing platform
14 years, 6 months
- 1
- 0
last-svn-commit-178-g71c9c14 Add `mesh-segm-skel' to the branches to be uploaded (as snapshot).
by Roland Levillain
* lrde-upload.sh: Here.
---
ChangeLog | 6 ++++++
lrde-upload.sh | 2 +-
2 files changed, 7 insertions(+), 1 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 57df1c6..44386d3 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2010-06-24 Roland Levillain <roland(a)lrde.epita.fr>
+
+ Add `mesh-segm-skel' to the branches to be uploaded (as snapshot).
+
+ * lrde-upload.sh: Here.
+
2010-04-23 Roland Levillain <roland(a)lrde.epita.fr>
Add variables for C++ compiler flags for Scribo.
diff --git a/lrde-upload.sh b/lrde-upload.sh
index 5f61ef2..3ed1aa6 100755
--- a/lrde-upload.sh
+++ b/lrde-upload.sh
@@ -45,7 +45,7 @@ branch=$1
case "$branch" in
# Consider these branches only.
- master|next|swilena) ;;
+ master|next|swilena|mesh-segm-skel) ;;
# Don't upload other branches.
*) exit ;;
esac
--
1.5.6.5
14 years, 6 months
- 1
- 0
branch exp/green updated: last-svn-commit-46-gcfc3ef7
by git＠lrde.epita.fr
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Olena, a generic and efficient image processing platform".
The branch exp/green has been updated
discards b6f36911eb58513cfceafe871dc5a3cdfd1791bc (commit)
discards 2fa459f44c6c7c938c48f4dd53a3210e885be1ac (commit)
discards d26549180bf35357fa14783fb99d60108896009f (commit)
discards 6e896e2214587d64f2d54a877c41b7cb1451c612 (commit)
discards de3450dd6da34b7380382928582f8e8dd6f8f0d6 (commit)
discards 9895c32ead3335ff6037eee9c900bc910cb4d74f (commit)
via cfc3ef76083def2e08adf726a633919cfd86bd9d (commit)
via d2a2a435da3435562e098fb267ecbeae19059b90 (commit)
via d602c29a1ebc23c841c0748226af2da193d9dd5e (commit)
via 0da8c6375445d82cadb5a4880af9bc8c6770a09a (commit)
via 0bf1f8f03ef32c05fe402e6559eacbfe1c8f068a (commit)
This update added new revisions after undoing existing revisions. That is
to say, the old revision is not a strict subset of the new revision. This
situation occurs when you --force push a change and generate a repository
containing something like this:
* -- * -- B -- O -- O -- O (b6f36911eb58513cfceafe871dc5a3cdfd1791bc)
\
N -- N -- N (cfc3ef76083def2e08adf726a633919cfd86bd9d)
When this happens we assume that you've already had alert emails for all
of the O revisions, and so we here report only the revisions in the N
branch from the common base, B.
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
cfc3ef7 Define documentation files.
d2a2a43 Define gnuplot shell export format.
d602c29 Import files from milena/sandbox/green.
0da8c63 Define accumulator which computes histogram view as image.
0bf1f8f Import files from milena/sandbox/green.
-----------------------------------------------------------------------
Summary of changes:
scribo/sandbox/green/ChangeLog | 51 ++
.../sandbox/green/ok/mln/accu/histo}/histo1d.hh | 100 ++--
.../sandbox/green/ok/mln/accu/histo}/histo2d.hh | 0
.../sandbox/green/ok/mln/accu/histo/histo3d.hh | 0
.../sandbox/green/ok}/mln/img_path.hh | 0
.../sandbox/green/ok/test/accu/histo}/gaussian.sh | 0
scribo/sandbox/green/ok/test/accu/histo/histo1d | Bin 0 -> 802920 bytes
scribo/sandbox/green/ok/test/accu/histo/histo1d.cc | 726 ++++++++++++++++++++
8 files changed, 820 insertions(+), 57 deletions(-)
copy {milena/sandbox/green/mln/accu/stat => scribo/sandbox/green/ok/mln/accu/histo}/histo1d.hh (74%)
copy {milena/sandbox/green/mln/accu/stat => scribo/sandbox/green/ok/mln/accu/histo}/histo2d.hh (100%)
copy milena/sandbox/green/mln/accu/stat/histo3d_rgb.hh => scribo/sandbox/green/ok/mln/accu/histo/histo3d.hh (100%)
copy {milena/sandbox/green => scribo/sandbox/green/ok}/mln/img_path.hh (100%)
copy {milena/sandbox/green/tests/accu/stat/histo1d => scribo/sandbox/green/ok/test/accu/histo}/gaussian.sh (100%)
create mode 100755 scribo/sandbox/green/ok/test/accu/histo/histo1d
create mode 100644 scribo/sandbox/green/ok/test/accu/histo/histo1d.cc
hooks/post-receive
--
Olena, a generic and efficient image processing platform
14 years, 6 months
- 1
- 0
branch exp/scribo-z updated: last-svn-commit-164-g91b2059
by git＠lrde.epita.fr
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Olena, a generic and efficient image processing platform".
The branch exp/scribo-z has been updated
via 91b205927506a09d3c921c4980da3b114617775d (commit)
from 966f8d64839b0d13bdc608ef7f4c4247e984391a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
91b2059 Delete files
-----------------------------------------------------------------------
Summary of changes:
scribo/sandbox/green/ko/mln/accu/stat/histo1d.hh | 348 ----------
scribo/sandbox/green/ko/mln/accu/stat/histo2d.hh | 346 ----------
.../sandbox/green/ko/mln/accu/stat/histo3d_hsl.hh | 380 ----------
.../sandbox/green/ko/mln/accu/stat/histo3d_rgb.hh | 349 ----------
scribo/sandbox/green/ok/mln/accu/histo/histo1d.hh | 334 ---------
scribo/sandbox/green/ok/mln/accu/histo/histo2d.hh | 346 ----------
scribo/sandbox/green/ok/mln/accu/histo/histo3d.hh | 349 ----------
scribo/sandbox/green/ok/mln/img_path.hh | 239 -------
.../sandbox/green/ok/test/accu/histo/gaussian.sh | 12 -
scribo/sandbox/green/ok/test/accu/histo/histo1d | Bin 808312 -> 0 bytes
scribo/sandbox/green/ok/test/accu/histo/histo1d.cc | 726 --------------------
11 files changed, 0 insertions(+), 3429 deletions(-)
delete mode 100644 scribo/sandbox/green/ko/mln/accu/stat/histo1d.hh
delete mode 100644 scribo/sandbox/green/ko/mln/accu/stat/histo2d.hh
delete mode 100644 scribo/sandbox/green/ko/mln/accu/stat/histo3d_hsl.hh
delete mode 100644 scribo/sandbox/green/ko/mln/accu/stat/histo3d_rgb.hh
delete mode 100644 scribo/sandbox/green/ok/mln/accu/histo/histo1d.hh
delete mode 100644 scribo/sandbox/green/ok/mln/accu/histo/histo2d.hh
delete mode 100644 scribo/sandbox/green/ok/mln/accu/histo/histo3d.hh
delete mode 100644 scribo/sandbox/green/ok/mln/img_path.hh
delete mode 100755 scribo/sandbox/green/ok/test/accu/histo/gaussian.sh
delete mode 100755 scribo/sandbox/green/ok/test/accu/histo/histo1d
delete mode 100644 scribo/sandbox/green/ok/test/accu/histo/histo1d.cc
hooks/post-receive
--
Olena, a generic and efficient image processing platform
14 years, 6 months
- 1
- 0
last-svn-commit-167-gb3416b2 Import files from milena/sandbox/green.
by Yann Jacquelet
* gaussian.sh: New gnuplot shell file.
* guassian2d.sh: New gnuplot shell file.
* test_labelling.cc: New source.
* tests/clustering/k_mean/Makefile.am: New makefile.
* tests/clustering/k_mean/k_mean.cc: New source.
* tests/clustering/kmean1d/Makefile.am: New makefile.
* tests/clustering/kmean1d/kmean1d.cc: New source.
* tests/io/plot/save_image_sh/Makefile.am: New makefile.
* tests/io/plot/save_image_sh/save_image_sh.cc: New source.
---
scribo/sandbox/green/ChangeLog | 14 +
.../histo1d => scribo/sandbox/green}/gaussian.sh | 0
.../histo2d => scribo/sandbox/green}/gaussian2d.sh | 0
scribo/sandbox/green/test_labelling.cc | 336 ++++++++++++++++++++
.../green/tests/clustering/k_mean/Makefile.am | 0
.../green/tests/clustering/k_mean/k_mean.cc | 0
.../green/tests/clustering/kmean1d/Makefile.am | 0
.../green/tests/clustering/kmean1d/kmean1d.cc | 0
.../green/tests/io/plot/save_image_sh}/Makefile.am | 0
.../tests/io/plot/save_image_sh/save_image_sh.cc | 0
10 files changed, 350 insertions(+), 0 deletions(-)
copy {milena/sandbox/green/tests/accu/stat/histo1d => scribo/sandbox/green}/gaussian.sh (100%)
copy {milena/sandbox/green/tests/accu/stat/histo2d => scribo/sandbox/green}/gaussian2d.sh (100%)
create mode 100644 scribo/sandbox/green/test_labelling.cc
copy {milena => scribo}/sandbox/green/tests/clustering/k_mean/Makefile.am (100%)
copy {milena => scribo}/sandbox/green/tests/clustering/k_mean/k_mean.cc (100%)
copy {milena => scribo}/sandbox/green/tests/clustering/kmean1d/Makefile.am (100%)
copy {milena => scribo}/sandbox/green/tests/clustering/kmean1d/kmean1d.cc (100%)
copy {milena/sandbox/green/doc/examples/frac => scribo/sandbox/green/tests/io/plot/save_image_sh}/Makefile.am (100%)
copy {milena => scribo}/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc (100%)
diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index 8f5101b..db589a1 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -2,6 +2,20 @@
Import files from milena/sandbox/green.
+ * gaussian.sh: New gnuplot shell file.
+ * guassian2d.sh: New gnuplot shell file.
+ * test_labelling.cc: New source.
+ * tests/clustering/k_mean/Makefile.am: New makefile.
+ * tests/clustering/k_mean/k_mean.cc: New source.
+ * tests/clustering/kmean1d/Makefile.am: New makefile.
+ * tests/clustering/kmean1d/kmean1d.cc: New source.
+ * tests/io/plot/save_image_sh/Makefile.am: New makefile.
+ * tests/io/plot/save_image_sh/save_image_sh.cc: New source.
+
+2010-06-24 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Import files from milena/sandbox/green.
+
* mln/accu/stat/histo1d.hh: New header file.
* mln/accu/stat/histo2d.hh: New header file.
* mln/accu/stat/histo3d_hsl.hh: New header file.
diff --git a/milena/sandbox/green/tests/accu/stat/histo1d/gaussian.sh b/scribo/sandbox/green/gaussian.sh
similarity index 100%
copy from milena/sandbox/green/tests/accu/stat/histo1d/gaussian.sh
copy to scribo/sandbox/green/gaussian.sh
diff --git a/milena/sandbox/green/tests/accu/stat/histo2d/gaussian2d.sh b/scribo/sandbox/green/gaussian2d.sh
similarity index 100%
copy from milena/sandbox/green/tests/accu/stat/histo2d/gaussian2d.sh
copy to scribo/sandbox/green/gaussian2d.sh
diff --git a/scribo/sandbox/green/test_labelling.cc b/scribo/sandbox/green/test_labelling.cc
new file mode 100644
index 0000000..6238d2b
--- /dev/null
+++ b/scribo/sandbox/green/test_labelling.cc
@@ -0,0 +1,336 @@
+// 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/io/plot/save_histo_sh.hh>
+#include <mln/value/rgb8.hh>
+#include <mln/value/label_8.hh>
+#include <mln/core/alias/neighb1d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/labeling/colorize.hh>
+#include <mln/labeling/mean_values.hh>
+#include <mln/labeling/regional_maxima.hh>
+#include <mln/make/w_window1d.hh>
+#include <mln/math/pi.hh>
+#include <mln/morpho/watershed/flooding.hh>
+#include <mln/morpho/elementary/dilation.hh>
+#include <mln/morpho/elementary/closing.hh>
+#include <mln/pw/value.hh>
+#include <mln/linear/convolve.hh>
+#include <mln/linear/gaussian.hh>
+
+
+/// ... to complete
+
+/// \brief Compute the gaussian probability to obtain a given value.
+///
+/// \param[in] x the value from which we want the probability.
+/// \param[in] mean the mean parameter of the gaussian distribution.
+/// \param[in] sigma the sqrt(variance) parameter of the gaussian.
+/// \return the probability to obtain the x value.
+///
+/// Implements the standard equation of the gaussian.
+
+double gaussian_distribution(const double x,
+ const double mean,
+ const double sigma)
+{
+ double num = exp(-0.5*mln::math::sqr((x - mean)/sigma));
+ double denom = sigma*mln::math::sqrt(2*mln::math::pi);
+ double result = num/denom;
+
+ return result;
+}
+
+/// \brief Make a 1d gaussian filter.
+///
+/// \param[out] ws the window (filter) where to put the probability values.
+/// \param[in] size the size of the filter.
+/// \param[in] sigma the gaussian parameter for the standard deviation.
+/// \return the probability to obtain the x value.
+///
+/// Approach the gaussian distribution for a few discrete sites, and
+/// then normilize the results to be sure that the sum obtain 1.
+
+void gaussian_filter(double ws[], const unsigned size, const double sigma)
+{
+ int h = size/2;
+
+ for (int i = -h; i <= h; ++i)
+ {
+ ws[i+h] = gaussian_distribution(i, 0.0, sigma);
+ }
+
+ double sum = 0.0;
+
+ for (unsigned i = 0; i < size; ++i)
+ sum += ws[i];
+
+ for (unsigned i = 0; i < size; ++i)
+ ws[i] /= sum;
+}
+
+/// \brief Make a 1d gaussian filter.
+///
+/// \param[out] ws the window (filter) where to put the probability values.
+/// \param[in] size the size of the filter.
+/// \param[in] sigma the gaussian parameter for the standard deviation.
+/// \return the probability to obtain the x value.
+///
+/// Approach the gaussian distribution for a few discrete sites, and
+/// then normilize the results to be sure that the sum obtain 1.
+
+/// The aim of this function is to rebuild an label image2d from the segmenting
+/// image of the histogram (label) and the original image (input).
+/// label_image2d / for each grey tone, associate its label.
+
+mln::image2d<mln::value::label_8>
+build_8bits(const mln::image2d<mln::value::int_u8>& input,
+ const mln::image1d<mln::value::label_8>& label)
+{
+ mln::trace::entering("build_8bits");
+ mln_precondition(label.is_valid());
+ mln_precondition(input.is_valid());
+
+ mln::image2d<mln::value::label_8> output;
+
+ mln::initialize(output, input);
+
+ mln_piter_(mln::image2d<mln::value::int_u8>) pi(input.domain());
+ mln_piter_(mln::image2d<mln::value::label_8>) po(output.domain());
+
+ for_all_2(pi, po)
+ {
+ mln::value::int_u8 val = input(pi);
+ unsigned grp = label(mln::point1d(val));
+
+ output(po) = grp;
+ }
+
+ mln::trace::exiting("build_8bits");
+ return output;
+}
+
+
+void test_8bits_classifying()
+{
+ typedef mln::value::int_u8 int_u8;
+ typedef mln::value::label_8 label_8;
+ typedef mln::value::rgb8 rgb8;
+ typedef mln::accu::stat::mean<double> mean;
+
+ mln::image2d<int_u8> img_ref;
+ mln::image2d<int_u8> img_out;
+ mln::image2d<rgb8> img_rgb;
+ mln::image1d<unsigned> img_res;
+ mln::image1d<double> img_smooth;
+ mln::image1d<label_8> labels;
+ label_8 nlabels;
+
+ //-----------------------------------------------------
+ // Loading the scribo image and computing its histogram
+ //-----------------------------------------------------
+
+ std::cout << "(08 bits) LOADING HISTOGRAM" << std::endl;
+
+ // mln::io::pgm::load(img_ref, OLENA_IMG_PATH"/lena.pgm");
+ mln::io::pgm::load(img_ref, SCRIBO_IMG_PATH"/mp00082c_50p_8bits.pgm");
+ img_res = mln::data::compute(mln::accu::stat::histo1d<int_u8>(), img_ref);
+ mln::io::plot::save_histo_sh(img_res, "histo0_8bits.sh");
+
+
+ //-----------------------------------------------------
+ // Smoothing the histogram with a gaussian filter
+ //-----------------------------------------------------
+
+ std::cout << "(08 bits) SMOOTHING HISTOGRAM" << std::endl;
+
+ double ws[41];
+ gaussian_filter(ws, 41, 6.0);
+ img_smooth = mln::linear::convolve(img_res, mln::make::w_window1d(ws));
+ mln::io::plot::save_histo_sh(img_smooth, "histo1_8bits.sh");
+
+
+ //-----------------------------------------------------
+ // Segmenting the histogram with the watershed method
+ //-----------------------------------------------------
+
+ std::cout << "SEGMENTING HISTOGRAM" << std::endl;
+
+ /*
+ labels = mln::labeling::regional_maxima(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2_8bits.sh");
+ */
+
+ // need to revert the histogram
+ labels = mln::morpho::watershed::flooding(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2_8bits.sh");
+
+
+ //-----------------------------------------------------
+ // Rebuilding the image with the mean of each region
+ //-----------------------------------------------------
+
+ std::cout << "(08 bits) BUILDING OUTPUT" << std::endl;
+
+ mln::image2d<label_8>img_label = build_8bits(img_ref, labels);
+
+ std::cout << "(08 bits) COLORING OUTPUT" << std::endl;
+
+ img_out = mln::labeling::mean_values(img_ref, img_label, nlabels);
+ img_rgb = mln::labeling::colorize(rgb8(), img_label);
+
+ mln::io::pgm::save(img_out, "out_8bits.pgm");
+ mln::io::ppm::save(img_rgb, "color_8bits.pgm");
+
+ //labels = mln::morpho::elementary::dilation(labels, mln::c2());
+ //mln::io::plot::save_histo_sh(labels, "histo3.sh");
+ //mln::io::plot::save(labels, "labelized.data");
+}
+
+
+/// The aim of this function is to rebuild an label image2d from the segmenting
+/// image of the histogram (label) and the original image (input).
+/// label_image2d / for each grey tone, associate its label.
+
+mln::image2d<mln::value::label_8>
+build_14bits(const mln::image2d<mln::value::int_u<14> >& input,
+ const mln::image1d<mln::value::label_8>& label)
+{
+ mln::trace::entering("build_14bits");
+ mln_precondition(label.is_valid());
+ mln_precondition(input.is_valid());
+
+ mln::image2d<mln::value::label_8> output;
+
+ mln::initialize(output, input);
+
+ mln_piter_(mln::image2d<mln::value::int_u<14> >) pi(input.domain());
+ mln_piter_(mln::image2d<mln::value::label_8>) po(output.domain());
+
+ for_all_2(pi, po)
+ {
+ mln::value::int_u<14> val = input(pi);
+ unsigned grp = label(mln::point1d(val));
+
+ output(po) = grp;
+ }
+
+ mln::trace::exiting("build_14bits");
+ return output;
+}
+
+
+void test_14bits_classifying()
+{
+ typedef mln::value::int_u16 int_u16;
+ typedef mln::value::int_u<14> int_u14;
+ typedef mln::value::label_8 label_8;
+ typedef mln::value::rgb8 rgb8;
+ typedef mln::accu::stat::mean<double> mean;
+
+ mln::image2d<int_u16> img_fst;
+ mln::image2d<int_u14> img_ref;
+ mln::image2d<int_u14> img_out;
+ mln::image2d<rgb8> img_rgb;
+ mln::image1d<unsigned> img_res;
+ mln::image1d<double> img_smooth;
+ mln::image1d<label_8> labels;
+ label_8 nlabels;
+
+ //-----------------------------------------------------
+ // Loading the scribo image and computing its histogram
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) LOADING HISTOGRAM" << std::endl;
+
+ //mln::io::pgm::load(img_fst, OLENA_IMG_PATH"/lena_16.pgm");
+ mln::io::pgm::load(img_fst, SCRIBO_IMG_PATH"/mp00082c_50p_16bits.pgm");
+ img_ref = mln::data::transform(img_fst, mln::fun::v2v::int_u16_to_int_u14());
+ img_res = mln::data::compute(mln::accu::stat::histo1d<int_u14>(), img_ref);
+ mln::io::plot::save_histo_sh(img_res, "histo0_14bits.sh");
+
+
+ //-----------------------------------------------------
+ // Smoothing the histogram with a gaussian filter
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) SMOOTHING HISTOGRAM" << std::endl;
+
+ double ws[401];
+ gaussian_filter(ws, 401, 50.0);
+ img_smooth = mln::linear::convolve(img_res, mln::make::w_window1d(ws));
+ mln::io::plot::save_histo_sh(img_smooth, "histo1_14bits.sh");
+
+
+ //-----------------------------------------------------
+ // Segmenting the histogram with the watershed method
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) SEGMENTING HISTOGRAM" << std::endl;
+
+ /*
+ labels = mln::labeling::regional_maxima(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2.sh");
+ */
+
+
+ labels = mln::morpho::watershed::flooding(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2_14bits.sh");
+
+
+ //-----------------------------------------------------
+ // Rebuilding the image with the mean of each region
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) BUILDING OUTPUT" << std::endl;
+
+ mln::image2d<label_8>img_label = build_14bits(img_ref, labels);
+
+ std::cout << "(14 bits) COLORING OUTPUT" << std::endl;
+
+ img_out = mln::labeling::mean_values(img_ref, img_label, nlabels);
+ img_rgb = mln::labeling::colorize(rgb8(), img_label);
+
+ mln::io::pgm::save(img_out, "out_14bits.pgm");
+ mln::io::ppm::save(img_rgb, "color_14bits.pgm");
+
+ //labels = mln::morpho::elementary::dilation(labels, mln::c2());
+ //mln::io::plot::save_histo_sh(labels, "histo3.sh");
+ //mln::io::plot::save(labels, "labelized.data");
+}
+
+int main()
+{
+ test_8bits_classifying();
+
+ test_14bits_classifying();
+
+ return 0;
+}
diff --git a/milena/sandbox/green/tests/clustering/k_mean/Makefile.am b/scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
similarity index 100%
copy from milena/sandbox/green/tests/clustering/k_mean/Makefile.am
copy to scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
diff --git a/milena/sandbox/green/tests/clustering/k_mean/k_mean.cc b/scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
similarity index 100%
copy from milena/sandbox/green/tests/clustering/k_mean/k_mean.cc
copy to scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
diff --git a/milena/sandbox/green/tests/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/tests/clustering/kmean1d/Makefile.am
similarity index 100%
copy from milena/sandbox/green/tests/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/tests/clustering/kmean1d/Makefile.am
diff --git a/milena/sandbox/green/tests/clustering/kmean1d/kmean1d.cc b/scribo/sandbox/green/tests/clustering/kmean1d/kmean1d.cc
similarity index 100%
copy from milena/sandbox/green/tests/clustering/kmean1d/kmean1d.cc
copy to scribo/sandbox/green/tests/clustering/kmean1d/kmean1d.cc
diff --git a/milena/sandbox/green/doc/examples/frac/Makefile.am b/scribo/sandbox/green/tests/io/plot/save_image_sh/Makefile.am
similarity index 100%
copy from milena/sandbox/green/doc/examples/frac/Makefile.am
copy to scribo/sandbox/green/tests/io/plot/save_image_sh/Makefile.am
diff --git a/milena/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc b/scribo/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc
similarity index 100%
copy from milena/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc
copy to scribo/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc
--
1.5.6.5
14 years, 6 months
- 1
- 0
last-svn-commit-44-gd602c29 Import files from milena/sandbox/green.
by Yann Jacquelet
* gaussian.sh: New gnuplot shell file.
* guassian2d.sh: New gnuplot shell file.
* test_labelling.cc: New source.
* tests/clustering/k_mean/Makefile.am: New makefile.
* tests/clustering/k_mean/k_mean.cc: New source.
* tests/clustering/kmean1d/Makefile.am: New makefile.
* tests/clustering/kmean1d/kmean1d.cc: New source.
* tests/io/plot/save_image_sh/Makefile.am: New makefile.
* tests/io/plot/save_image_sh/save_image_sh.cc: New source.
---
scribo/sandbox/green/ChangeLog | 14 +
.../histo1d => scribo/sandbox/green}/gaussian.sh | 0
.../histo2d => scribo/sandbox/green}/gaussian2d.sh | 0
scribo/sandbox/green/test_labelling.cc | 336 ++++++++++++++++++++
.../green/tests/clustering/k_mean/Makefile.am | 0
.../green/tests/clustering/k_mean/k_mean.cc | 0
.../green/tests/clustering/kmean1d/Makefile.am | 0
.../green/tests/clustering/kmean1d/kmean1d.cc | 0
.../green/tests/io/plot/save_image_sh}/Makefile.am | 0
.../tests/io/plot/save_image_sh/save_image_sh.cc | 0
10 files changed, 350 insertions(+), 0 deletions(-)
copy {milena/sandbox/green/tests/accu/stat/histo1d => scribo/sandbox/green}/gaussian.sh (100%)
copy {milena/sandbox/green/tests/accu/stat/histo2d => scribo/sandbox/green}/gaussian2d.sh (100%)
create mode 100644 scribo/sandbox/green/test_labelling.cc
copy {milena => scribo}/sandbox/green/tests/clustering/k_mean/Makefile.am (100%)
copy {milena => scribo}/sandbox/green/tests/clustering/k_mean/k_mean.cc (100%)
copy {milena => scribo}/sandbox/green/tests/clustering/kmean1d/Makefile.am (100%)
copy {milena => scribo}/sandbox/green/tests/clustering/kmean1d/kmean1d.cc (100%)
copy {milena/sandbox/green/doc/examples/frac => scribo/sandbox/green/tests/io/plot/save_image_sh}/Makefile.am (100%)
copy {milena => scribo}/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc (100%)
diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index 8f5101b..db589a1 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -2,6 +2,20 @@
Import files from milena/sandbox/green.
+ * gaussian.sh: New gnuplot shell file.
+ * guassian2d.sh: New gnuplot shell file.
+ * test_labelling.cc: New source.
+ * tests/clustering/k_mean/Makefile.am: New makefile.
+ * tests/clustering/k_mean/k_mean.cc: New source.
+ * tests/clustering/kmean1d/Makefile.am: New makefile.
+ * tests/clustering/kmean1d/kmean1d.cc: New source.
+ * tests/io/plot/save_image_sh/Makefile.am: New makefile.
+ * tests/io/plot/save_image_sh/save_image_sh.cc: New source.
+
+2010-06-24 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Import files from milena/sandbox/green.
+
* mln/accu/stat/histo1d.hh: New header file.
* mln/accu/stat/histo2d.hh: New header file.
* mln/accu/stat/histo3d_hsl.hh: New header file.
diff --git a/milena/sandbox/green/tests/accu/stat/histo1d/gaussian.sh b/scribo/sandbox/green/gaussian.sh
similarity index 100%
copy from milena/sandbox/green/tests/accu/stat/histo1d/gaussian.sh
copy to scribo/sandbox/green/gaussian.sh
diff --git a/milena/sandbox/green/tests/accu/stat/histo2d/gaussian2d.sh b/scribo/sandbox/green/gaussian2d.sh
similarity index 100%
copy from milena/sandbox/green/tests/accu/stat/histo2d/gaussian2d.sh
copy to scribo/sandbox/green/gaussian2d.sh
diff --git a/scribo/sandbox/green/test_labelling.cc b/scribo/sandbox/green/test_labelling.cc
new file mode 100644
index 0000000..6238d2b
--- /dev/null
+++ b/scribo/sandbox/green/test_labelling.cc
@@ -0,0 +1,336 @@
+// 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/io/plot/save_histo_sh.hh>
+#include <mln/value/rgb8.hh>
+#include <mln/value/label_8.hh>
+#include <mln/core/alias/neighb1d.hh>
+#include <mln/core/image/dmorph/image_if.hh>
+#include <mln/labeling/colorize.hh>
+#include <mln/labeling/mean_values.hh>
+#include <mln/labeling/regional_maxima.hh>
+#include <mln/make/w_window1d.hh>
+#include <mln/math/pi.hh>
+#include <mln/morpho/watershed/flooding.hh>
+#include <mln/morpho/elementary/dilation.hh>
+#include <mln/morpho/elementary/closing.hh>
+#include <mln/pw/value.hh>
+#include <mln/linear/convolve.hh>
+#include <mln/linear/gaussian.hh>
+
+
+/// ... to complete
+
+/// \brief Compute the gaussian probability to obtain a given value.
+///
+/// \param[in] x the value from which we want the probability.
+/// \param[in] mean the mean parameter of the gaussian distribution.
+/// \param[in] sigma the sqrt(variance) parameter of the gaussian.
+/// \return the probability to obtain the x value.
+///
+/// Implements the standard equation of the gaussian.
+
+double gaussian_distribution(const double x,
+ const double mean,
+ const double sigma)
+{
+ double num = exp(-0.5*mln::math::sqr((x - mean)/sigma));
+ double denom = sigma*mln::math::sqrt(2*mln::math::pi);
+ double result = num/denom;
+
+ return result;
+}
+
+/// \brief Make a 1d gaussian filter.
+///
+/// \param[out] ws the window (filter) where to put the probability values.
+/// \param[in] size the size of the filter.
+/// \param[in] sigma the gaussian parameter for the standard deviation.
+/// \return the probability to obtain the x value.
+///
+/// Approach the gaussian distribution for a few discrete sites, and
+/// then normilize the results to be sure that the sum obtain 1.
+
+void gaussian_filter(double ws[], const unsigned size, const double sigma)
+{
+ int h = size/2;
+
+ for (int i = -h; i <= h; ++i)
+ {
+ ws[i+h] = gaussian_distribution(i, 0.0, sigma);
+ }
+
+ double sum = 0.0;
+
+ for (unsigned i = 0; i < size; ++i)
+ sum += ws[i];
+
+ for (unsigned i = 0; i < size; ++i)
+ ws[i] /= sum;
+}
+
+/// \brief Make a 1d gaussian filter.
+///
+/// \param[out] ws the window (filter) where to put the probability values.
+/// \param[in] size the size of the filter.
+/// \param[in] sigma the gaussian parameter for the standard deviation.
+/// \return the probability to obtain the x value.
+///
+/// Approach the gaussian distribution for a few discrete sites, and
+/// then normilize the results to be sure that the sum obtain 1.
+
+/// The aim of this function is to rebuild an label image2d from the segmenting
+/// image of the histogram (label) and the original image (input).
+/// label_image2d / for each grey tone, associate its label.
+
+mln::image2d<mln::value::label_8>
+build_8bits(const mln::image2d<mln::value::int_u8>& input,
+ const mln::image1d<mln::value::label_8>& label)
+{
+ mln::trace::entering("build_8bits");
+ mln_precondition(label.is_valid());
+ mln_precondition(input.is_valid());
+
+ mln::image2d<mln::value::label_8> output;
+
+ mln::initialize(output, input);
+
+ mln_piter_(mln::image2d<mln::value::int_u8>) pi(input.domain());
+ mln_piter_(mln::image2d<mln::value::label_8>) po(output.domain());
+
+ for_all_2(pi, po)
+ {
+ mln::value::int_u8 val = input(pi);
+ unsigned grp = label(mln::point1d(val));
+
+ output(po) = grp;
+ }
+
+ mln::trace::exiting("build_8bits");
+ return output;
+}
+
+
+void test_8bits_classifying()
+{
+ typedef mln::value::int_u8 int_u8;
+ typedef mln::value::label_8 label_8;
+ typedef mln::value::rgb8 rgb8;
+ typedef mln::accu::stat::mean<double> mean;
+
+ mln::image2d<int_u8> img_ref;
+ mln::image2d<int_u8> img_out;
+ mln::image2d<rgb8> img_rgb;
+ mln::image1d<unsigned> img_res;
+ mln::image1d<double> img_smooth;
+ mln::image1d<label_8> labels;
+ label_8 nlabels;
+
+ //-----------------------------------------------------
+ // Loading the scribo image and computing its histogram
+ //-----------------------------------------------------
+
+ std::cout << "(08 bits) LOADING HISTOGRAM" << std::endl;
+
+ // mln::io::pgm::load(img_ref, OLENA_IMG_PATH"/lena.pgm");
+ mln::io::pgm::load(img_ref, SCRIBO_IMG_PATH"/mp00082c_50p_8bits.pgm");
+ img_res = mln::data::compute(mln::accu::stat::histo1d<int_u8>(), img_ref);
+ mln::io::plot::save_histo_sh(img_res, "histo0_8bits.sh");
+
+
+ //-----------------------------------------------------
+ // Smoothing the histogram with a gaussian filter
+ //-----------------------------------------------------
+
+ std::cout << "(08 bits) SMOOTHING HISTOGRAM" << std::endl;
+
+ double ws[41];
+ gaussian_filter(ws, 41, 6.0);
+ img_smooth = mln::linear::convolve(img_res, mln::make::w_window1d(ws));
+ mln::io::plot::save_histo_sh(img_smooth, "histo1_8bits.sh");
+
+
+ //-----------------------------------------------------
+ // Segmenting the histogram with the watershed method
+ //-----------------------------------------------------
+
+ std::cout << "SEGMENTING HISTOGRAM" << std::endl;
+
+ /*
+ labels = mln::labeling::regional_maxima(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2_8bits.sh");
+ */
+
+ // need to revert the histogram
+ labels = mln::morpho::watershed::flooding(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2_8bits.sh");
+
+
+ //-----------------------------------------------------
+ // Rebuilding the image with the mean of each region
+ //-----------------------------------------------------
+
+ std::cout << "(08 bits) BUILDING OUTPUT" << std::endl;
+
+ mln::image2d<label_8>img_label = build_8bits(img_ref, labels);
+
+ std::cout << "(08 bits) COLORING OUTPUT" << std::endl;
+
+ img_out = mln::labeling::mean_values(img_ref, img_label, nlabels);
+ img_rgb = mln::labeling::colorize(rgb8(), img_label);
+
+ mln::io::pgm::save(img_out, "out_8bits.pgm");
+ mln::io::ppm::save(img_rgb, "color_8bits.pgm");
+
+ //labels = mln::morpho::elementary::dilation(labels, mln::c2());
+ //mln::io::plot::save_histo_sh(labels, "histo3.sh");
+ //mln::io::plot::save(labels, "labelized.data");
+}
+
+
+/// The aim of this function is to rebuild an label image2d from the segmenting
+/// image of the histogram (label) and the original image (input).
+/// label_image2d / for each grey tone, associate its label.
+
+mln::image2d<mln::value::label_8>
+build_14bits(const mln::image2d<mln::value::int_u<14> >& input,
+ const mln::image1d<mln::value::label_8>& label)
+{
+ mln::trace::entering("build_14bits");
+ mln_precondition(label.is_valid());
+ mln_precondition(input.is_valid());
+
+ mln::image2d<mln::value::label_8> output;
+
+ mln::initialize(output, input);
+
+ mln_piter_(mln::image2d<mln::value::int_u<14> >) pi(input.domain());
+ mln_piter_(mln::image2d<mln::value::label_8>) po(output.domain());
+
+ for_all_2(pi, po)
+ {
+ mln::value::int_u<14> val = input(pi);
+ unsigned grp = label(mln::point1d(val));
+
+ output(po) = grp;
+ }
+
+ mln::trace::exiting("build_14bits");
+ return output;
+}
+
+
+void test_14bits_classifying()
+{
+ typedef mln::value::int_u16 int_u16;
+ typedef mln::value::int_u<14> int_u14;
+ typedef mln::value::label_8 label_8;
+ typedef mln::value::rgb8 rgb8;
+ typedef mln::accu::stat::mean<double> mean;
+
+ mln::image2d<int_u16> img_fst;
+ mln::image2d<int_u14> img_ref;
+ mln::image2d<int_u14> img_out;
+ mln::image2d<rgb8> img_rgb;
+ mln::image1d<unsigned> img_res;
+ mln::image1d<double> img_smooth;
+ mln::image1d<label_8> labels;
+ label_8 nlabels;
+
+ //-----------------------------------------------------
+ // Loading the scribo image and computing its histogram
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) LOADING HISTOGRAM" << std::endl;
+
+ //mln::io::pgm::load(img_fst, OLENA_IMG_PATH"/lena_16.pgm");
+ mln::io::pgm::load(img_fst, SCRIBO_IMG_PATH"/mp00082c_50p_16bits.pgm");
+ img_ref = mln::data::transform(img_fst, mln::fun::v2v::int_u16_to_int_u14());
+ img_res = mln::data::compute(mln::accu::stat::histo1d<int_u14>(), img_ref);
+ mln::io::plot::save_histo_sh(img_res, "histo0_14bits.sh");
+
+
+ //-----------------------------------------------------
+ // Smoothing the histogram with a gaussian filter
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) SMOOTHING HISTOGRAM" << std::endl;
+
+ double ws[401];
+ gaussian_filter(ws, 401, 50.0);
+ img_smooth = mln::linear::convolve(img_res, mln::make::w_window1d(ws));
+ mln::io::plot::save_histo_sh(img_smooth, "histo1_14bits.sh");
+
+
+ //-----------------------------------------------------
+ // Segmenting the histogram with the watershed method
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) SEGMENTING HISTOGRAM" << std::endl;
+
+ /*
+ labels = mln::labeling::regional_maxima(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2.sh");
+ */
+
+
+ labels = mln::morpho::watershed::flooding(img_smooth, mln::c2(), nlabels);
+ std::cout << "N labels : " << nlabels << std::endl;
+ mln::io::plot::save_histo_sh(labels, "histo2_14bits.sh");
+
+
+ //-----------------------------------------------------
+ // Rebuilding the image with the mean of each region
+ //-----------------------------------------------------
+
+ std::cout << "(14 bits) BUILDING OUTPUT" << std::endl;
+
+ mln::image2d<label_8>img_label = build_14bits(img_ref, labels);
+
+ std::cout << "(14 bits) COLORING OUTPUT" << std::endl;
+
+ img_out = mln::labeling::mean_values(img_ref, img_label, nlabels);
+ img_rgb = mln::labeling::colorize(rgb8(), img_label);
+
+ mln::io::pgm::save(img_out, "out_14bits.pgm");
+ mln::io::ppm::save(img_rgb, "color_14bits.pgm");
+
+ //labels = mln::morpho::elementary::dilation(labels, mln::c2());
+ //mln::io::plot::save_histo_sh(labels, "histo3.sh");
+ //mln::io::plot::save(labels, "labelized.data");
+}
+
+int main()
+{
+ test_8bits_classifying();
+
+ test_14bits_classifying();
+
+ return 0;
+}
diff --git a/milena/sandbox/green/tests/clustering/k_mean/Makefile.am b/scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
similarity index 100%
copy from milena/sandbox/green/tests/clustering/k_mean/Makefile.am
copy to scribo/sandbox/green/tests/clustering/k_mean/Makefile.am
diff --git a/milena/sandbox/green/tests/clustering/k_mean/k_mean.cc b/scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
similarity index 100%
copy from milena/sandbox/green/tests/clustering/k_mean/k_mean.cc
copy to scribo/sandbox/green/tests/clustering/k_mean/k_mean.cc
diff --git a/milena/sandbox/green/tests/clustering/kmean1d/Makefile.am b/scribo/sandbox/green/tests/clustering/kmean1d/Makefile.am
similarity index 100%
copy from milena/sandbox/green/tests/clustering/kmean1d/Makefile.am
copy to scribo/sandbox/green/tests/clustering/kmean1d/Makefile.am
diff --git a/milena/sandbox/green/tests/clustering/kmean1d/kmean1d.cc b/scribo/sandbox/green/tests/clustering/kmean1d/kmean1d.cc
similarity index 100%
copy from milena/sandbox/green/tests/clustering/kmean1d/kmean1d.cc
copy to scribo/sandbox/green/tests/clustering/kmean1d/kmean1d.cc
diff --git a/milena/sandbox/green/doc/examples/frac/Makefile.am b/scribo/sandbox/green/tests/io/plot/save_image_sh/Makefile.am
similarity index 100%
copy from milena/sandbox/green/doc/examples/frac/Makefile.am
copy to scribo/sandbox/green/tests/io/plot/save_image_sh/Makefile.am
diff --git a/milena/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc b/scribo/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc
similarity index 100%
copy from milena/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc
copy to scribo/sandbox/green/tests/io/plot/save_image_sh/save_image_sh.cc
--
1.5.6.5
14 years, 6 months
- 1
- 0
last-svn-commit-227-g2290b5c Import files from milena/sandbox/green.
by Yann Jacquelet
* mln/accu/stat/histo1d.hh: New header file.
* mln/accu/stat/histo2d.hh: New header file.
* mln/accu/stat/histo3d_hsl.hh: New header file.
* mln/accu/stat/histo3d_rgb.hh: New header file.
* mln/clustering/k_mean.hh: New header file.
* mln/clustering/kmean1d.hh: New header file.
* mln/clustering/kmean2d.hh: New header file.
* mln/clustering/kmean3d.hh: New header file.
* mln/clustering/kmean_rgb.hh: New header file.
* mln/display/display_histo.hh: New header file.
* mln/display/project_histo.hh: New header file.
* mln/fun/p2b/achromatic.hh: New header file.
* mln/fun/p2b/component_equals.hh: New header file.
* mln/fun/v2v/achromatism.hh: New header file.
* mln/fun/v2v/hue_concentration.hh: New header file.
* mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
* mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
* mln/fun/v2v/log.hh: New header file.
* mln/fun/v2v/rg_to_rgb.hh: New header file.
* mln/fun/v2v/rgb8_to_int_u8: New header file.
* mln/fun/v2v/rgb_to_achromastism_map.hh: New header file.
* mln/fun/v2v/rgb_to_hsv.hh: New header file.
* mln/fun/v2v/rgb_to_hue_map.hh: New header file.
* mln/fun/v2v/rgb_to_saturation_map.hh: New header file.
* mln/fun/v2v/rgb_to_value_map.hh: New header file.
* mln/img_path.hh: New header file.
* mln/io/plot/save_image_sh.hh: New header file.
* mln/math/cell.hh: New header file.
* mln/math/floor.hh: New header file.
* tests/accu/stat/histo1d/Makefile.am: New makefile.
* tests/accu/stat/histo1d/histo1d.cc: New source.
* tests/accu/stat/histo2d/Makefile.am: New makefile.
* tests/accu/stat/histo2d/histo2d.cc: New source.
---
scribo/sandbox/green/ChangeLog | 9 +
scribo/sandbox/green/README | 223 ++++++++++++++++++--
scribo/sandbox/green/mln/accu/stat/histo1d.hh | 1 -
scribo/sandbox/green/mln/accu/stat/histo2d.hh | 9 +-
scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh | 1 +
scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh | 2 +
.../sandbox/green/use/accu/stat/histo1d/histo1d.cc | 2 -
7 files changed, 224 insertions(+), 23 deletions(-)
diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index 7bb6646..b557ccf 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -159,6 +159,15 @@
2010-06-21 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+ Save histogram library.
+
+ * mln/accu/histo/histo1d.hh: New header file.
+ * mln/accu/histo/histo2d.hh: New header file.
+ * mln/accu/histo/histo3d_rgb.hh: New header file.
+ * mln/accu/histo/histo3d_hsl.hh: New header file.
+
+2010-06-21 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
Simple integration test.
* README: New text file.
diff --git a/scribo/sandbox/green/README b/scribo/sandbox/green/README
index 4eb71b7..3efe50d 100644
--- a/scribo/sandbox/green/README
+++ b/scribo/sandbox/green/README
@@ -1,32 +1,219 @@
-Le travail est classé dans deux répertoires ok et ko.
-Le répertoire ok correspond aux sources qui ont été reprises et retestées.
-Le répertoire ko correspond aux sources qui ont été juste transférées.
+I ARBORESCENCE
+--------------
-La première brique logicielle importante sur laquelle s'appuie mes travaux est
-la création d'histogrammes sous forme d'image.
+bench ==> Comparaison d'algorithmes d'un point de vue temps d'exécution.
+bug ==> Bug rencontrés dans milena et archivés sous forme de programme.
+build ==> Répertoire d'exécution, non sauvé dans git.
+demo ==> Première version d'un algorithme pour voir son comportement.
+doc ==> Documentation tex ou code minimal pour de petits exemples.
+exp ==> Version avancée des algorithmes pour traitées les bases de données.
+mln ==> Partie mise en librairie milena des différents travaux.
+tests ==> Tests unitaires sur certains algorithmes.
+tools ==> Découpage de certains algorithmes pour mieux les tester séparément.
+use ==> Test de compilation, code minimal pour compiler un élément.
+II COMPILATION
+--------------
-CREATION DES HISTOGRAMMES
--------------------------
+L'unité minimale de code choisie est le répertoire.
+Donc aller dans le répertoire qui nous interesse,
+par exemple, green/demo/annotating/hsv et lancé le make
-ko/mln/accu/stat/histo1d.hh: histogramme image valeur scalaire.
-ko/mln/accu/stat/histo2d.hh: histogramme image valeur vectorielle 2d.
-ko/mln/accu/stat/histo3d_hsl.hh: histogramme image valeur vectorielle 3d (HSL).
-ko/mln/accu/stat/histo3d_rgb.hh: histogramme image valeur vectorielle 3d (RGB).
+#:~/git/olena/scribo/sandbox/green$cd demo/annotating/hsv
+#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$ make -f Makefile.am
+Cette opération créé dans build le répertoire de compilation
+green/build/demo/annotating/hsv. Dans ce répertoire aura été copié un
+Makefile et tous les fichiers qui ne sont pas des sources. Par
+exemple, des fichiers de calibration comme gaussian.sh (pour vérifier
+la mire du filtre de gaussienne) ou de la documentation à la sauvette
+sous forme de fichiers textes jetés à la va vite dans le répertoire
+pour ne pas perdre l'information recherchée. En l'occurence, ici, il
+n'y a rien à copier. Rendons-nous dans le répertoire de compilation et lançons
+le makefile.
+#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$
+cd ../../../build/demo/annotating/hsv
+#:~/git/olena/scribo/sandbox/green/build/demo/annotating/hsv$ make clean all
-ok/mln/accu/histo/histo1d.hh: histogramme image valeur scalaire entière.
-ok/mln/accu/histo/histo2d.hh: histogramme image valeur vectorielle 2d entière.
-ok/mln/accu/histo/histo3d.hh: histogramme image valeur vectorielle 3d entière.
+L'exécutable est généré par le makefile, il porte le nom du
+répertoire. Si il y a besoin de mettre à jour le makefile, le faire
+dans le répertoire des sources en éditant Makefile.am, puis en
+régénérant le Makefile dans le répertoire d'exécution par la commande
+make -f Makefile.am depuis le répertoire source.
-SAUVEGARDE DES HISTOGRAMMES
----------------------------
+III MAKEFILE
+------------
+Les makefiles utilisés sont tous les mêmes avec quelques variables
+dont le contenu change dans leur partie en-tête.
+Pour chaque répertoire, le makefile doit savoir si le chemin courant
+est un répertoire de compilation ou un répertoire de source. Pour les
+identifier, il a recours à un pattern qui malheureusemnt fait
+intervenir le nom de la branche de développement (bench,demo,bug,exp ...).
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
-VISUALISATION DES HISTOGRAMMES
-------------------------------
\ No newline at end of file
+Si un makefile ne fonctionne pas, il faut vérifier ceci en premier
+lieu. Ici, le makefile doit être situé dans la branche démo.
+
+Autre élément à savoir, la compilation nécessite d'inclure la
+librairie milena, ainsi que les développements propres en vu de leur
+intégration futur dans milena, ceci est fait par un jeu d'INCLUDES1
+et INCLUDES2.
+
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+
+Suivant l'allure du compte où l'on exécute les makefiles, il faut
+revoir le chemin pour trouver des deux répertoires.
+
+Enfin, les options de compilations ne sont pas toujours les mêmes. Les
+trois lignes possibles sont toutes présentes et seule celle qui est
+utilisée n'est pas commentée. Typiquement, dans la branche de
+développement démo où les perfomances ne sont pas le problème, on
+compilera avec tout le matériel pour utiliser gdb et sans
+optimisation. A l'inverse, dans la branche d'expérimentation, où le
+code a déjà été testé, on cherche à aller vite car on exécute ce code
+sur de nombreuses images. Dans cette optique, pas de débugage, pas de
+traçage, optimisation conséquente.
+
+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)
+
+Une dernière dernière information, dans le cadre des développements
+exp, et tools, on utilise la librairie boost soit pour la
+virtualisation du filesystem, soit pour le formatage des fichiers text
+(réalisation de colonnes, mettre des entiers sur un certain nombre de
+caractères). Une ligne de chargement des librairies peut apparaitre donc.
+
+LOADLIBES= -lboost_filesystem
+
+On retrouvera les includes suivantes dans les sources:
+
+#include <boost/format.hpp>
+#include <boost/filesystem.hpp>
+
+
+IV CHEMINS DES IMAGES
+---------------------
+
+Toutes les images ont toujours été locales sur mon ordinateur. La
+politique a toujours été d'utiliser un fichier img_path pour coder les
+chemins des images. Les chemins étant plutôt long, j'ai toujours eu
+tendance à faire en sorte qu'ils soient compilés en dur (sauf pour la
+partie développement tools qui est vraiment voué à donner des
+exécutables indépendants et génériques). Le fichier mln/img_path.hh
+code la position de toutes les images dans mon arborescence. Il faudra
+donc veiller à changer tous les chemins pour les adapter au compte
+dans lequel on voudra reprendre le code. Dans le code, les références
+aux positions des images sont faites via des macros.
+
+Toutes les images sont située dans git/img. En règle générale, je ne
+traite que des images au format .pgm, .pbm et .ppm. Il m'arrive
+fréquemment de dumper des images au format .sh (gnuplot shell
+image). Pour la branche tools, nous avons utilisé les dumps de milena
+comme format de transfert d'un utilitaire à un autre. Les images sont
+classées suivant leur provenance. Nous avons tout d'abord la base
+OLENA (copie des images de tests milena), la base INIM (très peu
+utilisée voire jamais), la base ICDAR (très utilisée, surtout dans
+exp), la base AFP (très utilisée dans exp) et les bases ANNOTATING1 et
+ANNOTATING2 (pas très utilisées ni l'une, ni l'autre).
+
+La plus part du temps, sauver les résultats dans le répertoire
+d'exécution courant est largement suffisant. Parfois, il est
+nécessaire de sauvegarder de grosses quantités d'informations et de
+les classer comme dans la branche de développement exp. C'est pour
+cela, qu'un certain nombre de macros définissent des endroits pour
+sauvegarder les résultats lors d'expérimentation de grande ampleur sur
+toute la base ICDAR ou AFP.
+
+
+V GNUPLOT SCRIPT SHELL IMAGE FORMAT
+-----------------------------------
+
+J'abrège le nom du format par gnuplot shell format. En fait, c'est un
+format d'image particulier qui a besoin de gnuplot pour être lu. Il
+est donc compatible avec aucun viewer si ce n'est gnuplot, mais a la
+caractéristique d'afficher tous les points de manière visible. Par
+ailleurs, comme il s'agit d'un script gnuplot il permet d'insérer très
+facilement une fonction pour visualiser les données autrement (par
+exemple, changer d'espace: HSL, HSV). Le fichier tire son nom de la
+façon dont il fonctionne. C'est un script shell qui fait un appel à
+gnuplot et lui passe le jeu de données directement à partir de ce même
+fichier, pas besoin de faire appel à un autre fichier. Une fois
+généré, le fichier doit être modifié pour avoir les permissions
+d'exécution (chmod 755 gnuplot_shell_file.sh). Comme je trouve le format
+extrêmement pratique, il se retrouve preque partout dans mes sources.
+
+
+V MLN
+-----
+
+a) La sauvegarde des images au format gnuplot shell
+
+* mln/io/plot/save_image_sh.hh: Librairie sauvegarde format gnuplot shell.
+
+to do ...
+
+
+
+b) Les histogrammes
+
+Un des travaux demandés par théo est la réalisation d'une librairie
+d'histogramme permettant de fournir un résultat sous forme d'image.
+L'intérêt est ensuite de pouvoir filtrer directement ces histogrammes
+par les algorithmes de milena, ou encore d'étudier les valeurs
+caractéristiques par d'autres accumulateurs. Les codes réellement
+utilisés sont histo1d et histo3d RGB. Tous les autres codes sont très
+expérimentaux. Notemment, le code HSL demande de quantifier l'espace
+de comptage puisqu'il est décrit sous la forme de triplets de float
+(les autres sont inférés). Néanmoins, le code est à conserver car il
+contient une séquence d'appels pour les routines permettant de
+considérer la dimension de la teinte comme circulaire.
+
+* mln/accu/stat/histo1d.hh: Accumulateur histogramme image1d.
+* use/accu/stat/histo1d: Code minimal utilisant un histogramme 1d.
+
+* mln/accu/stat/histo2d.hh: Accumulateur histogramme image2d.
+* mln/value/rg.hh: Définition du type vectoriel 2d rouge/vert (RG).
+* mln/fun/v2v/rgb_to_rg.hh: Transformation de l'espace RGB vers l'espace RG.
+* use/accu/stat/histo2d: Code minimal utilisant un histogramme 2d.
+
+
+* mln/accu/stat/histo3d_rgb.hh: Accumulateur histogramme image3d RGB.
+* mln/accu/stat/histo3d_hsl.hh: Accumulateur histogramme image3d HSL.
+
+* use/accu/stat/histo3_rgb: Code minimal utilisant un histogramme 3d RGB.
+* use/accu/stat/histo3_hsl: Code minimal utilisant un histogramme 3d HSL.
+
+
+
+* tests/accu/stat/histo1d
+
+
+
+
+* tests/accu/stat/histo2d
+
+
+
+* use/accu/stat/histo3d_rgb
+* tests/accu/stat/histo3d_rgb
+
+* use/accu/stat/histo3d_hsl
+* tests/accu/stat/histo3d_hsl
+
+
+c) La visualisation des histogrammes 3d
+
+* demo/accu/stat/histo2d
+
+* mln/display/dispay_histo.hh
+* mln/displayproject_histo.hh
diff --git a/scribo/sandbox/green/mln/accu/stat/histo1d.hh b/scribo/sandbox/green/mln/accu/stat/histo1d.hh
index fae94c8..7677d3b 100644
--- a/scribo/sandbox/green/mln/accu/stat/histo1d.hh
+++ b/scribo/sandbox/green/mln/accu/stat/histo1d.hh
@@ -328,7 +328,6 @@ namespace mln
# endif // ! MLN_INCLUDE_ONLY
-
} // end of namespace mln::accu::stat
} // end of namespace mln::accu
diff --git a/scribo/sandbox/green/mln/accu/stat/histo2d.hh b/scribo/sandbox/green/mln/accu/stat/histo2d.hh
index 11a1bb3..ee4d145 100644
--- a/scribo/sandbox/green/mln/accu/stat/histo2d.hh
+++ b/scribo/sandbox/green/mln/accu/stat/histo2d.hh
@@ -80,7 +80,7 @@
# include <mln/core/alias/point2d.hh>
# include <mln/core/alias/box2d.hh>
-#include <mln/literal/zero.hh>
+# include <mln/literal/zero.hh>
# include <mln/trait/value/comp.hh>
@@ -182,6 +182,7 @@ namespace mln
histo2d();
/// \}
+
/// Manipulators.
/// \{
/// \brief Initialize the histogram with zero value.
@@ -191,13 +192,15 @@ namespace mln
/// density.
void init();
+
/// \brief Update the histogram with the RG pixel t.
- /// \param[in] t a graylevel pixel of type V.
+ /// \param[in] t a R/G pixel of type V.
///
/// The end user shouldn't call this method. In place of it, he can
/// go through the data compute interface.
void take(const argument& t);
+
/// \brief Update the histogram with an other histogram.
/// \param[in] other the other histogram.
///
@@ -269,6 +272,8 @@ namespace mln
inline
void histo2d<V>::take(const argument& t)
{
+ trace::entering("mln::accu::stat::histo2d::take");
+
// Just convert a greyscale value (int_u8 like) to a position for an
// iterator on the resulting image.
// Take care to the constructor : Point(slice, row, column)
diff --git a/scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh b/scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
index 35d78e2..a8888cd 100644
--- a/scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
+++ b/scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
@@ -168,6 +168,7 @@ namespace mln
/// \ingroup modaccuvalues
template <unsigned q, typename V>
struct histo3d_hsl :
+
public mln::accu::internal::base<image3d<unsigned>, histo3d_hsl<q,V> >
{
typedef V argument;
diff --git a/scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh b/scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
index 6a48024..2fb6084 100644
--- a/scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
+++ b/scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
@@ -179,6 +179,7 @@ namespace mln
histo3d_rgb();
/// \}
+
/// Manipulators.
/// \{
/// \brief Initialize the histogram with zero value.
@@ -242,6 +243,7 @@ namespace mln
histo3d_rgb<V>::histo3d_rgb()
{
trace::entering("mln::accu::stat::histo3d_rgb::cstor");
+
typedef mln_trait_value_comp(V,0) comp0;
typedef mln_trait_value_comp(V,1) comp1;
typedef mln_trait_value_comp(V,2) comp2;
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc b/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
index af39d94..ec80ff1 100644
--- a/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
+++ b/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
@@ -36,8 +36,6 @@
#include <mln/io/pgm/load.hh>
#include <mln/value/int_u8.hh>
-
-
int main()
{
typedef mln::value::int_u8 t_int_u8;
--
1.5.6.5
14 years, 6 months
- 1
- 0
last-svn-commit-165-g76dd7c3 Import files from milena/sandbox/green.
by Yann Jacquelet
* mln/accu/stat/histo1d.hh: New header file.
* mln/accu/stat/histo2d.hh: New header file.
* mln/accu/stat/histo3d_hsl.hh: New header file.
* mln/accu/stat/histo3d_rgb.hh: New header file.
* mln/clustering/k_mean.hh: New header file.
* mln/clustering/kmean1d.hh: New header file.
* mln/clustering/kmean2d.hh: New header file.
* mln/clustering/kmean3d.hh: New header file.
* mln/clustering/kmean_rgb.hh: New header file.
* mln/display/display_histo.hh: New header file.
* mln/display/project_histo.hh: New header file.
* mln/fun/p2b/achromatic.hh: New header file.
* mln/fun/p2b/component_equals.hh: New header file.
* mln/fun/v2v/achromatism.hh: New header file.
* mln/fun/v2v/hue_concentration.hh: New header file.
* mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
* mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
* mln/fun/v2v/log.hh: New header file.
* mln/fun/v2v/rg_to_rgb.hh: New header file.
* mln/fun/v2v/rgb8_to_int_u8: New header file.
* mln/fun/v2v/rgb_to_achromastism_map.hh: New header file.
* mln/fun/v2v/rgb_to_hsv.hh: New header file.
* mln/fun/v2v/rgb_to_hue_map.hh: New header file.
* mln/fun/v2v/rgb_to_saturation_map.hh: New header file.
* mln/fun/v2v/rgb_to_value_map.hh: New header file.
* mln/img_path.hh: New header file.
* mln/io/plot/save_image_sh.hh: New header file.
* mln/math/cell.hh: New header file.
* mln/math/floor.hh: New header file.
* tests/accu/stat/histo1d/Makefile.am: New makefile.
* tests/accu/stat/histo1d/histo1d.cc: New source.
* tests/accu/stat/histo2d/Makefile.am: New makefile.
* tests/accu/stat/histo2d/histo2d.cc: New source.
---
scribo/sandbox/green/ChangeLog | 59 ++
scribo/sandbox/green/README | 223 ++++-
scribo/sandbox/green/mln/accu/stat/histo1d.hh | 340 +++++++
scribo/sandbox/green/mln/accu/stat/histo2d.hh | 358 +++++++
.../sandbox/green/mln/accu/stat/histo3d_hsl.hh | 0
.../sandbox/green/mln/accu/stat/histo3d_rgb.hh | 0
.../sandbox/green/mln/clustering/k_mean.hh | 0
.../sandbox/green/mln/clustering/kmean1d.hh | 0
.../sandbox/green/mln/clustering/kmean2d.hh | 0
.../sandbox/green/mln/clustering/kmean3d.hh | 0
scribo/sandbox/green/mln/clustering/kmean_rgb.hh | 973 ++++++++++++++++++
scribo/sandbox/green/mln/display/display_histo.hh | 180 ++++
scribo/sandbox/green/mln/display/project_histo.hh | 536 ++++++++++
scribo/sandbox/green/mln/fun/p2b/achromatic.hh | 112 ++
.../sandbox/green/mln/fun/p2b/component_equals.hh | 99 ++
scribo/sandbox/green/mln/fun/v2v/achromatism.hh | 64 ++
.../sandbox/green/mln/fun/v2v/hue_concentration.hh | 100 ++
.../green/mln/fun/v2v/int_u16_to_int_u14.hh | 0
.../sandbox/green/mln/fun/v2v/log.hh | 0
.../sandbox/green/mln/fun/v2v/rg_to_rgb.hh | 0
scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh | 71 ++
.../sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh | 0
.../green/mln/fun/v2v/rgb_to_achromatism_map.hh | 77 ++
scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh | 149 +++
scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh | 96 ++
scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh | 111 ++
.../green/mln/fun/v2v/rgb_to_saturation_map.hh | 83 ++
.../sandbox/green/mln/fun/v2v/rgb_to_value_map.hh | 75 ++
scribo/sandbox/green/mln/img_path.hh | 239 +++++
scribo/sandbox/green/mln/io/plot/save_image_sh.hh | 1056 ++++++++++++++++++++
scribo/sandbox/green/mln/math/ceil.hh | 64 ++
scribo/sandbox/green/mln/math/floor.hh | 64 ++
scribo/sandbox/green/mln/value/hsv.hh | 424 ++++++++
scribo/sandbox/green/mln/value/rg.hh | 175 ++++
.../green/tests/accu/stat/histo1d/Makefile.am | 153 +++
.../green/tests/accu/stat/histo1d/histo1d.cc | 21 +
.../green/use/accu/stat/histo1d/Makefile.am | 153 +++
.../sandbox/green/use/accu/stat/histo1d/histo1d.cc | 24 +
.../green/use/accu/stat/histo2d/Makefile.am | 153 +++
.../sandbox/green/use/accu/stat/histo2d/histo2d.cc | 33 +
40 files changed, 6247 insertions(+), 18 deletions(-)
create mode 100644 scribo/sandbox/green/mln/accu/stat/histo1d.hh
create mode 100644 scribo/sandbox/green/mln/accu/stat/histo2d.hh
copy {milena => scribo}/sandbox/green/mln/accu/stat/histo3d_hsl.hh (100%)
copy {milena => scribo}/sandbox/green/mln/accu/stat/histo3d_rgb.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/k_mean.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean1d.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean2d.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean3d.hh (100%)
create mode 100644 scribo/sandbox/green/mln/clustering/kmean_rgb.hh
create mode 100644 scribo/sandbox/green/mln/display/display_histo.hh
create mode 100644 scribo/sandbox/green/mln/display/project_histo.hh
create mode 100644 scribo/sandbox/green/mln/fun/p2b/achromatic.hh
create mode 100644 scribo/sandbox/green/mln/fun/p2b/component_equals.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/achromatism.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
copy {milena => scribo}/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/log.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rg_to_rgb.hh (100%)
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh (100%)
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh
create mode 100644 scribo/sandbox/green/mln/img_path.hh
create mode 100644 scribo/sandbox/green/mln/io/plot/save_image_sh.hh
create mode 100644 scribo/sandbox/green/mln/math/ceil.hh
create mode 100644 scribo/sandbox/green/mln/math/floor.hh
create mode 100644 scribo/sandbox/green/mln/value/hsv.hh
create mode 100644 scribo/sandbox/green/mln/value/rg.hh
create mode 100644 scribo/sandbox/green/tests/accu/stat/histo1d/Makefile.am
create mode 100644 scribo/sandbox/green/tests/accu/stat/histo1d/histo1d.cc
create mode 100644 scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
create mode 100644 scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
create mode 100644 scribo/sandbox/green/use/accu/stat/histo2d/Makefile.am
create mode 100644 scribo/sandbox/green/use/accu/stat/histo2d/histo2d.cc
diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index e69de29..6a3c8fa 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -0,0 +1,59 @@
+2010-06-24 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Import files from milena/sandbox/green.
+
+ * mln/accu/stat/histo1d.hh: New header file.
+ * mln/accu/stat/histo2d.hh: New header file.
+ * mln/accu/stat/histo3d_hsl.hh: New header file.
+ * mln/accu/stat/histo3d_rgb.hh: New header file.
+ * mln/clustering/k_mean.hh: New header file.
+ * mln/clustering/kmean1d.hh: New header file.
+ * mln/clustering/kmean2d.hh: New header file.
+ * mln/clustering/kmean3d.hh: New header file.
+ * mln/clustering/kmean_rgb.hh: New header file.
+ * mln/display/display_histo.hh: New header file.
+ * mln/display/project_histo.hh: New header file.
+ * mln/fun/p2b/achromatic.hh: New header file.
+ * mln/fun/p2b/component_equals.hh: New header file.
+ * mln/fun/v2v/achromatism.hh: New header file.
+ * mln/fun/v2v/hue_concentration.hh: New header file.
+ * mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
+ * mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
+ * mln/fun/v2v/log.hh: New header file.
+ * mln/fun/v2v/rg_to_rgb.hh: New header file.
+ * mln/fun/v2v/rgb8_to_int_u8: New header file.
+ * mln/fun/v2v/rgb_to_achromastism_map.hh: New header file.
+ * mln/fun/v2v/rgb_to_hsv.hh: New header file.
+ * mln/fun/v2v/rgb_to_hue_map.hh: New header file.
+ * mln/fun/v2v/rgb_to_saturation_map.hh: New header file.
+ * mln/fun/v2v/rgb_to_value_map.hh: New header file.
+ * mln/img_path.hh: New header file.
+ * mln/io/plot/save_image_sh.hh: New header file.
+ * mln/math/cell.hh: New header file.
+ * mln/math/floor.hh: New header file.
+ * tests/accu/stat/histo1d/Makefile.am: New makefile.
+ * tests/accu/stat/histo1d/histo1d.cc: New source.
+ * tests/accu/stat/histo2d/Makefile.am: New makefile.
+ * tests/accu/stat/histo2d/histo2d.cc: New source.
+
+2010-06-21 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Save histogram library.
+
+ * mln/accu/histo/histo1d.hh: New header file.
+ * mln/accu/histo/histo2d.hh: New header file.
+ * mln/accu/histo/histo3d_rgb.hh: New header file.
+ * mln/accu/histo/histo3d_hsl.hh: New header file.
+
+2010-06-21 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Simple integration test.
+
+ * README: New text file.
+ * ok/mln/img_path.hh: New header file.
+ * ok/mln/accu/histo/histo1d.hh: New header file.
+ * ok/mln/accu/histo/histo2d.hh: New header file.
+ * ok/mln/accu/histo/histo3d.hh: New header file.
+ * ok/test/accu/histo/gaussian.sh: New gnuplot script file.
+ * ok/test/accu/histo/histo1d.cc: New source file.
+
diff --git a/scribo/sandbox/green/README b/scribo/sandbox/green/README
index 4eb71b7..3efe50d 100644
--- a/scribo/sandbox/green/README
+++ b/scribo/sandbox/green/README
@@ -1,32 +1,219 @@
-Le travail est classé dans deux répertoires ok et ko.
-Le répertoire ok correspond aux sources qui ont été reprises et retestées.
-Le répertoire ko correspond aux sources qui ont été juste transférées.
+I ARBORESCENCE
+--------------
-La première brique logicielle importante sur laquelle s'appuie mes travaux est
-la création d'histogrammes sous forme d'image.
+bench ==> Comparaison d'algorithmes d'un point de vue temps d'exécution.
+bug ==> Bug rencontrés dans milena et archivés sous forme de programme.
+build ==> Répertoire d'exécution, non sauvé dans git.
+demo ==> Première version d'un algorithme pour voir son comportement.
+doc ==> Documentation tex ou code minimal pour de petits exemples.
+exp ==> Version avancée des algorithmes pour traitées les bases de données.
+mln ==> Partie mise en librairie milena des différents travaux.
+tests ==> Tests unitaires sur certains algorithmes.
+tools ==> Découpage de certains algorithmes pour mieux les tester séparément.
+use ==> Test de compilation, code minimal pour compiler un élément.
+II COMPILATION
+--------------
-CREATION DES HISTOGRAMMES
--------------------------
+L'unité minimale de code choisie est le répertoire.
+Donc aller dans le répertoire qui nous interesse,
+par exemple, green/demo/annotating/hsv et lancé le make
-ko/mln/accu/stat/histo1d.hh: histogramme image valeur scalaire.
-ko/mln/accu/stat/histo2d.hh: histogramme image valeur vectorielle 2d.
-ko/mln/accu/stat/histo3d_hsl.hh: histogramme image valeur vectorielle 3d (HSL).
-ko/mln/accu/stat/histo3d_rgb.hh: histogramme image valeur vectorielle 3d (RGB).
+#:~/git/olena/scribo/sandbox/green$cd demo/annotating/hsv
+#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$ make -f Makefile.am
+Cette opération créé dans build le répertoire de compilation
+green/build/demo/annotating/hsv. Dans ce répertoire aura été copié un
+Makefile et tous les fichiers qui ne sont pas des sources. Par
+exemple, des fichiers de calibration comme gaussian.sh (pour vérifier
+la mire du filtre de gaussienne) ou de la documentation à la sauvette
+sous forme de fichiers textes jetés à la va vite dans le répertoire
+pour ne pas perdre l'information recherchée. En l'occurence, ici, il
+n'y a rien à copier. Rendons-nous dans le répertoire de compilation et lançons
+le makefile.
+#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$
+cd ../../../build/demo/annotating/hsv
+#:~/git/olena/scribo/sandbox/green/build/demo/annotating/hsv$ make clean all
-ok/mln/accu/histo/histo1d.hh: histogramme image valeur scalaire entière.
-ok/mln/accu/histo/histo2d.hh: histogramme image valeur vectorielle 2d entière.
-ok/mln/accu/histo/histo3d.hh: histogramme image valeur vectorielle 3d entière.
+L'exécutable est généré par le makefile, il porte le nom du
+répertoire. Si il y a besoin de mettre à jour le makefile, le faire
+dans le répertoire des sources en éditant Makefile.am, puis en
+régénérant le Makefile dans le répertoire d'exécution par la commande
+make -f Makefile.am depuis le répertoire source.
-SAUVEGARDE DES HISTOGRAMMES
----------------------------
+III MAKEFILE
+------------
+Les makefiles utilisés sont tous les mêmes avec quelques variables
+dont le contenu change dans leur partie en-tête.
+Pour chaque répertoire, le makefile doit savoir si le chemin courant
+est un répertoire de compilation ou un répertoire de source. Pour les
+identifier, il a recours à un pattern qui malheureusemnt fait
+intervenir le nom de la branche de développement (bench,demo,bug,exp ...).
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
-VISUALISATION DES HISTOGRAMMES
-------------------------------
\ No newline at end of file
+Si un makefile ne fonctionne pas, il faut vérifier ceci en premier
+lieu. Ici, le makefile doit être situé dans la branche démo.
+
+Autre élément à savoir, la compilation nécessite d'inclure la
+librairie milena, ainsi que les développements propres en vu de leur
+intégration futur dans milena, ceci est fait par un jeu d'INCLUDES1
+et INCLUDES2.
+
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+
+Suivant l'allure du compte où l'on exécute les makefiles, il faut
+revoir le chemin pour trouver des deux répertoires.
+
+Enfin, les options de compilations ne sont pas toujours les mêmes. Les
+trois lignes possibles sont toutes présentes et seule celle qui est
+utilisée n'est pas commentée. Typiquement, dans la branche de
+développement démo où les perfomances ne sont pas le problème, on
+compilera avec tout le matériel pour utiliser gdb et sans
+optimisation. A l'inverse, dans la branche d'expérimentation, où le
+code a déjà été testé, on cherche à aller vite car on exécute ce code
+sur de nombreuses images. Dans cette optique, pas de débugage, pas de
+traçage, optimisation conséquente.
+
+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)
+
+Une dernière dernière information, dans le cadre des développements
+exp, et tools, on utilise la librairie boost soit pour la
+virtualisation du filesystem, soit pour le formatage des fichiers text
+(réalisation de colonnes, mettre des entiers sur un certain nombre de
+caractères). Une ligne de chargement des librairies peut apparaitre donc.
+
+LOADLIBES= -lboost_filesystem
+
+On retrouvera les includes suivantes dans les sources:
+
+#include <boost/format.hpp>
+#include <boost/filesystem.hpp>
+
+
+IV CHEMINS DES IMAGES
+---------------------
+
+Toutes les images ont toujours été locales sur mon ordinateur. La
+politique a toujours été d'utiliser un fichier img_path pour coder les
+chemins des images. Les chemins étant plutôt long, j'ai toujours eu
+tendance à faire en sorte qu'ils soient compilés en dur (sauf pour la
+partie développement tools qui est vraiment voué à donner des
+exécutables indépendants et génériques). Le fichier mln/img_path.hh
+code la position de toutes les images dans mon arborescence. Il faudra
+donc veiller à changer tous les chemins pour les adapter au compte
+dans lequel on voudra reprendre le code. Dans le code, les références
+aux positions des images sont faites via des macros.
+
+Toutes les images sont située dans git/img. En règle générale, je ne
+traite que des images au format .pgm, .pbm et .ppm. Il m'arrive
+fréquemment de dumper des images au format .sh (gnuplot shell
+image). Pour la branche tools, nous avons utilisé les dumps de milena
+comme format de transfert d'un utilitaire à un autre. Les images sont
+classées suivant leur provenance. Nous avons tout d'abord la base
+OLENA (copie des images de tests milena), la base INIM (très peu
+utilisée voire jamais), la base ICDAR (très utilisée, surtout dans
+exp), la base AFP (très utilisée dans exp) et les bases ANNOTATING1 et
+ANNOTATING2 (pas très utilisées ni l'une, ni l'autre).
+
+La plus part du temps, sauver les résultats dans le répertoire
+d'exécution courant est largement suffisant. Parfois, il est
+nécessaire de sauvegarder de grosses quantités d'informations et de
+les classer comme dans la branche de développement exp. C'est pour
+cela, qu'un certain nombre de macros définissent des endroits pour
+sauvegarder les résultats lors d'expérimentation de grande ampleur sur
+toute la base ICDAR ou AFP.
+
+
+V GNUPLOT SCRIPT SHELL IMAGE FORMAT
+-----------------------------------
+
+J'abrège le nom du format par gnuplot shell format. En fait, c'est un
+format d'image particulier qui a besoin de gnuplot pour être lu. Il
+est donc compatible avec aucun viewer si ce n'est gnuplot, mais a la
+caractéristique d'afficher tous les points de manière visible. Par
+ailleurs, comme il s'agit d'un script gnuplot il permet d'insérer très
+facilement une fonction pour visualiser les données autrement (par
+exemple, changer d'espace: HSL, HSV). Le fichier tire son nom de la
+façon dont il fonctionne. C'est un script shell qui fait un appel à
+gnuplot et lui passe le jeu de données directement à partir de ce même
+fichier, pas besoin de faire appel à un autre fichier. Une fois
+généré, le fichier doit être modifié pour avoir les permissions
+d'exécution (chmod 755 gnuplot_shell_file.sh). Comme je trouve le format
+extrêmement pratique, il se retrouve preque partout dans mes sources.
+
+
+V MLN
+-----
+
+a) La sauvegarde des images au format gnuplot shell
+
+* mln/io/plot/save_image_sh.hh: Librairie sauvegarde format gnuplot shell.
+
+to do ...
+
+
+
+b) Les histogrammes
+
+Un des travaux demandés par théo est la réalisation d'une librairie
+d'histogramme permettant de fournir un résultat sous forme d'image.
+L'intérêt est ensuite de pouvoir filtrer directement ces histogrammes
+par les algorithmes de milena, ou encore d'étudier les valeurs
+caractéristiques par d'autres accumulateurs. Les codes réellement
+utilisés sont histo1d et histo3d RGB. Tous les autres codes sont très
+expérimentaux. Notemment, le code HSL demande de quantifier l'espace
+de comptage puisqu'il est décrit sous la forme de triplets de float
+(les autres sont inférés). Néanmoins, le code est à conserver car il
+contient une séquence d'appels pour les routines permettant de
+considérer la dimension de la teinte comme circulaire.
+
+* mln/accu/stat/histo1d.hh: Accumulateur histogramme image1d.
+* use/accu/stat/histo1d: Code minimal utilisant un histogramme 1d.
+
+* mln/accu/stat/histo2d.hh: Accumulateur histogramme image2d.
+* mln/value/rg.hh: Définition du type vectoriel 2d rouge/vert (RG).
+* mln/fun/v2v/rgb_to_rg.hh: Transformation de l'espace RGB vers l'espace RG.
+* use/accu/stat/histo2d: Code minimal utilisant un histogramme 2d.
+
+
+* mln/accu/stat/histo3d_rgb.hh: Accumulateur histogramme image3d RGB.
+* mln/accu/stat/histo3d_hsl.hh: Accumulateur histogramme image3d HSL.
+
+* use/accu/stat/histo3_rgb: Code minimal utilisant un histogramme 3d RGB.
+* use/accu/stat/histo3_hsl: Code minimal utilisant un histogramme 3d HSL.
+
+
+
+* tests/accu/stat/histo1d
+
+
+
+
+* tests/accu/stat/histo2d
+
+
+
+* use/accu/stat/histo3d_rgb
+* tests/accu/stat/histo3d_rgb
+
+* use/accu/stat/histo3d_hsl
+* tests/accu/stat/histo3d_hsl
+
+
+c) La visualisation des histogrammes 3d
+
+* demo/accu/stat/histo2d
+
+* mln/display/dispay_histo.hh
+* mln/displayproject_histo.hh
diff --git a/scribo/sandbox/green/mln/accu/stat/histo1d.hh b/scribo/sandbox/green/mln/accu/stat/histo1d.hh
new file mode 100644
index 0000000..d480cf0
--- /dev/null
+++ b/scribo/sandbox/green/mln/accu/stat/histo1d.hh
@@ -0,0 +1,340 @@
+// 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.
+
+#ifndef MLN_ACCU_STAT_HISTO1D_HH
+#define MLN_ACCU_STAT_HISTO1D_HH
+
+/// \file
+///
+/// \brief Define a histogram as accumulator which returns an image1d.
+///
+/// This source implements the discrete histogram version. It was
+/// created for images which the values are derived from integer
+/// type. The number of bins is directly infered from the cardinality
+/// of the image value. So the int_u8 image has got 256 bins, the
+/// int_u<14> image has got 16384 bins. But, this code doesn't work
+/// for that quantification because of the coord limitation (signed
+/// short, as it is defined in mln/core/def/coord.hh). Take care of
+/// the limitation from the result image value. We hard code unsigned,
+/// but it sometimes not enought to count data in one bin. That last
+/// case has not occured since the beginning of the creation of the type.
+///
+/// The following sample is a typical use of the histogram.
+///
+/// #include <mln/accu/stat/histo1d.hh>
+/// #include <mln/data/compute.hh>
+/// #include <mln/core/image/image1d.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;
+/// mln::image2d<t_int_u8> img;
+/// mln::image1d<unsigned> histo;
+///
+/// mln::io::pgm::load(img, OLENA_IMG_PATH"/lena.pgm");
+/// histo = mln::data::compute(mln::accu::meta::histo::histo1d(), img);
+///
+/// return 0;
+/// }
+
+
+#include <iostream>
+
+#include <mln/accu/internal/base.hh>
+
+#include <mln/arith/plus.hh>
+
+#include <mln/core/concept/meta_accumulator.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/macros.hh>
+
+#include <mln/literal/zero.hh>
+
+#include <mln/trace/entering.hh>
+#include <mln/trace/exiting.hh>
+
+#include <mln/trait/value/comp.hh>
+
+#include <mln/value/ops.hh>
+
+namespace mln
+{
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ // Forward declaration
+ template <typename V>
+ struct histo1d;
+
+ } // end of namespace mln::accu::stat
+
+
+ namespace meta
+ {
+
+ namespace stat
+ {
+
+ struct histo1d : public Meta_Accumulator<histo1d>
+ {
+ template <typename V>
+ struct with
+ {
+ typedef accu::stat::histo1d<V> ret;
+ };
+ };
+
+ } // end of namespace mln::accu::meta::stat
+
+ } // end of namespace mln::accu::meta
+
+ } // end of namespace mln::accu
+
+ namespace trait
+ {
+
+ template <typename V>
+ struct accumulator_< mln::accu::stat::histo1d<V> >
+ {
+ typedef accumulator::has_untake::no has_untake;
+ typedef accumulator::has_set_value::no has_set_value;
+ typedef accumulator::has_stop::no has_stop;
+ typedef accumulator::when_pix::use_v when_pix;
+ };
+
+ template <typename V>
+ struct set_precise_binary_<op::eq,
+ accu::stat::histo1d<V>,
+ accu::stat::histo1d<V> >
+ {
+ typedef bool ret;
+ };
+
+ } // end of namespace mln::trait
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ /// \brief Define a histogram as accumulator which returns an image1d.
+ ///
+ /// Param V defines the type of the input image value. It is in
+ /// this space that we count the values. For instance, this
+ /// histogram works well for image2d<int_u8> or with
+ /// image2d<int_u<14> >. The number of bins depends directly the
+ /// values V. For 8 bits there is 256 bins, for 14 bits there
+ /// is 16384 bins. Note that over quantification works too (up
+ /// to 14 bits).
+ ///
+ /// \ingroup modaccuvalues
+
+ template <typename V>
+ struct histo1d :
+ public mln::accu::internal::base<image1d<unsigned>, histo1d<V> >
+ {
+ typedef V argument;
+ typedef image1d<unsigned> result;
+ typedef result q_result;
+
+ /// Constructors
+ /// \{
+ /// \brief Infer the size of the resulting image1d domain.
+ ///
+ /// By evaluating the minimum and the maximum of V, we define the domain
+ /// of the resulting image1d.
+ histo1d();
+ /// \}
+
+
+ /// Manipulators.
+ /// \{
+ /// \brief Initialize the histogram with zero value.
+ ///
+ /// This method must be called just before starting the use of the
+ /// histogram. If it's not, resulting values won't converge to the
+ /// density.
+ void init();
+
+
+ /// \brief Update the histogram with the graylevel of the pixel t.
+ /// \param[in] t a graylevel pixel of type V.
+ ///
+ /// The end user shouldn't call this method. In place of it, he can
+ /// go through the data compute interface.
+ void take(const argument& t);
+
+
+ /// \brief Update the histogram with an other histogram.
+ /// \param[in] other the other histogram.
+ ///
+ /// The end user shouldn't call this method. This is part of
+ /// data compute interface mechanism.
+
+ void take(const histo1d<V>& other);
+ /// \}
+
+ /// Accessors.
+ /// \{
+ /// \brief Return the histogram as an image1d.
+ ///
+ /// This is the machinery to communicate with data compute interface.
+ /// The end user should'nt use it.
+ result to_result() const;
+ operator result () const;
+ /// \}
+
+ /// \brief Check whethever this accumulator is able to return a result.
+ ///
+ /// Depends if the resulting image1d is valid. We can assume it is quite
+ /// always the case.
+ bool is_valid() const;
+
+ protected:
+ result count_;
+ };
+
+ /// \brief Check wethever an histogram is equal to an other one.
+ /// \param[in] histo1 the first histogram to compare with.
+ /// \param[in] histo2 the second histogram.
+ ///
+ /// The operator compares all the bins from the two histograms.
+ /// Nobody uses this method unless unitary tests.
+
+ template <typename V>
+ bool operator==(const histo1d<V>& histo1, const histo1d<V>& histo2);
+
+#ifndef MLN_INCLUDE_ONLY
+
+ template <typename V>
+ inline
+ histo1d<V>::histo1d()
+ {
+ trace::entering("mln::accu::stat::histo1d::cstor");
+ typedef mln_trait_value_comp(V,0) comp;
+ typedef point<grid::tick, V> v_point1d;
+ typedef box<v_point1d> v_box1d;
+
+ // comp keep a trace of the dimension of the theorical image.
+ // mln_min(comp) --> 0
+ // mln_max(comp) --> 2^(n-1) [127 for n=7][255 for n=8] ...
+
+ count_.init_(box1d(point1d(mln_min(comp)),
+ point1d(mln_max(comp))));
+
+ // std::cout << "min : " << mln_min(comp) << std::endl;
+ // std::cout << "max : " << mln_max(comp) << std::endl;
+
+ trace::exiting("mln::accu::stat::histo1d::cstor");
+ }
+
+ template <typename V>
+ inline
+ void histo1d<V>::init()
+ {
+ data::fill(count_, literal::zero);
+ }
+
+ template <typename V>
+ inline
+ void histo1d<V>::take(const argument& t)
+ {
+ // Just convert a graylevel value (int_u8 like) to a position for an
+ // iterator on the resulting image.
+ ++count_(point1d(t));
+ }
+
+
+ template <typename V>
+ inline
+ void histo1d<V>::take(const histo1d<V>& other)
+ {
+ count_ += other.count_;
+ }
+
+ template <typename V>
+ inline
+ typename histo1d<V>::result histo1d<V>::to_result() const
+ {
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ histo1d<V>::operator result() const
+ {
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ bool histo1d<V>::is_valid() const
+ {
+ bool result = count_.is_valid();
+
+ return result;
+ }
+
+ template <typename V>
+ bool operator==(const histo1d<V>& histo1, const histo1d<V>& histo2)
+ {
+ trace::entering("mln::accu::stat::histo1d::operator==");
+
+ bool result = true;
+ const image1d<unsigned>& res1 = histo1.to_result();
+ const image1d<unsigned>& res2 = histo2.to_result();
+
+ mln_precondition(res1.is_valid());
+ mln_precondition(res2.is_valid());
+
+ mln_piter(image1d<unsigned>) p1(res1.domain());
+ mln_piter(image1d<unsigned>) p2(res2.domain());
+
+ for_all_2(p1, p2)
+ result &= (res1(p1) == res2(p2));
+
+ trace::exiting("mln::accu::stat::histo1d::operator==");
+ return result;
+ }
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::accu::stat
+
+ } // end of namespace mln::accu
+
+} // end of namespace mln
+
+#endif // ! MLN_ACCU_STAT_HISTO1D_HH
diff --git a/scribo/sandbox/green/mln/accu/stat/histo2d.hh b/scribo/sandbox/green/mln/accu/stat/histo2d.hh
new file mode 100644
index 0000000..c28723c
--- /dev/null
+++ b/scribo/sandbox/green/mln/accu/stat/histo2d.hh
@@ -0,0 +1,358 @@
+// 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.
+
+#ifndef MLN_ACCU_STAT_HISTO2D_HH
+# define MLN_ACCU_STAT_HISTO2D_HH
+
+/// \file
+///
+/// \brief Define a histogram as accumulator which returns an image2d.
+///
+/// This source implements the discrete histogram version. It was
+/// created for images which the values are derived from integer
+/// type. The number of bins is directly infered from the cardinality
+/// of the image value. It works with vectorial image, typically RGB
+/// space where only RG are preserved. See histo1d.hh for limitations
+/// of such implementation. 8 bits quantification starts to be
+/// expensive, it produces image2d with [0..255,0..255] as domain.
+///
+/// The following sample is a typical use of the histogram.
+///
+/// #include <mln/accu/stat/histo2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<unsigned> t_histo;
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+/// t_histo histo;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+/// histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+///
+/// return 0;
+/// }
+
+# include <iostream>
+
+# include <mln/accu/internal/base.hh>
+
+# include <mln/core/macros.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/alias/point2d.hh>
+# include <mln/core/alias/box2d.hh>
+
+# include <mln/trait/value/comp.hh>
+
+# include <mln/arith/plus.hh>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/value/ops.hh>
+
+namespace mln
+{
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ // Forward declaration
+ template <typename V>
+ struct histo2d;
+
+ } // end of namespace mln::accu::stat
+
+ namespace meta
+ {
+
+ namespace stat
+ {
+
+ struct histo2d : public Meta_Accumulator<histo2d>
+ {
+ template <typename V>
+ struct with
+ {
+ typedef accu::stat::histo2d<V> ret;
+ };
+ };
+
+ } // end of namespace mln::accu::meta::stat
+
+ } // end of namespace mln::accu::meta
+
+ } // end of namespace mln::accu
+
+
+ namespace trait
+ {
+
+ template <typename V>
+ struct accumulator_< mln::accu::stat::histo2d<V> >
+ {
+ typedef accumulator::has_untake::no has_untake;
+ typedef accumulator::has_set_value::no has_set_value;
+ typedef accumulator::has_stop::no has_stop;
+ typedef accumulator::when_pix::use_v when_pix;
+ };
+
+ template <typename V>
+ struct set_precise_binary_<op::eq,
+ accu::stat::histo2d<V>,
+ accu::stat::histo2d<V> >
+ {
+ typedef bool ret;
+ };
+
+ } // end of namespace mln::trait
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ /// \brief Define an histogram which returns an image3d .
+ ///
+ /// Param V defines the space in which we count the values.
+ /// For instance, this histogram works image2d<rgb<2>> or
+ /// image2d<rgb<7>>. The histogram count the occurrence of each value.
+ /// The number of bins depends of the grayscale values, for 8 bits there
+ /// is 256x3 bins. Note that over
+ /// quantification works too.
+ ///
+ /// \ingroup modaccuvalues
+
+ template <typename V>
+ struct histo2d :
+ public mln::accu::internal::base<image2d<unsigned>, histo2d<V> >
+ {
+ typedef V argument;
+ typedef image2d<unsigned> result;
+ typedef result q_result;
+
+ /// Constructors
+ /// \{
+ /// \brief Initialize the size of the resulting image1d.
+ ///
+ /// Initialize the size the resulting image from the theorical dynamic
+ /// of the greylevel values (Use V to manage it).
+ histo2d();
+ /// \}
+
+
+ /// Manipulators.
+ /// \{
+ /// \brief Initialize the histogram with zero value.
+ ///
+ /// This method must be called just before starting the use of the
+ /// histogram. If it's not, resulting values won't converge to the
+ /// density.
+ void init();
+
+
+ /// \brief Update the histogram with the RGB pixel t.
+ /// \param[in] t a greylevel pixel of type V.
+ ///
+ /// The end user shouldn't call this method. In place of it, he can
+ /// go through the data compute interface.
+ void take(const argument& t);
+
+
+ /// \brief Update the histogram with an other histogram.
+ /// \param[in] other the other histogram.
+ void take(const histo2d<V>& other);
+ /// \}
+
+ /// Accessors.
+ /// \{
+ /// \brief Return the histogram as an image1d.
+ ///
+ /// This is the machinery to communicate with data compute interface.
+ /// The end user should'nt use it.
+ result to_result() const;
+ operator result () const;
+ /// \}
+
+ /// \brief Check whethever this accumulator is able to return a result.
+ ///
+ /// Depends if the resulting image1d is valid. We can assume it is quite
+ /// always the case.
+ bool is_valid() const;
+
+ protected:
+ result count_;
+ };
+
+ /// \brief Check wethever an histogram is equal to an other one.
+ /// \param[in] histo1 the first histogram to compare with.
+ /// \param[in] histo2 the second histogram.
+ ///
+ /// The operator compare all the bins from the two histogram.
+
+ template <typename V>
+ bool operator==(const histo2d<V>& histo1,
+ const histo2d<V>& histo2);
+
+#ifndef MLN_INCLUDE_ONLY
+
+ template <typename V>
+ inline
+ histo2d<V>::histo2d()
+ {
+ trace::entering("mln::accu::stat::histo2d::histo2d");
+ typedef mln_trait_value_comp(V,0) comp0;
+ typedef mln_trait_value_comp(V,1) comp1;
+
+ // comp keep a trace of the dimension of the theorical image.
+ // mln_min(comp) --> 0
+ // mln_max(comp) --> 2^(n-1) [127 for n=7][255 for n=8] ...
+
+ count_.init_(box2d(point2d(mln_min(comp0),
+ mln_min(comp1)),
+ point2d(mln_max(comp0),
+ mln_max(comp1))));
+
+ trace::exiting("mln::accu::stat::histo2d::histo2d");
+ }
+
+ template <typename V>
+ inline
+ void histo2d<V>::init()
+ {
+ trace::entering("mln::accu::stat::histo2d::init");
+
+ data::fill(count_, 0);
+ trace::exiting("mln::accu::stat::histo2d::init");
+ }
+
+ template <typename V>
+ inline
+ void histo2d<V>::take(const argument& t)
+ {
+ trace::entering("mln::accu::stat::histo2d::take");
+
+ // Just convert a greyscale value (int_u8 like) to a position for an
+ // iterator on the resulting image.
+ // Take care to the constructor : Point(slice, row, column)
+ ++count_(point2d(t.red(), t.green()));
+
+ trace::exiting("mln::accu::stat::histo2d::take");
+ }
+
+
+ template <typename V>
+ inline
+ void histo2d<V>::take(const histo2d<V>& other)
+ {
+ trace::entering("mln::accu::stat::histo2d::take");
+
+ count_ += other.count_;
+
+ trace::exiting("mln::accu::stat::histo2d::take");
+ }
+
+ template <typename V>
+ inline
+ typename histo2d<V>::result histo2d<V>::to_result() const
+ {
+ trace::entering("mln::accu::stat::histo2d::to_result");
+
+ trace::exiting("mln::accu::stat::histo2d::to_result");
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ histo2d<V>::operator result() const
+ {
+ trace::entering("mln::accu::stat::histo2d::operator result");
+
+ trace::exiting("mln::accu::stat::histo2d::operator result");
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ bool histo2d<V>::is_valid() const
+ {
+ trace::entering("mln::accu::stat::histo2d::is_valid");
+ bool result = count_.is_valid();
+
+ trace::exiting("mln::accu::stat::histo2d::is_valid");
+ return result;
+ }
+
+ template <typename V>
+ bool operator==(const histo2d<V>& histo1,
+ const histo2d<V>& histo2)
+ {
+ trace::entering("mln::accu::stat::operator==");
+
+ bool result = true;
+ const image2d<unsigned>& res1 = histo1.to_result();
+ const image2d<unsigned>& res2 = histo2.to_result();
+
+ mln_precondition(res1.is_valid());
+ mln_precondition(res2.is_valid());
+
+ mln_piter(image2d<unsigned>) p1(res1.domain());
+ mln_piter(image2d<unsigned>) p2(res2.domain());
+
+ for_all_2(p1, p2)
+ result &= (res1(p1) == res2(p2));
+
+ trace::exiting("mln::accu::stat::operator==");
+ return result;
+ }
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::accu::stat
+
+ } // end of namespace mln::accu
+
+} // end of namespace mln
+
+#endif // ! MLN_ACCU_STAT_HISTO2D_HH
diff --git a/milena/sandbox/green/mln/accu/stat/histo3d_hsl.hh b/scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
similarity index 100%
copy from milena/sandbox/green/mln/accu/stat/histo3d_hsl.hh
copy to scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
diff --git a/milena/sandbox/green/mln/accu/stat/histo3d_rgb.hh b/scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
similarity index 100%
copy from milena/sandbox/green/mln/accu/stat/histo3d_rgb.hh
copy to scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
diff --git a/milena/sandbox/green/mln/clustering/k_mean.hh b/scribo/sandbox/green/mln/clustering/k_mean.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/k_mean.hh
copy to scribo/sandbox/green/mln/clustering/k_mean.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean1d.hh b/scribo/sandbox/green/mln/clustering/kmean1d.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean1d.hh
copy to scribo/sandbox/green/mln/clustering/kmean1d.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean2d.hh b/scribo/sandbox/green/mln/clustering/kmean2d.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean2d.hh
copy to scribo/sandbox/green/mln/clustering/kmean2d.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean3d.hh b/scribo/sandbox/green/mln/clustering/kmean3d.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean3d.hh
copy to scribo/sandbox/green/mln/clustering/kmean3d.hh
diff --git a/scribo/sandbox/green/mln/clustering/kmean_rgb.hh b/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
new file mode 100644
index 0000000..253745b
--- /dev/null
+++ b/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
@@ -0,0 +1,973 @@
+// Copyright (C) 2008,2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_CLUSTERING_KMEAN_RGB_HH
+# define MLN_CLUSTERING_KMEAN_RGB_HH
+
+/// \file
+///
+/// \brief Implements the optimized kmean algorithm.
+///
+/// This algorithm is optimized in the way it proceeds directly with
+/// the rgb values 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
+
+# include <limits.h>
+# include <iostream>
+
+# include <mln/accu/stat/histo3d_rgb.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/data/transform.hh>
+
+# include <mln/debug/println.hh>
+
+# include <mln/io/ppm/save.hh>
+# include <mln/io/pgm/save.hh>
+
+# include <mln/labeling/colorize.hh>
+# include <mln/labeling/mean_values.hh>
+
+# include <mln/literal/zero.hh>
+# include <mln/literal/one.hh>
+
+# include <mln/math/min.hh>
+# include <mln/math/sqr.hh>
+
+# include <mln/norm/l2.hh>
+
+# include <mln/opt/at.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/label_8.hh>
+
+
+//--------------------------------------------------------------------------
+// CODE APLATI
+//--------------------------------------------------------------------------
+
+
+namespace mln
+{
+
+ namespace clustering
+ {
+
+ template <typename T, unsigned n, typename I>
+ inline
+ image2d<value::label_8>
+ kmean_rgb(const Image<I>& point,
+ const unsigned k_center,
+ const unsigned watch_dog,
+ const unsigned n_times);
+
+ } // end of namespace mln::clustering
+
+ namespace clustering
+ {
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ //--------------------------------------------------------------------------
+ // Internal.
+ //--------------------------------------------------------------------------
+
+ namespace internal
+ {
+
+ //------------------------------------------------------------------------
+ // Debugging tools
+ //------------------------------------------------------------------------
+
+ /*
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::build_label_dbg()
+ {
+ trace::entering("mln::clustering::kmean3d_a::build_label_dbg");
+
+ mln_piter(t_point_img) pi(_point.domain());
+ mln_piter(t_label_dbg) po(_label_dbg.domain());
+
+ for_all_2(pi, po)
+ {
+ t_value val = _point(pi);
+ t_label grp = _group(point3d(val.blue(), val.red(), val.green()));
+
+ // As label zero has got a particular semantic, the first label is one
+ _label_dbg(po) = ++grp;
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::build_label_dbg");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::build_mean_dbg()
+ {
+ trace::entering("mln::clustering::kmean3d_a::build_mean_dbg");
+
+ mln_piter(t_mean_dbg) p(_mean_dbg.domain());
+
+ for_all(p)
+ {
+ _mean_dbg(p).red() = static_cast<unsigned>(_mean[_label_dbg(p)][0]);
+ _mean_dbg(p).green() = static_cast<unsigned>(_mean[_label_dbg(p)][1]);
+ _mean_dbg(p).blue() = static_cast<unsigned>(_mean[_label_dbg(p)][2]);
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::build_mean_dbg");
+ }
+
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::build_all_dbg()
+ {
+ trace::entering("mln::clustering::kmean3d_a::build_all_dbg");
+ build_label_dbg();
+ //build_mean_dbg();
+ _mean_dbg = labeling::mean_values(_point, _label_dbg, _k_center);
+ _color_dbg = labeling::colorize(value::rgb8(), _label_dbg);
+
+ trace::exiting("mln::clustering::kmean3d_a::build_all_dbg");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::update_cnv()
+ {
+ trace::entering("mln::clustering::kmean3d_a::update_cnv");
+
+ _variance_cnv[_current_launching](point1d(_current_step))
+ = _within_variance;
+
+ mln_eiter(t_mean_img) l(_mean);
+
+ for_all(l)
+ {
+ _mean_cnv[l.index_()][_current_launching](point1d(_current_step))
+ = _mean[l.index_()];
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::update_cnv");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::finalize_cnv()
+ {
+ trace::entering("mln::clustering::kmean3d_a::finalize_cnv");
+
+ // saturate the curv with the within variance
+ for (unsigned i = _current_step; i < _watch_dog; ++i)
+ _variance_cnv[_current_launching](point1d(i)) = _within_variance;
+
+ for (unsigned i = _current_step; i < _watch_dog; ++i)
+ {
+ mln_eiter(t_mean_img) l(_mean);
+
+ for_all(l)
+ {
+ _mean_cnv[l.index_()][_current_launching](point1d(i))
+ = _mean[l.index_()];
+ }
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::finalize_cnv");
+ }
+
+
+
+
+ //--------------------------------------------------------------------------
+ // Printing temporary results
+ //--------------------------------------------------------------------------
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_mean()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_mean");
+
+ mln_eiter(t_mean_img) l(_mean);
+
+ for_all(l)
+ {
+ std::cout << "mean(" << l.index_();
+ std::cout << ") = [r=" << _mean[l.index_()][0];
+ std::cout << ", g=" << _mean[l.index_()][1];
+ std::cout << ", b=" << _mean[l.index_()][2];
+ std::cout << "]" << std::endl;
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_mean");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_number()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_number");
+
+ mln_eiter(t_number_img) l(_number);
+
+ for_all(l)
+ {
+ std::cout << "number(" << l.index_();
+ std::cout << ") = " << _number[l.index_()];
+ std::cout << std::endl;
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_number");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_variance()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_variance");
+
+ mln_eiter(t_variance_img) l(_number);
+
+ for_all(l)
+ {
+ std::cout << "variance(" << l.index_();
+ std::cout << ") = " << _variance[l.index_()];
+ std::cout << std::endl;
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_variance");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_histo()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_histo");
+
+ mln_piter(t_histo_img) rgb(_histo.domain());
+
+ for_all(rgb)
+ {
+ if (0 < _histo(rgb))
+ {
+ std::cout << "histo(r=" << rgb.row();
+ std::cout << ", g=" << rgb.col();
+ std::cout << ", b=" << rgb.sli();
+ std::cout << ")= " << _histo(rgb);
+ std::cout << std::endl;
+ }
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_histo");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_group()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_group");
+
+ mln_piter(t_group_img) rgb(_group.domain());
+
+ for_all(rgb)
+ {
+ if (0 < _histo(rgb))
+ {
+ std::cout << "group(r=" << rgb.row();
+ std::cout << ", g=" << rgb.col();
+ std::cout << ", b=" << rgb.sli();
+ std::cout << ")= " << _group(rgb);
+ std::cout << std::endl;
+ }
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_group");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_distance()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_distance");
+
+ mln_eiter(t_distance_img) l(_distance);
+
+ for_all(l)
+ {
+ mln_piter(t_distance_val) rgb(_distance[l.index_()].domain());
+
+ for_all(rgb)
+ {
+ if (0 < _histo(rgb))
+ {
+ std::cout << "distance(l=" << l.index_();
+ std::cout << ",r=" << rgb.row();
+ std::cout << ", g=" << rgb.col();
+ std::cout << ", b=" << rgb.sli();
+ std::cout << ")= " << _distance[l.index_()](rgb);
+ std::cout << std::endl;
+ }
+ }
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_distance");
+ }
+
+ template <typename T, unsigned n>
+ inline
+ void kmean3d_a<T,n>::print_point()
+ {
+ trace::entering("mln::clustering::kmean3d_a::print_point");
+
+ mln_piter(t_point_img) p(_point.domain());
+
+ for_all(p)
+ {
+ std::cout << "point(r=" << p.row();
+ std::cout << ", c=" << p.col();
+ std::cout << ")= " << _point(p);
+ std::cout << std::endl;
+ }
+
+ trace::exiting("mln::clustering::kmean3d_a::print_point");
+ }
+
+
+
+ template <typename T, unsigned n>
+ inline
+ void rgb_rand_init(t_mean_img mean)
+ {
+ typedef value::rgb<n> t_value;
+ typedef mln_trait_value_comp(t_value,0) t_value_comp0;
+ typedef mln_trait_value_comp(t_value,1) t_value_comp1;
+ typedef mln_trait_value_comp(t_value,2) t_value_comp2;
+ typedef algebra::vec<3,T> t_result3d;
+ typedef util::array<t_result3d> t_mean_img;
+
+ t_value_comp0 min_comp0 = mln_min(t_value_comp0);
+ t_value_comp0 max_comp0 = mln_max(t_value_comp0);
+ t_value_comp1 min_comp1 = mln_min(t_value_comp1);
+ t_value_comp1 max_comp1 = mln_max(t_value_comp1);
+ t_value_comp2 min_comp2 = mln_min(t_value_comp2);
+ t_value_comp2 max_comp2 = mln_max(t_value_comp2);
+ mln_eiter(t_mean_img) l(mean);
+
+ for_all(l)
+ {
+ mean[l.index_()][0] = (rand() % (max_comp0 - min_comp0)) + min_comp0;
+ mean[l.index_()][1] = (rand() % (max_comp1 - min_comp1)) + min_comp1;
+ mean[l.index_()][2] = (rand() % (max_comp2 - min_comp2)) + min_comp2;
+ }
+
+ return mean;
+ }
+
+ */
+
+ } // end of namespace mln::clustering::internal
+
+
+ //--------------------------------------------------------------------------
+ // Impl.
+ //--------------------------------------------------------------------------
+
+ namespace impl
+ {
+
+ //------------------------------------------------------------------------
+ // kmean_image2d_rgb(const t_point_img& point,
+ // const unsigned k_center,
+ // const unsigned watch_dog = 10,
+ // const unsigned n_times = 10)
+ //------------------------------------------------------------------------
+
+ template <unsigned n>
+ struct rgbn_to_lbl8 : Function_v2v< rgbn_to_lbl8<n> >
+ {
+ typedef value::rgb<n> argument;
+ typedef value::label_8 result;
+ typedef value::label_8 t_label;
+ typedef image3d<t_label> t_group_img;
+
+ t_group_img _group;
+
+ rgbn_to_lbl8(t_group_img group) : _group(group) {}
+
+ result operator()(const argument& c) const
+ {
+ value::label_8 tmp = opt::at(_group, c.blue(), c.red(), c.green());
+
+ // FIXME WHY DO WE NOT USE +1
+ return ++tmp;
+ }
+ };
+
+ template <typename T, unsigned n>
+ struct rgb_to_dist : Function_v2v< rgb_to_dist<T,n> >
+ {
+ typedef value::rgb<n> argument;
+ typedef T result;
+ typedef T t_result1d;
+ typedef algebra::vec<3,T> t_result3d;
+ typedef image3d<unsigned> t_histo_img;
+
+ t_result3d _mean;
+ t_histo_img _histo;
+
+ rgb_to_dist(t_result3d mean, t_histo_img histo) : _mean(mean),
+ _histo(histo) {}
+
+ result operator()(const argument& c) const
+ {
+ t_result1d diff2_row = math::sqr(c.row() - _mean[0]);
+ t_result1d diff2_col = math::sqr(c.col() - _mean[1]);
+ t_result1d diff2_sli = math::sqr(c.sli() - _mean[2]);
+ t_result1d tmp = _histo(c)*(diff2_row + diff2_col + diff2_sli);
+
+ return tmp;
+ }
+ };
+
+ template <typename T, unsigned n>
+ inline
+ image2d<value::label_8>
+ kmean_image2d_rgb(const image2d< value::rgb<n> >& point,
+ const unsigned k_center,
+ const unsigned watch_dog = 10,
+ const unsigned n_times = 10)
+ {
+ trace::entering("mln::clustering::impl::kmean_image2d_rgb");
+ trace::quiet = true;
+ // BEGIN TYPEDEF
+ typedef value::rgb<8> t_rgb;
+ typedef value::label<8> t_label;
+ typedef value::rgb<n> t_value;
+ typedef mln_trait_value_comp(t_value,0) t_value_comp0;
+ typedef mln_trait_value_comp(t_value,1) t_value_comp1;
+ typedef mln_trait_value_comp(t_value,2) t_value_comp2;
+ typedef T t_result1d;
+ typedef algebra::vec<3,T> t_result3d;
+
+ typedef image2d<t_value> t_point_img;
+ typedef image3d<unsigned> t_histo_img;
+ typedef util::array<t_result1d> t_number_img;
+ typedef util::array<t_result3d> t_mean_img;
+ typedef util::array<t_result1d> t_variance_img;
+
+ typedef image3d<t_label> t_group_img;
+ typedef image3d<t_result1d> t_distance_val;
+ typedef util::array<t_distance_val> t_distance_img;
+
+ typedef image2d<t_label> t_label_dbg;
+ typedef image2d<t_rgb> t_color_dbg;
+ typedef image2d<t_value> t_mean_dbg;
+
+ typedef image1d<t_result3d> t_mean_val;
+ typedef util::array<t_mean_val> t_mean_set;
+ 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;
+ // END TYPEDEF
+
+ // BEGIN INITIALISATION
+ mln_precondition(point.is_valid());
+
+ static const unsigned _N_TRIES = 3;
+
+ typedef accu::meta::stat::histo3d_rgb t_histo3d_rgb;
+
+ t_result1d _within_variance;
+
+ unsigned _k_center = k_center;
+ unsigned _watch_dog = watch_dog;
+ unsigned _n_times = n_times;
+ t_point_img _point = point;
+
+ // HISTOGRAM INIT
+ t_histo_img _histo = data::compute(t_histo3d_rgb(),
+ _point);
+
+ // CENTER STATS INIT
+ t_number_img _number;
+ t_mean_img _mean;
+ t_variance_img _variance;
+
+ for (unsigned i = 0; i < _k_center; ++i)
+ {
+ _number.append(literal::zero);
+ _mean.append(literal::zero);
+ _variance.append(literal::zero);
+ }
+
+
+ unsigned _current_step = 0;
+ unsigned _current_launching = 0;
+ bool _is_number_valid = false;
+
+ unsigned _launching_min;
+ t_result1d _variance_min;
+ t_mean_img _mean_min;
+
+
+
+ t_group_img _group;
+ t_distance_img _distance;
+
+
+ t_label_dbg _label_dbg;
+ t_color_dbg _color_dbg;
+ t_mean_dbg _mean_dbg;
+
+
+ t_mean_cnv _mean_cnv;
+ t_variance_cnv _variance_cnv;
+
+
+
+
+ _group.init_(box3d(point3d(mln_min(t_value_comp2),
+ mln_min(t_value_comp0),
+ mln_min(t_value_comp1)),
+ point3d(mln_max(t_value_comp2),
+ mln_max(t_value_comp0),
+ mln_max(t_value_comp1))));
+
+ for (unsigned i = 0; i < _k_center; ++i)
+ {
+ t_distance_val img(box3d(point3d(mln_min(t_value_comp2),
+ mln_min(t_value_comp0),
+ mln_min(t_value_comp1)),
+ point3d(mln_max(t_value_comp2),
+ mln_max(t_value_comp0),
+ mln_max(t_value_comp1))));
+
+ _distance.append(img);
+ }
+
+ // Debugging, calibrating and testing
+ initialize(_label_dbg, _point);
+ initialize(_color_dbg, _point);
+ initialize(_mean_dbg, _point);
+
+ // Observing the convergence
+
+ for (unsigned i = 0; i < _n_times; ++i)
+ {
+ t_variance_val img(box1d(point1d(0), point1d(_watch_dog-1)));
+
+ data::fill(img, literal::zero);
+
+ _variance_cnv.append(img);
+ }
+
+ for (unsigned i = 0; i < _k_center; ++i)
+ {
+ t_mean_set mean_set;
+
+ for (unsigned j = 0; j < _n_times; ++j)
+ {
+ t_mean_val img(box1d(point1d(0), point1d(_watch_dog-1)));
+
+ data::fill(img, literal::zero);
+
+ mean_set.append(img);
+ }
+
+ _mean_cnv.append(mean_set);
+ }
+ // END INITIALISATION
+
+ // BEGIN LOOP N TIMES
+ {
+ unsigned tries = 0;
+ _variance_min = mln_max(t_result1d);
+ _current_launching = 0;
+
+ while (_current_launching < _n_times)
+ {
+ // BEGIN LAUNCH ONE TIME
+ trace::quiet = false;
+ trace::entering("Launch one time");
+ trace::quiet = true;
+ {
+ t_result1d old_variance = mln_max(t_result1d);
+ _within_variance = mln_max(t_result1d);
+ _current_step = 0;
+
+ // BEGIN INIT_MEAN
+ trace::quiet = false;
+ trace::entering("init mean");
+ trace::quiet = true;
+ {
+ t_value_comp0 min_comp0 = mln_min(t_value_comp0);
+ t_value_comp0 max_comp0 = mln_max(t_value_comp0);
+ t_value_comp1 min_comp1 = mln_min(t_value_comp1);
+ t_value_comp1 max_comp1 = mln_max(t_value_comp1);
+ t_value_comp2 min_comp2 = mln_min(t_value_comp2);
+ t_value_comp2 max_comp2 = mln_max(t_value_comp2);
+ mln_eiter(t_mean_img) l(_mean);
+
+ for_all(l)
+ {
+ _mean[l.index_()][0]=(rand()%(max_comp0-min_comp0))+min_comp0;
+ _mean[l.index_()][1]=(rand()%(max_comp1-min_comp1))+min_comp1;
+ _mean[l.index_()][2]=(rand()%(max_comp2-min_comp2))+min_comp2;
+ }
+ }
+ trace::quiet = false;
+ trace::exiting("init mean");
+ trace::quiet = true;
+ // END INIT MEAN
+
+
+ // UPDATE DISTANCE
+ trace::quiet = false;
+ trace::entering("update distance");
+ trace::quiet = true;
+
+ for (unsigned i = 0; i < _k_center; ++i)
+ {
+
+ // _distance[i] = data::transform(_histo,
+ // rgb_to_dist<T,n>(_mean[i],
+ // _histo));
+
+ mln_piter(t_distance_val) d(_distance[i].domain());
+
+ for_all(d)
+ {
+ t_result1d diff2_row = math::sqr(d.row() - _mean[i][0]);
+ t_result1d diff2_col = math::sqr(d.col() - _mean[i][1]);
+ t_result1d diff2_sli = math::sqr(d.sli() - _mean[i][2]);
+ _distance[i](d) = _histo(d)*
+ (diff2_row + diff2_col + diff2_sli);
+ }
+ }
+
+ trace::quiet = false;
+ trace::exiting("update distance");
+ trace::quiet = true;
+ // END UPDATE DISTANCE
+
+ do
+ {
+ old_variance = _within_variance;
+
+ // BEGIN UPDATE GROUP
+ trace::quiet = false;
+ trace::entering("update group");
+ trace::quiet = true;
+ {
+ mln_piter(t_group_img) rgb(_group.domain());
+
+ for_all(rgb)
+ {
+ mln_eiter(t_distance_img) l(_distance);
+ t_result1d min = mln_max(t_result1d);
+ t_label label = mln_max(t_label);
+
+ for_all(l)
+ {
+ if (min > _distance[l.index_()](rgb))
+ {
+ min = _distance[l.index_()](rgb);
+ label = l.index_();
+ }
+ }
+
+ _group(rgb) = label;
+ }
+
+ }
+ trace::quiet = false;
+ trace::exiting("update group");
+ trace::quiet = true;
+ // END UPDATE GROUP
+
+ // BEGIN UPDATE MEAN
+ trace::quiet = false;
+ trace::entering("update mean");
+ trace::quiet = true;
+ {
+ mln_eiter(t_number_img) en(_number);
+ mln_eiter(t_mean_img) em(_mean);
+
+ for_all_2(en,em)
+ {
+ _number[en.index_()] = literal::zero;
+ _mean[em.index_()] = literal::zero;
+ }
+
+ mln_piter(t_group_img) rgb(_group.domain());
+
+ for_all(rgb)
+ {
+ _mean[_group(rgb)][0] += rgb.row() * _histo(rgb);
+ _mean[_group(rgb)][1] += rgb.col() * _histo(rgb);
+ _mean[_group(rgb)][2] += rgb.sli() * _histo(rgb);
+ _number(_group(rgb)) += _histo(rgb);
+ }
+
+ mln_eiter(t_mean_img) l(_mean);
+
+ for_all(l)
+ {
+ _is_number_valid = (0 != _number[l.index_()]);
+
+ if (!_is_number_valid)
+ break;
+
+ _mean[l.index_()] /= _number[l.index_()];
+ }
+ }
+ trace::quiet = false;
+ trace::exiting("update mean");
+ trace::quiet = true;
+ // END UPDATE MEAN
+
+
+ // Stopping Nan propagation
+ if (!_is_number_valid)
+ break;
+
+ // UPDATE DISTANCE
+ trace::quiet = false;
+ trace::entering("update distance");
+ trace::quiet = true;
+
+ for (unsigned i = 0; i < _k_center; ++i)
+ {
+ mln_piter(t_distance_val) d(_distance[i].domain());
+
+ for_all(d)
+ {
+ // the square distance
+ t_result1d diff2_row = math::sqr(d.row() - _mean[i][0]);
+ t_result1d diff2_col = math::sqr(d.col() - _mean[i][1]);
+ t_result1d diff2_sli = math::sqr(d.sli() - _mean[i][2]);
+ _distance[i](d) = _histo(d)*
+ (diff2_row + diff2_col + diff2_sli);
+ }
+ }
+ trace::quiet = false;
+ trace::exiting("update distance");
+ trace::quiet = true;
+ // END UPDATE DISTANCE
+
+ // BEGIN UPDATE VARIANCE
+ trace::quiet = false;
+ trace::entering("update variance");
+ trace::quiet = true;
+ {
+ _within_variance = literal::zero;
+ mln_eiter(t_variance_img) l(_variance);
+
+ for_all(l)
+ {
+ _variance[l.index_()] = literal::zero;
+
+ mln_piter(t_group_img) rgb(_group.domain());
+
+ for_all(rgb)
+ {
+ if (l.index_() == _group(rgb))
+ _variance[l.index_()] += _distance[l.index_()](rgb);
+ }
+
+ _within_variance += _variance[l.index_()];
+ }
+
+ }
+ trace::quiet = false;
+ trace::exiting("update variance");
+ trace::quiet = true;
+ // END UPDATE VARIANCE
+
+ //update_cnv();
+
+ ++_current_step;
+ }
+ while (_current_step < _watch_dog &&
+ _within_variance < old_variance);
+
+ //finalize_cnv();
+ //build_all_dbg();
+ }
+ trace::quiet = false;
+ trace::exiting("Launch one time");
+ trace::quiet = true;
+ // END LAUNCH ONE TIME
+
+ if ((_is_number_valid && (_current_step < _watch_dog))||
+ _N_TRIES < tries)
+ {
+ if (_within_variance < _variance_min)
+ {
+ _variance_min = _within_variance;
+ _mean_min = _mean;
+ _launching_min = _current_launching;
+ }
+
+ // Reinitialize the number of echecs possible
+ tries = 0;
+
+ //std::cout << "_current_launching : " << _current_launching
+ // << std::endl;
+
+ //std::cout << "within_variance[" << _current_launching << "] = "
+ // << _within_variance << std::endl;
+
+ ++_current_launching;
+ }
+ else
+ ++tries;
+ }
+
+ //Debugging code
+ //build_all_dbg();
+
+ }
+ // END LOOP N TIMES
+
+ // BEGIN BUILD LABEL IMAGE
+ _label_dbg = data::transform(_point, rgbn_to_lbl8<n>(_group));
+
+// {
+// mln_piter(t_point_img) pi(_point.domain());
+// mln_piter(t_label_dbg) po(_label_dbg.domain());
+
+// for_all_2(pi, po)
+// {
+// t_value val = _point(pi);
+// t_label grp = _group(point3d(val.blue(),val.red(),val.green()));
+
+// _label_dbg(po) = ++grp;
+// }
+// }
+
+ // END BUILD LABEL IMAGE
+ trace::quiet = false;
+ trace::exiting("mln::clustering::impl::kmean_image2d_rgb");
+
+ return _label_dbg;
+
+ }
+
+ } // end of namespace mln::clustering::impl
+
+
+
+
+
+ //--------------------------------------------------------------------------
+ // Internal.
+ //--------------------------------------------------------------------------
+
+ namespace internal
+ {
+
+ template <typename T, unsigned n>
+ inline
+ image2d<value::label_8>
+ kmean_rgb_dispatch(const image2d< value::rgb<n> >& img,
+ const unsigned k_center,
+ const unsigned watch_dog,
+ const unsigned n_times)
+ {
+ return impl::kmean_image2d_rgb<T,n>(img, k_center, watch_dog, n_times);
+ }
+
+
+ template <typename T, unsigned n, typename I>
+ inline
+ image2d< value::label_8>
+ kmean_rgb_dispatch(const Image<I>& img,
+ const unsigned k_center,
+ const unsigned watch_dog,
+ const unsigned n_times)
+ {
+ return kmean_rgb_dispatch<T,n>(exact(img),k_center,watch_dog,n_times);
+ }
+
+
+ } // end of namespace mln::clustering::internal
+
+
+ //--------------------------------------------------------------------------
+ // Facade.
+ //--------------------------------------------------------------------------
+
+ template <typename T, unsigned n, typename I>
+ inline
+ image2d<value::label_8>
+ kmean_rgb(const Image<I>& point,
+ const unsigned k_center,
+ const unsigned watch_dog,
+ const unsigned n_times)
+ {
+ trace::entering("mln::clustering::kmean_rgb");
+
+ image2d<value::label_8> tmp = internal::kmean_rgb_dispatch<T,n>(point,
+ k_center,
+ watch_dog,
+ n_times);
+ trace::exiting("mln::clustering::kmean_rgb");
+
+ return tmp;
+ }
+
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::clustering
+
+} // end of namespace mln
+
+#endif // ! MLN_CLUSTERING_KMEAN_RGB_HH
diff --git a/scribo/sandbox/green/mln/display/display_histo.hh b/scribo/sandbox/green/mln/display/display_histo.hh
new file mode 100644
index 0000000..ef47182
--- /dev/null
+++ b/scribo/sandbox/green/mln/display/display_histo.hh
@@ -0,0 +1,180 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_DISPLAY_DISPLAY_HISTO_HH
+# define MLN_DISPLAY_DISPLAY_HISTO_HH
+
+# include <mln/accu/math/sum.hh>
+# include <mln/algebra/vec.hh>
+# include <mln/data/stretch.hh>
+# include <mln/display/project_histo.hh>
+# include <mln/fun/v2v/log.hh>
+# include <mln/value/int_u8.hh>
+# include <mln/value/rgb8.hh>
+# include <mln/value/label_8.hh>
+# include <mln/util/array.hh>
+
+
+/// \file
+///
+/// \brief Allow the complete visualization of a 3d histogram by projection.
+///
+/// The 3d histogram is projected in red/green space by accumulating around the
+/// the blue dimension (green and blue composantes are being correlated). In
+/// fact, we sum in along the blue direction. Then, we stretch value to feet
+/// pgm format.
+
+
+namespace mln
+{
+
+ namespace display
+ {
+
+ // Forward declaration.
+ image2d<value::int_u8>
+ display_histo3d_unsigned(const image3d<unsigned>& histo);
+
+ template <unsigned n>
+ image2d< value::int_u<n> >
+ display2_histo3d_unsigned(const image3d<unsigned>& histo,
+ const value::int_u<n> ambiguous_color);
+
+ template <unsigned n>
+ image2d<value::label_8>
+ display2_histo3d_unsigned(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const value::label_8 ambiguous_label);
+
+ template <unsigned n>
+ image2d< value::rgb<n> >
+ display3_histo3d_unsigned(const image3d<unsigned>& histo,
+ const value::rgb<n> ambiguous_color);
+
+ template <unsigned n>
+ image2d< value::rgb8 >
+ display3_histo3d_unsigned(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const util::array< algebra::vec<3,float> >& pal,
+ const value::rgb8 ambiguous_color);
+
+#ifndef MLN_INCLUDE_ONLY
+
+ /// \brief Allow the visualization of a 3d histogram by projection.
+ ///
+ /// The 3d histogram is projected in red/green space by
+ /// accumulating around the the blue dimension (green and blue
+ /// composantes are being correlated). In fact, we sum along
+ /// the blue direction. Then, we stretch value to feet pgm
+ /// format.
+ /// Direction r = 1
+ /// Direction g = 2
+ /// Direction b = 0
+ ///
+ /// \parameter[in] histo the histogram in 3d.
+ /// \result return a equivalent 2d image.
+
+ // FIXME : display_shape [in int_u8]
+ image2d<value::int_u8>
+ display_histo3d_unsigned(const image3d<unsigned>& histo)
+ {
+ typedef accu::math::sum<unsigned,unsigned> t_sum;
+ typedef value::int_u8 t_int_u8;
+ typedef fun::v2v::log<float> t_log;
+
+ image2d<unsigned> proj = project_histo<t_sum,0>(histo);
+ image2d<t_int_u8> proj_int = data::stretch(t_int_u8(),
+ data::transform(proj,
+ t_log()));
+ return proj_int;
+ }
+
+ // FIXME : display_color [in int_un]
+ template <unsigned n>
+ image2d< value::int_u<n> >
+ display2_histo3d_unsigned(const image3d<unsigned>& histo,
+ const value::int_u<n> ambiguous_color)
+ {
+ image2d< value::int_u<n> > proj = project2_histo<n,0>(histo,
+ ambiguous_color);
+
+ return proj;
+ }
+
+ // FIXME : display_label [in label]
+ template <unsigned n>
+ image2d<value::label_8>
+ display2_histo3d_unsigned(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const value::label_8 ambiguous_label)
+ {
+ image2d<value::label_8> proj = project2_histo<n,0>(histo,
+ label,
+ ambiguous_label);
+
+ return proj;
+ }
+
+ // FIXME : display_color [in color]
+ template <unsigned n>
+ image2d< value::rgb<n> >
+ display3_histo3d_unsigned(const image3d<unsigned>& histo,
+ const value::rgb<n> ambiguous_color)
+ {
+ image2d< value::rgb<n> > proj = project3_histo<n,0>(histo,
+ ambiguous_color);
+
+ return proj;
+ }
+
+
+ // FIXME : display_label [in color]
+ template <unsigned n>
+ image2d< value::rgb8 >
+ display3_histo3d_unsigned(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const util::array<algebra::vec<3,float> >& pal,
+ const value::rgb8 ambiguous_color)
+ {
+ image2d< value::rgb8 > proj = project3_histo<n,0>(histo,
+ label,
+ pal,
+ ambiguous_color);
+
+ return proj;
+ }
+
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::transform
+
+} // end of namespace mln
+
+
+#endif // ! MLN_DISPLAY_DISPLAY_HISTO_HH
diff --git a/scribo/sandbox/green/mln/display/project_histo.hh b/scribo/sandbox/green/mln/display/project_histo.hh
new file mode 100644
index 0000000..30bcd6d
--- /dev/null
+++ b/scribo/sandbox/green/mln/display/project_histo.hh
@@ -0,0 +1,536 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_DISPLAY_PROJECT_HISTO_HH
+# define MLN_DISPLAY_PROJECT_HISTO_HH
+
+# include <mln/core/image/image2d.hh>
+# include <mln/core/image/image3d.hh>
+# include <mln/core/image/dmorph/unproject_image.hh>
+# include <mln/fun/v2v/projection.hh>
+
+# include <mln/accu/image/init.hh>
+# include <mln/accu/image/take.hh>
+# include <mln/accu/image/to_result.hh>
+
+# include <mln/algebra/vec.hh>
+
+# include <mln/opt/at.hh>
+
+# include <mln/value/int_u8.hh>
+# include <mln/value/rgb8.hh>
+# include <mln/value/label_8.hh>
+
+# include <mln/util/array.hh>
+
+/// \file
+///
+/// \brief Allow the visualization of 3d histogram.
+/// The 3d histogram is projected in 2d such as the data in that direction
+/// are accumulated to the two others.
+
+namespace mln
+{
+
+ namespace display
+ {
+
+ // Forward declaration.
+ template <typename A, unsigned direction, typename V>
+ image2d<mln_result(A)>
+ project_histo(const image3d<V>& histo);
+
+ template <typename A, unsigned n, unsigned direction, typename V>
+ image2d<mln_result(A)>
+ project2_histo(const image3d<V>& histo,
+ const value::int_u<n>& ambiguous_color);
+
+ template <unsigned n, unsigned direction, typename V>
+ image2d<V>
+ project2_histo(const image3d<unsigned>& histo,
+ const image3d<V>& label);
+
+ template <unsigned n, unsigned direction>
+ image2d< value::rgb<n> >
+ project3_histo(const image3d<unsigned>& histo,
+ const value::rgb<n> ambiguous_color);
+
+ template <unsigned n, unsigned direction>
+ image2d< value::rgb8 >
+ project3_histo(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const util::array<algebra::vec<3, float> >& pal,
+ const value::rgb8 ambiguous_color);
+ // FIXME ==> palette must be 1d-image not an array !!
+
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ /// \brief Allow the visualization of 3d histogram.
+ ///
+ /// The 3d histogram is projected in 2d such as the data in that direction
+ /// are accumulated to the two others.
+ ///
+ /// Parameter A is the type of accumulator, for instance, accu::math::sum.
+ /// Parameter direction is the way of the projection, for instance blue one.
+ /// Parameter V is the value we use to accumulate information.
+ ///
+ /// \prameter[in] the histogram 3d.
+ /// \result the 2d projection of the 3d histogram.
+
+ template <typename A, unsigned direction, typename V>
+ image2d<mln_result(A)>
+ project_histo(const image3d<V>& histo)
+ {
+ typedef fun::v2v::projection<point3d,direction> t_projection;
+
+ image2d<A> histo_accu(histo.nrows(), histo.ncols());
+
+ accu::image::init(histo_accu);
+
+ accu::image::take(unproject(histo_accu,
+ histo.domain(),
+ t_projection()).rw(),
+ histo);
+
+ return accu::image::to_result(histo_accu);
+ }
+
+ // 0 ==> blue
+ // 1 ==> red
+ // 2 ==> green
+
+ // mln::opt::at(histo, blue, red, green)
+
+ template <unsigned n, unsigned direction>
+ image2d< value::int_u<n> >
+ project2_histo(const image3d<unsigned>& histo,
+ const value::int_u<n>& ambiguous_color)
+ {
+ image2d< value::int_u<n> > result;
+
+ if (0 == direction) // blue
+ {
+ image2d< value::int_u<n> > arg_max(histo.nrows(), histo.ncols());
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ def::coord pos = -1;
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = blue;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,green) = ambiguous_color;
+ else
+ opt::at(arg_max,red,green) = pos;
+ }
+
+ result = arg_max;
+ }
+ else if (1 == direction) // red
+ {
+ image2d< value::int_u<n> > arg_max(histo.ncols(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = red;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,green,blue) = ambiguous_color;
+ else
+ opt::at(arg_max,green,blue) = pos;
+ }
+
+ result = arg_max;
+ }
+ else // 2 == direction // green
+ {
+ image2d< value::int_u<n> > arg_max(histo.nrows(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = green;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,blue) = ambiguous_color;
+ else
+ opt::at(arg_max,red,blue) = pos;
+ }
+
+ result = arg_max;
+ }
+
+ return result;
+ }
+
+ template <unsigned n, unsigned direction>
+ image2d<value::label_8>
+ project2_histo(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const value::label_8 ambiguous_label)
+ {
+ image2d<value::label_8> result;
+
+ if (0 == direction) // blue
+ {
+ image2d<value::label_8> arg_max(histo.nrows(), histo.ncols());
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ def::coord pos = -1;
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = blue;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,green) = ambiguous_label;
+ else
+ opt::at(arg_max,red,green) = opt::at(label, pos, red, green);
+ }
+
+ result = arg_max;
+ }
+ else if (1 == direction) // red
+ {
+ image2d<value::label_8> arg_max(histo.ncols(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = red;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,green,blue) = ambiguous_label;
+ else
+ opt::at(arg_max,green,blue) = opt::at(label, blue, pos, green);
+ }
+
+ result = arg_max;
+ }
+ else // 2 == direction // green
+ {
+ image2d<value::label_8> arg_max(histo.nrows(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = green;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,blue) = ambiguous_label;
+ else
+ opt::at(arg_max,red,blue) = opt::at(label, blue, red, pos);
+ }
+
+ result = arg_max;
+ }
+
+ return result;
+ }
+
+
+
+
+ // FIXME ... determine the color of each class.
+ // FIXME la palette est supposée en 8 bits
+ template <unsigned n, unsigned direction>
+ image2d< value::rgb8 >
+ project3_histo(const image3d<unsigned>& histo,
+ const image3d<value::label_8>& label,
+ const util::array<algebra::vec<3,float> >& pal,
+ const value::rgb8 ambiguous_color)
+ {
+ image2d< value::rgb8 > result;
+
+ if (0 == direction) // blue
+ {
+ image2d< value::rgb8 > arg_max(histo.nrows(), histo.ncols());
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ def::coord pos = -1;
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = blue;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,green) = ambiguous_color;
+ else
+ {
+ value::int_u8 r = pal[opt::at(label,pos,red,green)][0];
+ value::int_u8 g = pal[opt::at(label,pos,red,green)][1];
+ value::int_u8 b = pal[opt::at(label,pos,red,green)][2];
+ value::rgb8 color(r,g,b);
+
+ opt::at(arg_max,red,green) = color;
+ }
+ }
+
+ result = arg_max;
+ }
+ else if (1 == direction) // red
+ {
+ image2d< value::rgb8 > arg_max(histo.ncols(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = red;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,green,blue) = ambiguous_color;
+ else
+ {
+ value::int_u8 r = pal[opt::at(label,blue,pos,green)][0];
+ value::int_u8 g = pal[opt::at(label,blue,pos,green)][1];
+ value::int_u8 b = pal[opt::at(label,blue,pos,green)][2];
+ value::rgb8 color(r,g,b);
+
+ opt::at(arg_max,green,blue) = color;
+ }
+ }
+
+ result = arg_max;
+ }
+ else // 2 == direction // green
+ {
+ image2d< value::rgb8 > arg_max(histo.nrows(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = green;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,blue) = ambiguous_color;
+ else
+ {
+ value::int_u8 r = pal[opt::at(label,blue,red,pos)][0];
+ value::int_u8 g = pal[opt::at(label,blue,red,pos)][1];
+ value::int_u8 b = pal[opt::at(label,blue,red,pos)][2];
+ value::rgb8 color(r,g,b);
+
+ opt::at(arg_max,red,blue) = color;
+ }
+ }
+
+ result = arg_max;
+ }
+
+ return result;
+ }
+
+
+ template <unsigned n, unsigned direction>
+ image2d< value::rgb<n> >
+ project3_histo(const image3d<unsigned>& histo,
+ const value::rgb<n> ambiguous_color)
+ {
+ image2d< value::rgb<n> > result;
+
+ if (0 == direction) // blue
+ {
+ image2d< value::rgb<n> > arg_max(histo.nrows(), histo.ncols());
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ def::coord pos = -1;
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = blue;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,green) = ambiguous_color;
+ else
+ opt::at(arg_max,red,green) = value::rgb<n>(red,green,pos);
+ }
+
+ result = arg_max;
+ }
+ else if (1 == direction) // red
+ {
+ image2d< value::rgb<n> > arg_max(histo.ncols(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = red;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,green,blue) = ambiguous_color;
+ else
+ opt::at(arg_max,green,blue) = value::rgb<n>(pos,green,blue);;
+ }
+
+ result = arg_max;
+ }
+ else // 2 == direction // green
+ {
+ image2d< value::rgb<n> > arg_max(histo.nrows(), histo.nslices());
+
+ for (def::coord blue = 0; blue < (signed)histo.nslices(); ++blue)
+ for (def::coord red = 0; red < (signed)histo.nrows(); ++red)
+ {
+ unsigned max = 0; // minimum as possible
+ signed pos = -1;
+
+ for (def::coord green = 0; green < (signed)histo.ncols(); ++green)
+ {
+ if (max < opt::at(histo,blue,red,green))
+ {
+ max = opt::at(histo,blue,red,green);
+ pos = green;
+ }
+ }
+
+ if (-1 == pos)
+ opt::at(arg_max,red,blue) = ambiguous_color;
+ else
+ opt::at(arg_max,red,blue) = value::rgb<n>(red,pos,blue);
+ }
+
+ result = arg_max;
+ }
+
+ return result;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::transform
+
+} // end of namespace mln
+
+
+#endif // ! MLN_DISPLAY_PROJECT_HISTO_HH
diff --git a/scribo/sandbox/green/mln/fun/p2b/achromatic.hh b/scribo/sandbox/green/mln/fun/p2b/achromatic.hh
new file mode 100644
index 0000000..1f45b2d
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/p2b/achromatic.hh
@@ -0,0 +1,112 @@
+// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_FUN_P2B_ACHROMATIC_HH
+# define MLN_FUN_P2B_ACHROMATIC_HH
+
+/// \file
+///
+/// In the vectorial image context (as RGB, HSL, HSV), compare one component
+/// to a specific value.
+
+# include <mln/core/alias/point2d.hh>
+# include <mln/core/concept/function.hh>
+# include <mln/trait/value/comp.hh>
+
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace p2b
+ {
+ /// \brief Functor that compare the i-th component of a value.
+ // V is for the type of the value received
+ // i is the ith component to select
+ template <typename T_rgb>
+ struct achromatic : public Function_v2b< achromatic<T_rgb> >
+ {
+ typedef bool result;
+ bool operator()(const point2d& p) const;
+
+ achromatic(const image2d<T_rgb>& img, const float threshold);
+
+ const float threshold_;
+ const image2d<T_rgb>& img_;
+ };
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename T_rgb>
+ achromatic<T_rgb>::achromatic(const image2d<T_rgb>& img,
+ const float threshold)
+ : threshold_(threshold), img_(img)
+ {
+ }
+
+ template <typename T_rgb>
+ bool achromatic<T_rgb>::operator()(const point2d& p) const
+ {
+ typedef typename T_rgb::red_t t_red;
+ typedef typename T_rgb::green_t t_green;
+ typedef typename T_rgb::blue_t t_blue;
+
+ const T_rgb rgb = img_(p);
+
+ // To obtain red between 0 and 1
+ const float max_red = mln_max(t_red);
+ const float min_red = mln_min(t_red);
+ const float red = (rgb.red() - min_red)/(max_red - min_red);
+
+ // To obtain green between 0 and 1
+ const float max_green = mln_max(t_green);
+ const float min_green = mln_min(t_green);
+ const float green = (rgb.green()-min_green)/(max_green-min_green);
+
+ // To obtain blue between 0 and 1
+ const float max_blue = mln_max(t_blue);
+ const float min_blue = mln_min(t_blue);
+ const float blue = (rgb.blue()-min_blue)/(max_blue-min_blue);
+
+ bool result = (threshold_ > math::abs(red - green) &&
+ threshold_ > math::abs(red - blue) &&
+ threshold_ > math::abs(green - blue));
+
+ return result;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::fun::p2b
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+
+#endif // ! MLN_FUN_P2B_ACHROMATIC_HH
diff --git a/scribo/sandbox/green/mln/fun/p2b/component_equals.hh b/scribo/sandbox/green/mln/fun/p2b/component_equals.hh
new file mode 100644
index 0000000..2a4c62c
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/p2b/component_equals.hh
@@ -0,0 +1,99 @@
+// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_FUN_P2B_COMPONENT_EQUALS_HH
+# define MLN_FUN_P2B_COMPONENT_EQUALS_HH
+
+/// \file
+///
+/// In the vectorial image context (as RGB, HSL, HSV), compare one component
+/// to a specific value.
+
+# include <mln/core/alias/point2d.hh>
+# include <mln/core/concept/function.hh>
+# include <mln/trait/value/comp.hh>
+
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace p2b
+ {
+
+ /// \brief Functor that compare the i-th component of a value.
+ // V is for the type of the value received
+ // i is the ith component to select
+ template <typename I, unsigned i>
+ struct component_equals : public Function_v2b< component_equals<I,i> >
+ {
+ typedef bool result;
+ bool operator()(const point2d& p) const;
+
+ component_equals(const I& img,
+ const mln_trait_value_comp(mln_value(I),i)& ref);
+
+ const mln_trait_value_comp(mln_value(I),i) _ref;
+ const I& _img;
+ };
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename I, unsigned i>
+ inline
+ component_equals<I,i>::
+ component_equals(const I& img,
+ const mln_trait_value_comp(mln_value(I),i)& ref)
+ : _ref(ref), _img(img)
+ {
+ }
+
+ template <typename I, unsigned i>
+ inline
+ bool
+ component_equals<I,i>::operator()(const point2d& p) const
+ {
+ typedef mln_value(I) t_value;
+ typedef mln_trait_value_comp(t_value,i) mln_value_comp;
+
+ t_value v = _img(p);
+ mln_value_comp c = trait::value::internal::comp<t_value,i>::on(v);
+
+ return (c == _ref);
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::fun::p2b
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+
+#endif // ! MLN_FUN_P2B_COMPONENT_EQUALS_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/achromatism.hh b/scribo/sandbox/green/mln/fun/v2v/achromatism.hh
new file mode 100644
index 0000000..72b545c
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/achromatism.hh
@@ -0,0 +1,64 @@
+// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_FUN_V2V_ACHROMATISM_HH
+# define MLN_FUN_V2V_ACHROMATISM_HH
+
+# include <mln/value/rgb8.hh>
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ struct achromatism : public Function_v2v< achromatism >
+ {
+ typedef float result;
+
+ float operator()(const value::rgb8 rgb) const;
+ };
+
+# ifndef MLN_INCLUDE_ONLY
+
+ float achromatism::operator()(const value::rgb8 rgb) const
+ {
+ return (math::abs(rgb.red() - rgb.green())
+ + math::abs(rgb.red() - rgb.blue())
+ + math::abs(rgb.green() - rgb.blue()))/3.0;
+ }
+
+# endif // !MLN_INCLUDE_ONLY
+
+ } // end of namespace fun::v2v
+
+ } // end of namespace fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_ACHROMATISM_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh b/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
new file mode 100644
index 0000000..84d26c8
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
@@ -0,0 +1,100 @@
+// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_FUN_V2V_HUE_CONCENTRATION_HH
+# define MLN_FUN_V2V_HUE_CONCENTRATION_HH
+
+# include <mln/core/image/image1d.hh>
+# include <mln/math/abs.hh>
+# include <mln/opt/at.hh>
+# include <mln/value/hsv.hh>
+# include <mln/value/rgb8.hh>
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ unsigned peak_histo(const mln::image1d<unsigned>& hue_histo);
+
+ struct hue_concentration : public Function_v2v< hue_concentration >
+ {
+ typedef float result;
+
+ float operator()(const float hue) const;
+
+ hue_concentration(const mln::image1d<unsigned>& hue_histo)
+ {
+ peak = peak_histo(hue_histo);
+ }
+
+ unsigned peak;
+ };
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+
+ unsigned peak_histo(const mln::image1d<unsigned>& hue_histo)
+ {
+ mln_precondition(hue_histo.is_valid());
+
+ // Find the peak of the histogram
+ unsigned v_max = mln::opt::at(hue_histo, 0);
+ short p_max = 0;
+
+ mln_piter_(mln::image1d<unsigned>) p(hue_histo.domain());
+
+ for_all(p)
+ {
+ if (v_max < hue_histo(p))
+ {
+ v_max = hue_histo(p);
+ p_max = p.ind();
+ }
+ }
+
+ return p_max;
+ }
+
+
+ float hue_concentration::operator()(float hue) const
+ {
+ return mln::math::abs(peak - hue);
+ }
+
+# endif // !MLN_INCLUDE_ONLY
+
+ } // end of namespace fun::v2v
+
+ } // end of namespace fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_HUE_CONCENTRATION_HH
diff --git a/milena/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh b/scribo/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh
copy to scribo/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/log.hh b/scribo/sandbox/green/mln/fun/v2v/log.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/log.hh
copy to scribo/sandbox/green/mln/fun/v2v/log.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rg_to_rgb.hh b/scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
copy to scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh b/scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh
new file mode 100644
index 0000000..0f63c8c
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh
@@ -0,0 +1,71 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB8_TO_INT_U8_HH
+# define MLN_FUN_V2V_RGB8_TO_INT_U8_HH
+
+# include <mln/value/int_u8.hh>
+# include <mln/value/rgb8.hh>
+# include <mln/core/contract.hh>
+
+/// \file
+///
+/// \brief Convert rgb8 color value to int_u8 grey value
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert rgb8 color value to int_u8 grey value
+ ///
+ /// \ingroup modfunv2v
+
+ struct rgb8_to_int_u8 : Function_v2v<rgb8_to_int_u8>
+ {
+ typedef value::rgb8 argument;
+ typedef value::int_u8 result;
+
+ result operator()(const argument& c) const
+ {
+ result res((c.red() + c.green() + c.blue()) / 3);
+
+ return res;
+ }
+ };
+
+ }
+
+ }
+
+}
+
+#endif // ! MLN_FUN_V2V_RGB8_TO_INT_U8_HH
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh b/scribo/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
new file mode 100644
index 0000000..6de63ec
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
@@ -0,0 +1,77 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_ACHROMATISM_MAP_HH
+# define MLN_FUN_V2V_RGB_TO_ACHROMATISM_MAP_HH
+
+# include <mln/math/abs.hh>
+# include <mln/math/max.hh>
+
+# include <mln/value/rgb.hh>
+
+
+/// \file
+///
+/// \brief Convert rgb value to achromatism map.
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert rgb value to achromatism map.
+ ///
+ /// \ingroup modfunv2v
+
+ template <unsigned n>
+ struct rgb_to_achromatism_map :
+ Function_v2v< rgb_to_achromatism_map<n> >
+ {
+ typedef value::rgb<n> argument;
+ typedef value::int_u<n> result;
+
+ result operator()(const argument& v) const
+ {
+ result max = math::max(math::max(v.red(),v.green()),v.blue());
+ result min = math::min(math::min(v.red(),v.green()),v.blue());
+ result ret = max - min;
+
+ return ret;
+ }
+ };
+
+ } // end of namespace mln::fun::v2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_ACHROMATISM_MAP_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
new file mode 100644
index 0000000..3dd8eb0
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
@@ -0,0 +1,149 @@
+// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_HSV_HH
+# define MLN_FUN_V2V_RGB_TO_HSV_HH
+
+#include <mln/math/max.hh>
+#include <mln/math/min.hh>
+
+#include <mln/trait/promote.hh>
+
+#include <mln/value/hsv.hh>
+#include <mln/value/rgb.hh>
+
+namespace mln
+{
+
+ namespace value
+ {
+ template <typename H, typename S, typename V> class hsv_;
+ typedef hsv_<float, float, float> hsv_f;
+ typedef hsv_<double, double, double> hsv_d;
+ template <unsigned n> struct rgb;
+ }
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ template <typename T_hsv>
+ struct f_rgb_to_hsv_ : public Function_v2v< f_rgb_to_hsv_<T_hsv> >
+ {
+ typedef T_hsv result;
+
+
+ /// HSV implementation from millet.2008.phd.pdf p67
+ template <typename T_rgb>
+ T_hsv operator()(const T_rgb& rgb) const;
+
+ };
+
+ typedef f_rgb_to_hsv_<value::hsv_f> f_rgb_to_hsv_f_t;
+
+ extern f_rgb_to_hsv_f_t f_rgb_to_hsv_f;
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ /// Global variables.
+ /// \{
+ f_rgb_to_hsv_f_t f_rgb_to_hsv_f;
+ /// \}
+
+
+ template <typename T_hsv>
+ template <typename T_rgb>
+ inline
+ T_hsv
+ f_rgb_to_hsv_<T_hsv>::operator()(const T_rgb& rgb) const
+ {
+ typedef typename T_rgb::red_t t_red;
+ typedef typename T_rgb::green_t t_green;
+ typedef typename T_rgb::blue_t t_blue;
+ typedef typename T_hsv::h_type t_hue;
+ typedef typename T_hsv::s_type t_sat;
+ typedef typename T_hsv::v_type t_val;
+ typedef mln_trait_promote(t_hue, t_sat) t_max_hue_sat;
+ typedef mln_trait_promote(t_max_hue_sat, t_val) t_max_hsv;
+
+ // To obtain red between 0 and 1
+ const t_max_hsv max_red = mln_max(t_red);
+ const t_max_hsv min_red = mln_min(t_red);
+ const t_max_hsv red = (rgb.red() - min_red)/(max_red - min_red);
+
+ // To obtain green between 0 and 1
+ const t_max_hsv max_green = mln_max(t_green);
+ const t_max_hsv min_green = mln_min(t_green);
+ const t_max_hsv green =(rgb.green()-min_green)/(max_green-min_green);
+
+ // To obtain blue between 0 and 1
+ const t_max_hsv max_blue = mln_max(t_blue);
+ const t_max_hsv min_blue = mln_min(t_blue);
+ const t_max_hsv blue = (rgb.blue()-min_blue)/(max_blue-min_blue);
+
+ const t_max_hsv max = math::max(red, math::max(green, blue));
+ const t_max_hsv min = math::min(red, math::min(green, blue));
+ const t_max_hsv max_minus_min = max-min;
+ const t_max_hsv s = 0.03;
+
+ // Locals.
+ T_hsv hsv;
+
+ // SPECIFIC CASE WHEN PIXEL IS ACHROMATIC
+ if (s > math::abs(red - blue) &&
+ s > math::abs(blue - red) &&
+ s > math::abs(red - green))
+ {
+ hsv.val() = (red + green + blue)/3.0;
+ hsv.sat() = 0.0;
+ hsv.hue() = -1.0;
+ }
+ else
+ {
+ hsv.val() = max;
+ hsv.sat() = max_minus_min / max;
+ if (max == red)
+ hsv.hue() = 60 * ((green - blue) / max_minus_min);
+ else if (max == green)
+ hsv.hue() = 60 * (2 + (blue - red) / max_minus_min);
+ else // (max == blue)
+ hsv.hue() = 60 * (4 + (red - green) / max_minus_min);
+ }
+ return hsv;
+ }
+
+
+# endif // !MLN_INCLUDE_ONLY
+
+ } // end of namespace fun::v2v
+
+ } // end of namespace fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_HSV_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh
new file mode 100644
index 0000000..8b228e0
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh
@@ -0,0 +1,96 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_HUE_MAP_HH
+# define MLN_FUN_V2V_RGB_TO_HUE_MAP_HH
+
+# include <mln/math/abs.hh>
+# include <mln/math/max.hh>
+
+# include <mln/value/rgb.hh>
+
+
+/// \file
+///
+/// \brief Convert rgb value to hue map.
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert rgb value to hue map.
+ ///
+ /// \ingroup modfunv2v
+
+ template <unsigned n>
+ struct rgb_to_hue_map :
+ Function_v2v< rgb_to_hue_map<n> >
+ {
+ typedef value::rgb<n> argument;
+ typedef value::int_u<n> result;
+
+ result operator()(const argument& v) const
+ {
+ const float max = math::max(math::max(v.red(), v.green()), v.blue());
+ const float min = math::min(math::min(v.red(), v.green()), v.blue());
+ const float diff = max - min;
+ float hue = 0;
+
+ if (0 != diff)
+ {
+ if (v.red() == max)
+ {
+ hue = 60 * ((v.green() - v.blue()) / diff);
+
+ if (0 < hue)
+ hue = 360.0 + hue;
+ }
+ else if (v.green() == max)
+ hue = 60 * (2 + (v.blue() - v.red()) / diff);
+ else // (v.blue() == max)
+ hue = 60 * (4 + (v.red() - v.green()) / diff);
+ }
+
+ const result ret = (hue/360.0) * (mln_max(result) - mln_min(result))
+ + mln_min(result);
+
+ return ret;
+ }
+ };
+
+ } // end of namespace mln::fun::v2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_HUE_MAP_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh
new file mode 100644
index 0000000..d4c1e46
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh
@@ -0,0 +1,111 @@
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_RG_HH
+# define MLN_FUN_V2V_RGB_TO_RG_HH
+
+# include <mln/value/rg.hh>
+# include <mln/value/rgb.hh>
+# include <mln/core/contract.hh>
+
+/// \file
+///
+/// \brief Convert a rgb value to a rg value.
+///
+/// This source implements the conversion between rgb space and rg space.
+///
+/// The following sample is a typical use of the rgb/rg conversion function.
+///
+/// #include <mln/accu/stat/histo2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<unsigned> t_histo;
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+/// t_histo histo;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+/// histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+///
+/// return 0;
+/// }
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert a rgb value to a rg value.
+ ///
+ /// Param n defines the quantification used for rgb space and rg space.
+ ///
+ /// \ingroup modfunv2v
+
+ template <unsigned n>
+ struct rgb_to_rg : Function_v2v< rgb_to_rg<n> >
+ {
+ typedef value::rg<n> result;
+ typedef value::rgb<n> argument;
+
+ /// \brief Convert rgb value to rg value.
+ ///
+ /// \param[in] v the rgb value to convert.
+ ///
+ /// Conversion is done by calling the rg constructor. There is
+ /// no modification of values. The red/green fields from rgb the value
+ /// are preserved. Blue value is dropped.
+
+ result operator()(const argument& v) const
+ {
+ return value::rg<n>(v);
+ }
+ };
+
+ } // end of namespace mln::fun::v2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_RG_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh
new file mode 100644
index 0000000..a8847a0
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh
@@ -0,0 +1,83 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_SATURATION_MAP_HH
+# define MLN_FUN_V2V_RGB_TO_SATURATION_MAP_HH
+
+# include <mln/math/abs.hh>
+# include <mln/math/max.hh>
+
+# include <mln/value/rgb.hh>
+
+
+/// \file
+///
+/// \brief Convert rgb value to saturation map.
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert rgb value to saturation map.
+ ///
+ /// \ingroup modfunv2v
+
+ template <unsigned n>
+ struct rgb_to_saturation_map :
+ Function_v2v< rgb_to_saturation_map<n> >
+ {
+ typedef value::rgb<n> argument;
+ typedef value::int_u<n> result;
+
+ result operator()(const argument& v) const
+ {
+ const float max = math::max(math::max(v.red(), v.green()), v.blue());
+ const float min = math::min(math::min(v.red(), v.green()), v.blue());
+ float sat = 0.0;
+
+ if (0 != max)
+ sat = (1 - (float)min/max);
+
+ const result ret = sat * (mln_max(result) - mln_min(result))
+ + mln_min(result);
+
+ return ret;
+ }
+ };
+
+ } // end of namespace mln::fun::v2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_SATURATION_MAP_HH
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh
new file mode 100644
index 0000000..12ac1db
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh
@@ -0,0 +1,75 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_VALUE_MAP_HH
+# define MLN_FUN_V2V_RGB_TO_VALUE_MAP_HH
+
+# include <mln/math/abs.hh>
+# include <mln/math/max.hh>
+
+# include <mln/value/rgb.hh>
+
+
+/// \file
+///
+/// \brief Convert rgb value to value map.
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert rgb value to value map.
+ ///
+ /// \ingroup modfunv2v
+
+ template <unsigned n>
+ struct rgb_to_value_map :
+ Function_v2v< rgb_to_value_map<n> >
+ {
+ typedef value::rgb<n> argument;
+ typedef value::int_u<n> result;
+
+ result operator()(const argument& v) const
+ {
+ const result ret = math::max(math::max(v.red(), v.green()), v.blue());
+
+ return ret;
+ }
+ };
+
+ } // end of namespace mln::fun::v2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_VALUE_MAP_HH
diff --git a/scribo/sandbox/green/mln/img_path.hh b/scribo/sandbox/green/mln/img_path.hh
new file mode 100644
index 0000000..d205e1f
--- /dev/null
+++ b/scribo/sandbox/green/mln/img_path.hh
@@ -0,0 +1,239 @@
+// 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)
+//
+// 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.
+
+#ifndef MLN_IMG_PATH_HH
+# define MLN_IMG_PATH_HH
+
+# define IMG_PATH "/home/green/git/img"
+# define RET_PATH "/home/green/git/result"
+
+# define INIM_IMG_PATH IMG_PATH"/inim"
+# define INIM_BG_IMG_PATH INIM_IMG_PATH"/bg"
+# define INIM_FG_IMG_PATH INIM_IMG_PATH"/fg"
+# define INIM_IN_IMG_PATH INIM_IMG_PATH"/in"
+
+# define OLENA_IMG_PATH IMG_PATH"/olena"
+
+# define ICDAR_IMG_PATH IMG_PATH"/icdar"
+# define ICDAR_100P_IMG_PATH ICDAR_IMG_PATH"/100p"
+# define ICDAR_100P_PPM_IMG_PATH ICDAR_100P_IMG_PATH"/ppm"
+# define ICDAR_100P_PGM_IMG_PATH ICDAR_100P_IMG_PATH"/pgm"
+# define ICDAR_100P_PBM_IMG_PATH ICDAR_100P_IMG_PATH"/pbm"
+# define ICDAR_100P_THICK_IMG_PATH ICDAR_100P_IMG_PATH"/gradient_thick"
+# define ICDAR_100P_THIN_IMG_PATH ICDAR_100P_IMG_PATH"/gradient_thin"
+
+# define ICDAR_50P_IMG_PATH ICDAR_IMG_PATH"/50p"
+# define ICDAR_50P_PPM_IMG_PATH ICDAR_50P_IMG_PATH"/ppm"
+# define ICDAR_50P_PGM_IMG_PATH ICDAR_50P_IMG_PATH"/pgm"
+# define ICDAR_50P_PBM_IMG_PATH ICDAR_50P_IMG_PATH"/pbm"
+
+# define ICDAR_20P_IMG_PATH ICDAR_IMG_PATH"/20p"
+# define ICDAR_20P_TEXT_ONLY_IMG_PATH ICDAR_20P_IMG_PATH"/text-only"
+# define ICDAR_20P_TEXT_COLOR_IMG_PATH ICDAR_20P_IMG_PATH"/text-color"
+# define ICDAR_20P_TEXT_PHOTO_IMG_PATH ICDAR_20P_IMG_PATH"/text-photo"
+# define ICDAR_20P_GMP30_IMG_PATH ICDAR_20P_IMG_PATH"/gimp-pal-30"
+# define ICDAR_20P_MGK30_IMG_PATH ICDAR_20P_IMG_PATH"/magick-pal-30"
+# define ICDAR_20P_GMP20_IMG_PATH ICDAR_20P_IMG_PATH"/gimp-pal-20"
+# define ICDAR_20P_MGK20_IMG_PATH ICDAR_20P_IMG_PATH"/magick-pal-20"
+# define ICDAR_20P_GMP10_IMG_PATH ICDAR_20P_IMG_PATH"/gimp-pal-10"
+# define ICDAR_20P_MGK10_IMG_PATH ICDAR_20P_IMG_PATH"/magick-pal-10"
+# define ICDAR_20P_INPUT_IMG_PATH ICDAR_20P_IMG_PATH"/ppm"
+# define ICDAR_20P_CROP_IMG_PATH ICDAR_20P_IMG_PATH"/crop"
+# define ICDAR_20P_PGM_IMG_PATH ICDAR_20P_IMG_PATH"/pgm"
+# define ICDAR_20P_PPM_IMG_PATH ICDAR_20P_IMG_PATH"/ppm"
+# define ICDAR_20P_PBM_IMG_PATH ICDAR_20P_IMG_PATH"/pbm"
+
+# define AFP_IMG_PATH IMG_PATH"/afp"
+# define AFP_GMP30_IMG_PATH AFP_IMG_PATH"/gimp-pal-30"
+# define AFP_GMP20_IMG_PATH AFP_IMG_PATH"/gimp-pal-20"
+# define AFP_GMP10_IMG_PATH AFP_IMG_PATH"/gimp-pal-10"
+# define AFP_MGK30_IMG_PATH AFP_IMG_PATH"/magick-pal-30"
+# define AFP_MGK20_IMG_PATH AFP_IMG_PATH"/magick-pal-20"
+# define AFP_MGK10_IMG_PATH AFP_IMG_PATH"/magick-pal-10"
+# define AFP_INPUT_IMG_PATH AFP_IMG_PATH"/ppm"
+# define AFP_PPM_IMG_PATH AFP_IMG_PATH"/ppm"
+# define AFP_JPG_IMG_PATH AFP_IMG_PATH"/jpg"
+
+# define ANNOTATING_1_IMG_PATH IMG_PATH"/annotating-1"
+# define ANNOTATING_1_BILL_IMG_PATH ANNOTATING_1_IMG_PATH"/bill"
+# define ANNOTATING_1_FAX_IMG_PATH ANNOTATING_1_IMG_PATH"/fax"
+# define ANNOTATING_1_HANDWRITTEN_IMG_PATH ANNOTATING_1_IMG_PATH"/handwritten"
+# define ANNOTATING_1_LOGO_IMG_PATH ANNOTATING_1_IMG_PATH"/logo"
+# define ANNOTATING_1_MAP_IMG_PATH ANNOTATING_1_IMG_PATH"/map"
+# define ANNOTATING_1_SCREENSHOT_IMG_PATH ANNOTATING_1_IMG_PATH"/screenshot"
+# define ANNOTATING_1_SLIDE_IMG_PATH ANNOTATING_1_IMG_PATH"/slide"
+# define ANNOTATING_1_TYPED_IMG_PATH ANNOTATING_1_IMG_PATH"/typed"
+# define ANNOTATING_1_PHOTO_IMG_PATH ANNOTATING_1_IMG_PATH"/photo"
+
+# define ANNOTATING_2_IMG_PATH IMG_PATH"/annotating-2"
+# define ANNOTATING_2_BILL_IMG_PATH ANNOTATING_2_IMG_PATH"/bill"
+# define ANNOTATING_2_FAX_IMG_PATH ANNOTATING_2_IMG_PATH"/fax"
+# define ANNOTATING_2_HANDWRITTEN_IMG_PATH ANNOTATING_2_IMG_PATH"/handwritten"
+# define ANNOTATING_2_LOGO_IMG_PATH ANNOTATING_2_IMG_PATH"/logo"
+# define ANNOTATING_2_MAP_IMG_PATH ANNOTATING_2_IMG_PATH"/map"
+# define ANNOTATING_2_SCREENSHOT_IMG_PATH ANNOTATING_2_IMG_PATH"/screenshot"
+# define ANNOTATING_2_SLIDE_IMG_PATH ANNOTATING_2_IMG_PATH"/slide"
+# define ANNOTATING_2_TYPED_IMG_PATH ANNOTATING_2_IMG_PATH"/typed"
+# define ANNOTATING_2_PHOTO_IMG_PATH ANNOTATING_2_IMG_PATH"/photo"
+
+// result directories
+# define ANNOTATING_RET_PATH RET_PATH"/annotating"
+
+# define ANNOTATING_ICDAR_RET_PATH ANNOTATING_RET_PATH"/icdar"
+
+# define ANNOTATING_ICDAR_INPUT_RET_PATH ANNOTATING_ICDAR_RET_PATH"/input"
+# define ANNOTATING_ICDAR_H_INPUT_RET_PATH ANNOTATING_ICDAR_INPUT_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_INPUT_RET_PATH ANNOTATING_ICDAR_INPUT_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_INPUT_RET_PATH ANNOTATING_ICDAR_INPUT_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_INPUT_RET_PATH ANNOTATING_ICDAR_INPUT_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_INPUT_RET_PATH ANNOTATING_ICDAR_INPUT_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_INPUT_RET_PATH ANNOTATING_ICDAR_INPUT_RET_PATH"/b"
+
+# define ANNOTATING_ICDAR_GMP30_RET_PATH ANNOTATING_ICDAR_RET_PATH"/gimp-pal-30"
+# define ANNOTATING_ICDAR_H_GMP30_RET_PATH ANNOTATING_ICDAR_GMP30_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_GMP30_RET_PATH ANNOTATING_ICDAR_GMP30_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_GMP30_RET_PATH ANNOTATING_ICDAR_GMP30_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_GMP30_RET_PATH ANNOTATING_ICDAR_GMP30_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_GMP30_RET_PATH ANNOTATING_ICDAR_GMP30_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_GMP30_RET_PATH ANNOTATING_ICDAR_GMP30_RET_PATH"/b"
+
+# define ANNOTATING_ICDAR_GMP20_RET_PATH ANNOTATING_ICDAR_RET_PATH"/gimp-pal-20"
+# define ANNOTATING_ICDAR_H_GMP20_RET_PATH ANNOTATING_ICDAR_GMP20_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_GMP20_RET_PATH ANNOTATING_ICDAR_GMP20_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_GMP20_RET_PATH ANNOTATING_ICDAR_GMP20_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_GMP20_RET_PATH ANNOTATING_ICDAR_GMP20_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_GMP20_RET_PATH ANNOTATING_ICDAR_GMP20_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_GMP20_RET_PATH ANNOTATING_ICDAR_GMP20_RET_PATH"/b"
+
+# define ANNOTATING_ICDAR_GMP10_RET_PATH ANNOTATING_ICDAR_RET_PATH"/gimp-pal-10"
+# define ANNOTATING_ICDAR_H_GMP10_RET_PATH ANNOTATING_ICDAR_GMP10_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_GMP10_RET_PATH ANNOTATING_ICDAR_GMP10_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_GMP10_RET_PATH ANNOTATING_ICDAR_GMP10_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_GMP10_RET_PATH ANNOTATING_ICDAR_GMP10_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_GMP10_RET_PATH ANNOTATING_ICDAR_GMP10_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_GMP10_RET_PATH ANNOTATING_ICDAR_GMP10_RET_PATH"/b"
+
+# define ANNOTATING_ICDAR_MGK30_RET_PATH ANNOTATING_ICDAR_RET_PATH"/magick-pal-30"
+# define ANNOTATING_ICDAR_H_MGK30_RET_PATH ANNOTATING_ICDAR_MGK30_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_MGK30_RET_PATH ANNOTATING_ICDAR_MGK30_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_MGK30_RET_PATH ANNOTATING_ICDAR_MGK30_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_MGK30_RET_PATH ANNOTATING_ICDAR_MGK30_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_MGK30_RET_PATH ANNOTATING_ICDAR_MGK30_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_MGK30_RET_PATH ANNOTATING_ICDAR_MGK30_RET_PATH"/b"
+
+# define ANNOTATING_ICDAR_MGK20_RET_PATH ANNOTATING_ICDAR_RET_PATH"/magick-pal-20"
+# define ANNOTATING_ICDAR_H_MGK20_RET_PATH ANNOTATING_ICDAR_MGK20_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_MGK20_RET_PATH ANNOTATING_ICDAR_MGK20_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_MGK20_RET_PATH ANNOTATING_ICDAR_MGK20_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_MGK20_RET_PATH ANNOTATING_ICDAR_MGK20_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_MGK20_RET_PATH ANNOTATING_ICDAR_MGK20_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_MGK20_RET_PATH ANNOTATING_ICDAR_MGK20_RET_PATH"/b"
+
+# define ANNOTATING_ICDAR_MGK10_RET_PATH ANNOTATING_ICDAR_RET_PATH"/magick-pal-10"
+# define ANNOTATING_ICDAR_H_MGK10_RET_PATH ANNOTATING_ICDAR_MGK10_RET_PATH"/h"
+# define ANNOTATING_ICDAR_S_MGK10_RET_PATH ANNOTATING_ICDAR_MGK10_RET_PATH"/s"
+# define ANNOTATING_ICDAR_V_MGK10_RET_PATH ANNOTATING_ICDAR_MGK10_RET_PATH"/v"
+# define ANNOTATING_ICDAR_R_MGK10_RET_PATH ANNOTATING_ICDAR_MGK10_RET_PATH"/r"
+# define ANNOTATING_ICDAR_G_MGK10_RET_PATH ANNOTATING_ICDAR_MGK10_RET_PATH"/g"
+# define ANNOTATING_ICDAR_B_MGK10_RET_PATH ANNOTATING_ICDAR_MGK10_RET_PATH"/b"
+
+
+
+
+# define ANNOTATING_AFP_RET_PATH ANNOTATING_RET_PATH"/afp"
+
+# define ANNOTATING_AFP_INPUT_RET_PATH ANNOTATING_AFP_RET_PATH"/input"
+# define ANNOTATING_AFP_H_INPUT_RET_PATH ANNOTATING_AFP_INPUT_RET_PATH"/h"
+# define ANNOTATING_AFP_S_INPUT_RET_PATH ANNOTATING_AFP_INPUT_RET_PATH"/s"
+# define ANNOTATING_AFP_V_INPUT_RET_PATH ANNOTATING_AFP_INPUT_RET_PATH"/v"
+# define ANNOTATING_AFP_R_INPUT_RET_PATH ANNOTATING_AFP_INPUT_RET_PATH"/r"
+# define ANNOTATING_AFP_G_INPUT_RET_PATH ANNOTATING_AFP_INPUT_RET_PATH"/g"
+# define ANNOTATING_AFP_B_INPUT_RET_PATH ANNOTATING_AFP_INPUT_RET_PATH"/b"
+
+# define ANNOTATING_AFP_GMP30_RET_PATH ANNOTATING_AFP_RET_PATH"/gimp-pal-30"
+# define ANNOTATING_AFP_H_GMP30_RET_PATH ANNOTATING_AFP_GMP30_RET_PATH"/h"
+# define ANNOTATING_AFP_S_GMP30_RET_PATH ANNOTATING_AFP_GMP30_RET_PATH"/s"
+# define ANNOTATING_AFP_V_GMP30_RET_PATH ANNOTATING_AFP_GMP30_RET_PATH"/v"
+# define ANNOTATING_AFP_R_GMP30_RET_PATH ANNOTATING_AFP_GMP30_RET_PATH"/r"
+# define ANNOTATING_AFP_G_GMP30_RET_PATH ANNOTATING_AFP_GMP30_RET_PATH"/g"
+# define ANNOTATING_AFP_B_GMP30_RET_PATH ANNOTATING_AFP_GMP30_RET_PATH"/b"
+
+# define ANNOTATING_AFP_GMP20_RET_PATH ANNOTATING_AFP_RET_PATH"/gimp-pal-20"
+# define ANNOTATING_AFP_H_GMP20_RET_PATH ANNOTATING_AFP_GMP20_RET_PATH"/h"
+# define ANNOTATING_AFP_S_GMP20_RET_PATH ANNOTATING_AFP_GMP20_RET_PATH"/s"
+# define ANNOTATING_AFP_V_GMP20_RET_PATH ANNOTATING_AFP_GMP20_RET_PATH"/v"
+# define ANNOTATING_AFP_R_GMP20_RET_PATH ANNOTATING_AFP_GMP20_RET_PATH"/r"
+# define ANNOTATING_AFP_G_GMP20_RET_PATH ANNOTATING_AFP_GMP20_RET_PATH"/g"
+# define ANNOTATING_AFP_B_GMP20_RET_PATH ANNOTATING_AFP_GMP20_RET_PATH"/b"
+
+# define ANNOTATING_AFP_GMP10_RET_PATH ANNOTATING_AFP_RET_PATH"/gimp-pal-10"
+# define ANNOTATING_AFP_H_GMP10_RET_PATH ANNOTATING_AFP_GMP10_RET_PATH"/h"
+# define ANNOTATING_AFP_S_GMP10_RET_PATH ANNOTATING_AFP_GMP10_RET_PATH"/s"
+# define ANNOTATING_AFP_V_GMP10_RET_PATH ANNOTATING_AFP_GMP10_RET_PATH"/v"
+# define ANNOTATING_AFP_R_GMP10_RET_PATH ANNOTATING_AFP_GMP10_RET_PATH"/r"
+# define ANNOTATING_AFP_G_GMP10_RET_PATH ANNOTATING_AFP_GMP10_RET_PATH"/g"
+# define ANNOTATING_AFP_B_GMP10_RET_PATH ANNOTATING_AFP_GMP10_RET_PATH"/b"
+
+# define ANNOTATING_AFP_MGK30_RET_PATH ANNOTATING_AFP_RET_PATH"/magick-pal-30"
+# define ANNOTATING_AFP_H_MGK30_RET_PATH ANNOTATING_AFP_MGK30_RET_PATH"/h"
+# define ANNOTATING_AFP_S_MGK30_RET_PATH ANNOTATING_AFP_MGK30_RET_PATH"/s"
+# define ANNOTATING_AFP_V_MGK30_RET_PATH ANNOTATING_AFP_MGK30_RET_PATH"/v"
+# define ANNOTATING_AFP_R_MGK30_RET_PATH ANNOTATING_AFP_MGK30_RET_PATH"/r"
+# define ANNOTATING_AFP_G_MGK30_RET_PATH ANNOTATING_AFP_MGK30_RET_PATH"/g"
+# define ANNOTATING_AFP_B_MGK30_RET_PATH ANNOTATING_AFP_MGK30_RET_PATH"/b"
+
+# define ANNOTATING_AFP_MGK20_RET_PATH ANNOTATING_AFP_RET_PATH"/magick-pal-20"
+# define ANNOTATING_AFP_H_MGK20_RET_PATH ANNOTATING_AFP_MGK20_RET_PATH"/h"
+# define ANNOTATING_AFP_S_MGK20_RET_PATH ANNOTATING_AFP_MGK20_RET_PATH"/s"
+# define ANNOTATING_AFP_V_MGK20_RET_PATH ANNOTATING_AFP_MGK20_RET_PATH"/v"
+# define ANNOTATING_AFP_R_MGK20_RET_PATH ANNOTATING_AFP_MGK20_RET_PATH"/r"
+# define ANNOTATING_AFP_G_MGK20_RET_PATH ANNOTATING_AFP_MGK20_RET_PATH"/g"
+# define ANNOTATING_AFP_B_MGK20_RET_PATH ANNOTATING_AFP_MGK20_RET_PATH"/b"
+
+# define ANNOTATING_AFP_MGK10_RET_PATH ANNOTATING_AFP_RET_PATH"/magick-pal-10"
+# define ANNOTATING_AFP_H_MGK10_RET_PATH ANNOTATING_AFP_MGK10_RET_PATH"/h"
+# define ANNOTATING_AFP_S_MGK10_RET_PATH ANNOTATING_AFP_MGK10_RET_PATH"/s"
+# define ANNOTATING_AFP_V_MGK10_RET_PATH ANNOTATING_AFP_MGK10_RET_PATH"/v"
+# define ANNOTATING_AFP_R_MGK10_RET_PATH ANNOTATING_AFP_MGK10_RET_PATH"/r"
+# define ANNOTATING_AFP_G_MGK10_RET_PATH ANNOTATING_AFP_MGK10_RET_PATH"/g"
+# define ANNOTATING_AFP_B_MGK10_RET_PATH ANNOTATING_AFP_MGK10_RET_PATH"/b"
+
+
+# define ANNOTATING_BILL_RET_PATH ANNOTATING_RET_PATH"/bill"
+# define ANNOTATING_FAX_RET_PATH ANNOTATING_RET_PATH"/fax"
+# define ANNOTATING_HANDWRITTEN_RET_PATH ANNOTATING_RET_PATH"/handwritten"
+# define ANNOTATING_LOGO_RET_PATH ANNOTATING_RET_PATH"/logo"
+# define ANNOTATING_MAP_RET_PATH ANNOTATING_RET_PATH"/map"
+# define ANNOTATING_SCREENSHOT_RET_PATH ANNOTATING_RET_PATH"/screenshot"
+# define ANNOTATING_SLIDE_RET_PATH ANNOTATING_RET_PATH"/slide"
+# define ANNOTATING_TYPED_RET_PATH ANNOTATING_RET_PATH"/typed"
+# define ANNOTATING_PHOTO_RET_PATH ANNOTATING_RET_PATH"/photo"
+
+# define ANNOTATING_ICDAR_ACHROMATISM_RET_PATH ANNOTATING_ICDAR_RET_PATH"/achromatism"
+
+
+#endif // ! MLN_IMG_PATH_HH
diff --git a/scribo/sandbox/green/mln/io/plot/save_image_sh.hh b/scribo/sandbox/green/mln/io/plot/save_image_sh.hh
new file mode 100644
index 0000000..137f78d
--- /dev/null
+++ b/scribo/sandbox/green/mln/io/plot/save_image_sh.hh
@@ -0,0 +1,1056 @@
+// 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.
+
+#ifndef MLN_IO_PLOT_SAVE_IMAGE_SH_HH
+# define MLN_IO_PLOT_SAVE_IMAGE_SH_HH
+
+/// \file
+///
+/// \brief Define some functions to export to gnuplot format as a script shell.
+///
+/// Theses routines are dedicated to image visualization. The aim is to display
+/// image whatever the value used as pixel. The behaviour of gnuplot is more
+/// like xv than imageMagick. A Gnuplot script shell file is a text dump file
+/// with a preambule to let gnuplot interpret data. As a script shell, you can
+/// launch it (don't forget the permissions), and every thing is packed in it.
+/// The script file call gnuplot in batch mode, the result window persists and
+/// that's all.
+///
+
+# include <fstream>
+# include <string>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/core/macros.hh>
+# include <mln/core/contract.hh>
+# include <mln/core/image/image1d.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/image/image3d.hh>
+
+# include <mln/geom/min_ind.hh>
+# include <mln/geom/max_ind.hh>
+# include <mln/geom/min_row.hh>
+# include <mln/geom/max_row.hh>
+# include <mln/geom/min_col.hh>
+# include <mln/geom/max_col.hh>
+
+# include <mln/trait/value_.hh>
+
+# include <mln/value/int_u.hh>
+# include <mln/value/int_s.hh>
+# include <mln/value/rgb.hh>
+# include <mln/value/hsl.hh>
+# include <mln/value/hsi.hh>
+
+# include <mln/util/array.hh>
+
+
+namespace mln
+{
+
+ namespace io
+ {
+
+ namespace plot
+ {
+
+ /// \brief Save an image as a gnuplot script shell.
+ ///
+ /// Every thing is save. The image could be 1d, 2d or 3d. The value of
+ /// the pixels could be int_u<n>, int_s<n>, float, double, hsl_f, hsl_d,
+ /// hsi_f, hsi_d and rgb<n>.
+ ///
+ /// \param[in] img the image which contains the data to save.
+ /// \param[in] filename the name of the unix script shell.
+ /// \return the status of the opening file operation.
+ ///
+ /// The result depends on the permission to save the file with
+ /// filename parameter as unix path. The script shell file must have the
+ /// permission to execute (chmod 755). Launch the script shell to call
+ /// gnuplot in batchmode with fine parameters.
+
+ template <typename I>
+ bool save_image_sh(const Image<I>& img, const std::string& filename);
+
+ /// \brief Save a stack of image.
+ ///
+ /// This is an experimental support.
+ ///
+ /// \param[in] stack the stack of image to save.
+ /// \param[in] filename the name of the unix script shell.
+ /// \return the status of the opening file operation.
+ ///
+ /// The result depends on the permission to save the file with
+ /// filename parameter as unix path. The script shell file must have the
+ /// permission to execute (chmod 755). Launch the script shell to call
+ /// gnuplot in batchmode with fine parameters.
+ template <typename I>
+ bool save_image_sh(const util::array< image1d<I> >& stack,
+ const std::string& filename);
+
+ template <typename I>
+ bool save_image_sh(const util::array< util::array< image1d<I> > >& stack,
+ const std::string& filename);
+
+ } // end of namespace mln::io::plot
+
+ } // end of namespace mln::io
+
+
+ namespace io
+ {
+
+ namespace plot
+ {
+
+#ifndef MLN_INCLUDE_ONLY
+
+ //------------------------------------------------------------------------
+ // Impl.
+ //------------------------------------------------------------------------
+
+ namespace impl
+ {
+
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_array_image1d(const array<array<image1d<I>>>&,
+ // const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_array_array_image1d(const util::array< util::array<
+ image1d<I> > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d");
+
+ mln_precondition(!stack.is_empty());
+ mln_precondition(!stack[0].is_empty());
+ mln_precondition(stack[0][0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0][0]);
+ unsigned max_ind = geom::max_ind(stack[0][0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "plot '-' with line";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+ for (unsigned j = 1; j < stack[i].size(); ++j)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line";
+ }
+ }
+
+ out << std::endl;
+
+ mln_eiter(util::array< util::array< image1d<I> > >) e0(stack);
+
+ for_all (e0)
+ {
+ mln_eiter(util::array< image1d<I> >) e1(stack[e0.index_()]);
+
+ for_all (e1)
+ {
+ mln_piter(image1d< I >)
+ p(stack[e0.index_()][e1.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e0.index_()][e1.index_()](p) << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d");
+
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_array_image1d_vec3(
+ // const array<array<image1d<vec<3,T>>>>&,
+ // const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_array_array_image1d_vec3(
+ const util::array<util::array<image1d<algebra::vec<3,T> > > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec3");
+
+ typedef algebra::vec<3,T> t_val;
+ typedef image1d<t_val> t_img;
+ typedef util::array<t_img> t_array;
+ typedef util::array<t_array> t_stack;
+
+ mln_precondition(!stack.is_empty());
+ mln_precondition(!stack[0].is_empty());
+ mln_precondition(stack[0][0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0][0]);
+ unsigned max_ind = geom::max_ind(stack[0][0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "splot '-' with line palette";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+ for (unsigned j = 1; j < stack[i].size(); ++j)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line palette";
+ }
+ }
+
+ out << std::endl;
+
+ mln_eiter(t_stack) e0(stack);
+
+ for_all (e0)
+ {
+ mln_eiter(t_array) e1(stack[e0.index_()]);
+
+ for_all (e1)
+ {
+ mln_piter(t_img) p(stack[e0.index_()][e1.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e0.index_()][e1.index_()](p)[0] << " ";
+ out << stack[e0.index_()][e1.index_()](p)[1] << " ";
+ out << stack[e0.index_()][e1.index_()](p)[2] << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec3");
+
+ return result;
+ }
+
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_array_image1d_vec2(
+ // const array<array<image1d<vec<2,T>>>>&,
+ // const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_array_array_image1d_vec2(
+ const util::array<util::array<image1d<algebra::vec<2,T> > > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec2");
+
+ typedef algebra::vec<2,T> t_val;
+ typedef image1d<t_val> t_img;
+ typedef util::array<t_img> t_array;
+ typedef util::array<t_array> t_stack;
+
+ mln_precondition(!stack.is_empty());
+ mln_precondition(!stack[0].is_empty());
+ mln_precondition(stack[0][0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0][0]);
+ unsigned max_ind = geom::max_ind(stack[0][0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "splot '-' with line";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+ for (unsigned j = 1; j < stack[i].size(); ++j)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line";
+ }
+ }
+
+ out << std::endl;
+
+ mln_eiter(t_stack) e0(stack);
+
+ for_all (e0)
+ {
+ mln_eiter(t_array) e1(stack[e0.index_()]);
+
+ for_all (e1)
+ {
+ mln_piter(t_img) p(stack[e0.index_()][e1.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e0.index_()][e1.index_()](p)[0] << " ";
+ out << stack[e0.index_()][e1.index_()](p)[1] << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec2");
+
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_image1d(const array<image1d<I>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_array_image1d(const util::array< image1d<I> >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_array_image1d");
+ mln_precondition(!stack.is_empty());
+ mln_precondition(stack[0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0]);
+ unsigned max_ind = geom::max_ind(stack[0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "plot '-' with line";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line";
+ }
+
+ out << std::endl;
+
+ mln_eiter(util::array< image1d<I> >) e(stack);
+
+ for_all (e)
+ {
+ mln_piter(image1d< I >) p(stack[e.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e.index_()](p) << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_array_image1d");
+ return result;
+ }
+
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d_rgb(const image2d<rgb<n>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <unsigned n>
+ inline
+ bool save_image_sh_image2d_rgb(const image2d<value::rgb<n> >& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d_rgb");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ if (result)
+ {
+ mln_piter(image2d< value::rgb<n> >) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, r, g, b) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):3:4:5 with rgbimage" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p).red() << " ";
+ out << img(p).green() << " ";
+ out << img(p).blue() << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d_rgb");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d_hsl(const image2d<hsl_<T,T,T>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_image2d_hsl(const image2d<value::hsl_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d_hsl");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ typedef mln::value::hsl_<T,T,T> hsl;
+
+ if (result)
+ {
+ mln_piter(image2d< hsl >) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "q(l,s) = (l < 0.5)? (l*(1+s)):(l+s-(l*s))" << std::endl;
+ out << "p(l,s) = (2.0 * l - q(l,s))" << std::endl;
+ out << "n(x) = (x < 0)?(x+1):(x > 1)?(x-1) : (x)"<< std::endl;
+ out << std::endl;
+ out << "c(p,q,t) = (t <(1.0/6.0))?(p+(q-p)*6.0*t):\\"<< std::endl;
+ out << " (t <(1.0/2.0))?(q) :\\" << std::endl;
+ out << " (t<(2.0/3.0))?(p+(q-p)*6.0*((2.0/3.0)-t)):\\" << std::endl;
+ out << " (p)" << std::endl;
+ out << std::endl;
+ out << "r(h,s,l) = c(p(l,s),q(l,s),n(h/360.0+1.0/3.0))"<< std::endl;
+ out << "g(h,s,l) = c(p(l,s),q(l,s),n(h/360.0))" << std::endl;
+ out << "b(h,s,l) = c(p(l,s),q(l,s),n(h/360.0-1.0/3.0))"<< std::endl;
+ out << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set palette gray" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):\\" << std::endl;
+ out << " (r(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (g(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (b(\\$3,\\$4,\\$5)) with rgbimage" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p).hue() << " ";
+ out << img(p).sat() << " ";
+ out << img(p).lum() << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d_hsl");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d_hsi(const image2d<hsi_<T,T,T>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_image2d_hsi(const image2d<value::hsi_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d_hsi");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ typedef mln::value::hsi_<T,T,T> hsi;
+
+ if (result)
+ {
+ mln_piter(image2d< hsi >) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "teta(h) = (h/180.0) * pi" << std::endl;
+ out << "alpha(s,h) = s*cos(teta(h))" << std::endl;
+ out << "beta(s,h) = s*sin(teta(h))" << std::endl;
+ out << "n(x) = (x < 0)?(x+1) : (x > 1)?(x-1):(x)"<< std::endl;
+ out << std::endl;
+ out << "c(p,q,t) = (t <(1.0/6.0))?(p+(q-p)*6.0*t):\\"<< std::endl;
+ out << " (t <(1.0/2.0))?(q) :\\" << std::endl;
+ out << " (t <(2.0/3.0))?(p+(q-p)*6.0*((2.0/3.0)-t)):\\"<< std::endl;
+ out << " (p)" << std::endl;
+ out << std::endl;
+ out << "r(h,s,i) = (sqrt(3.0)/3.0) * i \\" << std::endl;
+ out << " + (2.0/(sqrt(6.0))) * beta(s,h)" << std::endl;
+ out << "g(h,s,i) = (sqrt(3.0)/3.0) * i \\" << std::endl;
+ out << " + (2.0/(sqrt(2.0))) * alpha(s,h)\\" << std::endl;
+ out << " - (1.0/(sqrt(6.0))) * beta(s,h)" << std::endl;
+ out << "b(h,s,i) = (sqrt(3.0)/3.0) * i \\" << std::endl;
+ out << " - (2.0/(sqrt(2.0))) * alpha(s,h) \\"<< std::endl;
+ out << " - (1.0/(sqrt(6.0))) * beta(s,h)" << std::endl;
+ out << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set palette gray" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):\\" << std::endl;
+ out << " (r(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (g(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (b(\\$3,\\$4,\\$5)) with rgbimage" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p).hue() << " ";
+ out << img(p).sat() << " ";
+ out << img(p).inty() << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d_hsi");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d(const image2d<I>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_image2d(const image2d<I>& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ if (result)
+ {
+ mln_piter(image2d<I>) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set palette gray" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):3 with image" <<std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p) << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:"<< filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image1d(const image1d<I>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_image1d(const image1d<I>& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image1d");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+
+ if (result)
+ {
+ mln_piter(image1d<I>) p(img.domain());
+
+ // Output data prelude (terminal X11, impulse).
+ out << "#!/bin/sh" << std::endl;
+ out << "##########################" << std::endl;
+ out << "# Two columns = (x, val) #" << std::endl;
+ out << "##########################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "plot '-' with impulse" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << img(p) << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:"<< filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image1d");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image3d(const image3d<I>&, const string&)
+ //----------------------------------------------------------------------
+
+
+ template <typename I>
+ inline
+ bool save_image_sh_image3d(const image3d<I>& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image3d");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+
+ if (result)
+ {
+ mln_piter(image3d<I>) p(img.domain());
+
+ // Output data prelude (terminal X11, pointtype 0).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, z, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "splot '-' with points palette pointtype 7" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << p.sli() << " ";
+ out << img(p) << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:"<< filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image3d");
+ return result;
+ }
+
+ } // end of namespace impl
+
+
+ //------------------------------------------------------------------------
+ // Internal.
+ //------------------------------------------------------------------------
+
+ namespace internal
+ {
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const util::array< image1d<I> >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_image1d(stack, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const util::array<
+ util::array <image1d<I> > >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_array_image1d(stack, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(
+ const util::array<util::array<image1d<algebra::vec<3,T> > > >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_array_image1d_vec3(stack, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(
+ const util::array<util::array<image1d<algebra::vec<2,T> > > >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_array_image1d_vec2(stack, filename);
+ }
+
+ template <unsigned n>
+ inline
+ bool save_image_sh_dispatch(const image2d<value::rgb<n> >& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d_rgb(img, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(const image2d<value::hsl_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d_hsl(img, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(const image2d<value::hsi_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d_hsi(img, filename);
+ }
+
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const image2d<I>& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d(img, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const image1d<I>& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image1d(img, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const image3d<I>& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image3d(img, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const Image<I>& img,
+ const std::string& filename)
+ {
+ return save_image_sh_dispatch(exact(img), filename);
+ }
+
+ } // end of namespace mln::io::plot::internal
+
+ //------------------------------------------------------------------------
+ // Facade.
+ //------------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh(const Image<I>& img, const std::string& filename)
+ {
+ trace::entering("mln::io::plot::save_image_sh");
+
+ bool result = internal::save_image_sh_dispatch(img, filename);
+
+ trace::exiting("mln::io::plot::save_image_sh");
+ return result;
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh(const util::array< image1d<I> >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::save_image_sh");
+
+ bool result = internal::save_image_sh_dispatch(stack, filename);
+
+ trace::exiting("mln::io::plot::save_image_sh");
+ return result;
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh(const util::array< util::array< image1d<I> > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::save_image_sh");
+
+ bool result = internal::save_image_sh_dispatch(stack, filename);
+
+ trace::exiting("mln::io::plot::save_image_sh");
+ return result;
+ }
+
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::io::plot
+
+ } // end of namespace mln::io
+
+} // end of namespace mln
+
+#endif // ! MLN_IO_PLOT_SAVE_IMAGE_SH_HH
diff --git a/scribo/sandbox/green/mln/math/ceil.hh b/scribo/sandbox/green/mln/math/ceil.hh
new file mode 100644
index 0000000..6fc08c8
--- /dev/null
+++ b/scribo/sandbox/green/mln/math/ceil.hh
@@ -0,0 +1,64 @@
+// Copyright (C) 2007, 2008, 2009, 2010
+// EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_MATH_CEIL_HH
+# define MLN_MATH_CEIL_HH
+
+/*! \file
+ *
+ * \brief Define the ceil (ceil) routine.
+ */
+
+# include <cmath>
+
+
+namespace mln
+{
+
+ namespace math
+ {
+
+ template <typename T>
+ T ceil(const T& v);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename T>
+ inline
+ T ceil(const T& v)
+ {
+ return std::ceil(v);
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::math
+
+} // end of namespace mln
+
+
+#endif // ! MLN_MATH_FLOOR_HH
diff --git a/scribo/sandbox/green/mln/math/floor.hh b/scribo/sandbox/green/mln/math/floor.hh
new file mode 100644
index 0000000..97e63bd
--- /dev/null
+++ b/scribo/sandbox/green/mln/math/floor.hh
@@ -0,0 +1,64 @@
+// Copyright (C) 2007, 2008, 2009, 2010
+// EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_MATH_FLOOR_HH
+# define MLN_MATH_FLOOR_HH
+
+/*! \file
+ *
+ * \brief Define the floor (floor) routine.
+ */
+
+# include <cmath>
+
+
+namespace mln
+{
+
+ namespace math
+ {
+
+ template <typename T>
+ T floor(const T& v);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename T>
+ inline
+ T floor(const T& v)
+ {
+ return std::floor(v);
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::math
+
+} // end of namespace mln
+
+
+#endif // ! MLN_MATH_FLOOR_HH
diff --git a/scribo/sandbox/green/mln/value/hsv.hh b/scribo/sandbox/green/mln/value/hsv.hh
new file mode 100644
index 0000000..69948d9
--- /dev/null
+++ b/scribo/sandbox/green/mln/value/hsv.hh
@@ -0,0 +1,424 @@
+// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (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.
+
+#ifndef MLN_VALUE_HSV_HH
+# define MLN_VALUE_HSV_HH
+
+#include <mln/value/ops.hh>
+
+#include <mln/value/concept/vectorial.hh>
+#include <mln/value/int_u.hh>
+// #include <mln/algebra/vec.hh>
+
+// Used in from_to
+// #include <mln/fun/v2v/rgb_to_hsv.hh>
+
+
+namespace mln
+{
+
+ // Forward declarations.
+ namespace value
+ {
+
+ template <typename H, typename S, typename V>
+ class hsv_;
+
+ }
+
+
+/*
+ namespace convert
+ {
+
+ namespace over_load
+ {
+
+ // rgb to hsv_
+ void
+ from_to_(const value::rgb<16>& from, value::hsv_<float,float,float>& to);
+
+ // rgb to hsv_
+ void
+ from_to_(const value::rgb<8>& from, value::hsv_<float,float,float>& to);
+
+ } // end of namespace mln::convert::over_load
+
+ } // end of namespace mln::convert
+*/
+
+
+ namespace trait
+ {
+
+ template <typename H, typename S, typename V>
+ struct set_precise_binary_< op::plus, mln::value::hsv_<H,S,V>,
+ mln::value::hsv_<H,S,V> >
+ {
+ typedef mln::value::hsv_<H,S,V> ret;
+ };
+
+ template <typename H, typename S, typename V>
+ struct set_precise_binary_< op::minus, mln::value::hsv_<H,S,V>,
+ mln::value::hsv_<H,S,V> >
+ {
+ typedef mln::value::hsv_<H,S,V> ret;
+ };
+
+ template <typename H, typename S, typename V, typename S2>
+ struct set_precise_binary_< op::times, mln::value::hsv_<H,S,V>,
+ mln::value::scalar_<S2> >
+ {
+ typedef mln::value::hsv_<H,S,V> ret;
+ };
+
+ template <typename H, typename S, typename V, typename S2>
+ struct set_precise_binary_< op::div, mln::value::hsv_<H,S,V>,
+ mln::value::scalar_<S2> >
+ {
+ typedef mln::value::hsv_<H,S,V> ret;
+ };
+
+
+ // FIXME : Is there any way more generic? a way to factor
+ // set_precise_binary_< op::div, mln::value::hsv_<H,S,V>, mln::value::scalar_<S> >
+ // and
+ // set_precise_binary_< op::div, mln::value::hsv_<H,S,V>, mln::value::int_u<m> >
+ // as for op::times.
+
+ template <typename H, typename S, typename V, unsigned m>
+ struct set_precise_binary_< op::times, mln::value::hsv_<H,S,V>,
+ mln::value::int_u<m> >
+ {
+ typedef mln::value::hsv_<H,S,V> ret;
+ };
+
+ template <typename H, typename S, typename V, unsigned m>
+ struct set_precise_binary_< op::div, mln::value::hsv_<H,S,V>,
+ mln::value::int_u<m> >
+ {
+ typedef mln::value::hsv_<H,S,V> ret;
+ };
+
+ template <typename H, typename S, typename V>
+ struct value_< mln::value::hsv_<H,S,V> >
+ {
+ enum {
+ dim = 3,
+ nbits = (sizeof (H) + sizeof (S) + sizeof (V)) * 8,
+ card = mln_value_card_from_(nbits)
+ };
+
+ typedef trait::value::nature::vectorial nature;
+ typedef trait::value::kind::color kind;
+ typedef mln_value_quant_from_(card) quant;
+
+ typedef void comp;
+ typedef H comp_0;
+ typedef S comp_1;
+ typedef V comp_2;
+
+ template <typename VAL>
+ static comp_0 get_comp_0(const VAL& v) { return v.hue(); }
+
+ template <typename VAL>
+ static comp_1 get_comp_1(const VAL& v) { return v.sat(); }
+
+ template <typename VAL>
+ static comp_2 get_comp_2(const VAL& v) { return v.val(); }
+
+ typedef mln::value::hsv_<H,S,V> sum;
+ };
+
+ } // end of namespace trait
+
+
+ namespace value
+ {
+
+ template <typename E>
+ struct HSV : Object<E>
+ {
+ };
+
+ template <typename H, typename S, typename V>
+ class hsv_ : public HSV< hsv_<H,S,V> >
+ {
+ public:
+
+ typedef H h_type;
+ typedef S s_type;
+ typedef V v_type;
+
+ /// Constructor without argument.
+ hsv_()
+ {
+ }
+
+ hsv_(const literal::zero_t&)
+ : hue_(0),
+ sat_(0),
+ val_(0)
+ {
+ }
+
+ /// Constructor from component values.
+ hsv_(const H& hue, const S& sat, const V& val)
+ : hue_(hue),
+ sat_(sat),
+ val_(val)
+ {
+ }
+
+ /// Read-only access to the hue component.
+ const H& hue() const;
+ const S& sat() const;
+ const V& val() const;
+
+ /// Read-write access to the hue component.
+ H& hue();
+ S& sat();
+ V& val();
+
+ private:
+ //FIXME: Don't we want to store these values in a vector?
+ H hue_;
+ S sat_;
+ V val_;
+ };
+
+
+ typedef hsv_<float, float, float> hsv_f;
+ typedef hsv_<double, double, double> hsv_d;
+
+
+ /// Print an hsv \p c into the output stream \p ostr.
+ ///
+ /// \param[in,out] ostr An output stream.
+ /// \param[in] c An rgb.
+ ///
+ /// \return The modified output stream \p ostr.
+ template <typename H, typename S, typename V>
+ std::ostream& operator<<(std::ostream& ostr, const hsv_<H,S,V>& c);
+
+
+ /// Addition.
+ /// {
+ template <typename H, typename S, typename V>
+ hsv_<H,S,V>
+ operator+(const hsv_<H,S,V>& lhs, const hsv_<H,S,V>& rhs);
+ /// \}
+
+ /// Subtraction.
+ /// \{
+ template <typename H, typename S, typename V>
+ hsv_<H,S,V>
+ operator-(const hsv_<H,S,V>& lhs, const hsv_<H,S,V>& rhs);
+ /// \}
+
+ /// Product.
+ /// \{
+ template <typename H, typename S, typename V, typename S2>
+ hsv_<H,S,V>
+ operator*(const hsv_<H,S,V>& lhs, const mln::value::scalar_<S2>& s);
+ /// \}
+
+ /// Division.
+ /// \{
+ template <typename H, typename S, typename V, typename S2>
+ hsv_<H,S,V>
+ operator/(const hsv_<H,S,V>& lhs, const mln::value::scalar_<S2>& s);
+ /// \}
+
+ /// Comparison.
+ /// \{
+ template <typename H, typename S, typename V>
+ bool
+ operator==(const hsv_<H,S,V>& lhs, const hsv_<H,S,V>& rhs);
+ /// \}
+
+ } // end of namespace mln::value
+
+
+
+ // More forward declarations
+ namespace fun
+ {
+ namespace v2v
+ {
+
+ template <typename T_hsv>
+ struct f_rgb_to_hsv_;
+
+ typedef f_rgb_to_hsv_<value::hsv_f> f_rgb_to_hsv_f_t;
+
+ extern f_rgb_to_hsv_f_t f_rgb_to_hsv_f;
+
+ }
+
+ }
+
+# ifndef MLN_INCLUDE_ONLY
+
+
+ namespace value
+ {
+
+ template <typename H, typename S, typename V>
+ const H&
+ hsv_<H,S,V>::hue() const
+ {
+ return this->hue_;
+ }
+
+ template <typename H, typename S, typename V>
+ const S&
+ hsv_<H,S,V>::sat() const
+ {
+ return this->sat_;
+ }
+
+ template <typename H, typename S, typename V>
+ const V&
+ hsv_<H,S,V>::val() const
+ {
+ return this->val_;
+ }
+
+ template <typename H, typename S, typename V>
+ H&
+ hsv_<H,S,V>::hue()
+ {
+ return this->hue_;
+ }
+
+ template <typename H, typename S, typename V>
+ S&
+ hsv_<H,S,V>::sat()
+ {
+ return this->sat_;
+ }
+
+ template <typename H, typename S, typename V>
+ V&
+ hsv_<H,S,V>::val()
+ {
+ return this->val_;
+ }
+
+
+ template <typename H, typename S, typename V>
+ inline
+ std::ostream& operator<<(std::ostream& ostr, const hsv_<H,S,V>& v)
+ {
+ return ostr << '(' << debug::format(v.hue())
+ << ',' << debug::format(v.sat())
+ << ',' << debug::format(v.val())
+ << ')';
+ }
+
+
+ template <typename H, typename S, typename V>
+ hsv_<H,S,V>
+ operator+(const hsv_<H,S,V>& lhs, const hsv_<H,S,V>& rhs)
+ {
+ return hsv_<H,S,V>(lhs.hue() + rhs.hue(),
+ lhs.sat() + rhs.sat(),
+ lhs.val() + rhs.val());
+ }
+
+
+ template <typename H, typename S, typename V>
+ hsv_<H,S,V>
+ operator-(const hsv_<H,S,V>& lhs, const hsv_<H,S,V>& rhs)
+ {
+ return hsv_<H,S,V>(lhs.hue() - rhs.hue(),
+ lhs.sat() - rhs.sat(),
+ lhs.val() - rhs.val());
+ }
+
+
+ template <typename H, typename S, typename V, typename S2>
+ hsv_<H,S,V>
+ operator*(const hsv_<H,S,V>& lhs, const mln::value::scalar_<S2>& s)
+ {
+ return hsv_<H,S,V>(lhs.hue() * s,
+ lhs.sat() * s,
+ lhs.val() * s);
+ }
+
+
+ template <typename H, typename S, typename V, typename S2>
+ hsv_<H,S,V>
+ operator/(const hsv_<H,S,V>& lhs, const mln::value::scalar_<S2>& s)
+ {
+ return hsv_<H,S,V>(lhs.hue() / s,
+ lhs.sat() / s,
+ lhs.val() / s);
+ }
+
+ template <typename H, typename S, typename V>
+ bool
+ operator==(const hsv_<H,S,V>& lhs, const hsv_<H,S,V>& rhs)
+ {
+ return lhs.hue() == rhs.hue()
+ && lhs.sat() == rhs.sat()
+ && lhs.val() == rhs.val();
+ }
+
+ } // end of namespace mln::value
+
+/*
+ namespace convert
+ {
+
+ namespace over_load
+ {
+
+ inline
+ void
+ from_to_(const value::rgb<16>& from, value::hsv_<float,float,float>& to)
+ {
+ to = fun::v2v::f_rgb_to_hsv_f(from);
+ }
+
+ inline
+ void
+ from_to_(const value::rgb<8>& from, value::hsv_<float,float,float>& to)
+ {
+ to = fun::v2v::f_rgb_to_hsv_f(from);
+ }
+
+ } // end of namespace mln::convert::over_load
+
+ } // end of namespace mln::convert
+*/
+
+# endif // ! MLN_INCLUDE_ONLY
+
+
+} // end of namespace mln
+
+#endif // ! MLN_VALUE_HSV_HH
diff --git a/scribo/sandbox/green/mln/value/rg.hh b/scribo/sandbox/green/mln/value/rg.hh
new file mode 100644
index 0000000..d083ffd
--- /dev/null
+++ b/scribo/sandbox/green/mln/value/rg.hh
@@ -0,0 +1,175 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena. If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License. This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+#ifndef MLN_VALUE_RG_HH
+# define MLN_VALUE_RG_HH
+
+/// \file
+///
+/// \brief Define the red/green vectorial image type.
+///
+/// This source implements the red/green (RG) vectorial image type. It
+/// is a partial copy of the rgb type. This type doesn't manage
+/// anykind of interaction. Its purpose is limited to store a couple
+/// of values. Do not use it outside this purpose, i can't garantie
+/// the behaviour.
+///
+/// The following sample is a typical use of the rg type.
+///
+/// #include <mln/accu/stat/histo2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<unsigned> t_histo;
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+/// t_histo histo;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+/// histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+///
+/// return 0;
+/// }
+
+
+# include <mln/algebra/vec.hh>
+# include <mln/value/concept/vectorial.hh>
+# include <mln/value/int_u.hh>
+# include <mln/value/rgb8.hh>
+# include <mln/trait/value_.hh>
+
+
+namespace mln
+{
+
+ namespace value
+ {
+
+ // Forward declaration.
+ template <unsigned n> struct rg;
+
+ } // end of namespace mln::value
+
+ namespace trait
+ {
+
+ template <unsigned n>
+ struct value_< mln::value::rg<n> >
+ {
+ enum {
+ dim = 2,
+ nbits = dim * n,
+ card = mln_value_card_from_(nbits)
+ };
+
+ typedef trait::value::nature::vectorial nature;
+ typedef trait::value::kind::color kind;
+ typedef trait::value::quant::high quant;
+
+ typedef void comp;
+ typedef mln::value::int_u<n> comp_0;
+ typedef mln::value::int_u<n> comp_1;
+
+ static comp_0 get_comp_0(const mln::value::rg<n>& v){return v.red(); }
+ static comp_1 get_comp_1(const mln::value::rg<n>& v){return v.green();}
+
+ typedef algebra::vec<dim, float> sum;
+
+ static const char* name()
+ {
+ static std::string s = std::string("rg").append(1, 8 + '0');
+ return s.c_str();
+ }
+ };
+
+ } // end of namespace mln::trait
+
+ namespace value
+ {
+
+ /// \brief Define the red/green vectorial image type.
+ ///
+ /// Param n defines the quantification used for red/green space.
+
+ template <unsigned n>
+ struct rg :public mln::value::Vectorial< rg<n> >,
+ public internal::value_like_<
+ algebra::vec< 2, int_u<n> >, // Equivalent.
+ algebra::vec< 2, int_u<n> >, // Encoding.
+ algebra::vec< 2, int >, // Interoperation.
+ rg<n> > // Exact.
+ {
+ typedef int_u<n> t_red;
+ typedef int_u<n> t_green;
+
+ int_u<n> red() const {return this->v_[0];}
+ int_u<n>& red() {return this->v_[0];}
+ int_u<n> green() const {return this->v_[1];}
+ int_u<n>& green() {return this->v_[1];}
+
+ /// Constructors
+ /// \{
+ /// \brief Create a rg value.
+ ///
+ /// Two constructors exist, the first one do nothing and the second one
+ /// initializes the red/green components from a rgb value.
+ rg(){}
+ rg(const rgb8& val){this->v_[0] = val.red(); this->v_[1] = val.green();}
+ /// \}
+
+ /// \brief Affect a rg value to this object.
+ /// \param[in] rhs the value to affect to this object.
+ ///
+ /// If the two objects are different, then then copy the
+ /// underline array of values.
+
+ rg operator=(const rg& rhs)
+ {
+ if (&rhs != this)
+ this->v_ = rhs.v_;
+
+ return *this;
+ }
+ };
+
+ } // end of namespace mln::value
+
+} // end of namespace mln
+
+#endif // ! MLN_VALUE_RG_HH
diff --git a/scribo/sandbox/green/tests/accu/stat/histo1d/Makefile.am b/scribo/sandbox/green/tests/accu/stat/histo1d/Makefile.am
new file mode 100644
index 0000000..77f9015
--- /dev/null
+++ b/scribo/sandbox/green/tests/accu/stat/histo1d/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/tests
+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)/
+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/tests/accu/stat/histo1d/histo1d.cc b/scribo/sandbox/green/tests/accu/stat/histo1d/histo1d.cc
new file mode 100644
index 0000000..5a5c4c4
--- /dev/null
+++ b/scribo/sandbox/green/tests/accu/stat/histo1d/histo1d.cc
@@ -0,0 +1,21 @@
+/// TEST HISTO1D
+
+#include <mln/accu/stat/histo1d.hh>
+#include <mln/data/compute.hh>
+#include <mln/core/image/image1d.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;
+ mln::image2d<t_int_u8> img;
+ mln::image1d<unsigned> histo;
+
+ mln::io::pgm::load(img, OLENA_IMG_PATH"/lena.pgm");
+ histo = mln::data::compute(mln::accu::meta::stat::histo1d(), img);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am b/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
new file mode 100644
index 0000000..a96b2e9
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo1d/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/use
+BUILD__PATTERN= green/build/use
+
+
+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/use/accu/stat/histo1d/histo1d.cc b/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
new file mode 100644
index 0000000..1c6176b
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
@@ -0,0 +1,24 @@
+/// \file
+///
+/// \brief Minimal code for building 1d image histogram version.
+///
+
+#include <mln/accu/stat/histo1d.hh>
+#include <mln/data/compute.hh>
+#include <mln/core/image/image1d.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;
+ mln::image2d<t_int_u8> img;
+ mln::image1d<unsigned> histo;
+
+ mln::io::pgm::load(img, OLENA_IMG_PATH"/lena.pgm");
+ histo = mln::data::compute(mln::accu::meta::stat::histo1d(), img);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo2d/Makefile.am b/scribo/sandbox/green/use/accu/stat/histo2d/Makefile.am
new file mode 100644
index 0000000..a96b2e9
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo2d/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/use
+BUILD__PATTERN= green/build/use
+
+
+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/use/accu/stat/histo2d/histo2d.cc b/scribo/sandbox/green/use/accu/stat/histo2d/histo2d.cc
new file mode 100644
index 0000000..6369b5a
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo2d/histo2d.cc
@@ -0,0 +1,33 @@
+/// \file
+///
+/// \brief Minimal code for building 2d image histogram version.
+///
+
+#include <mln/accu/stat/histo2d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+ typedef mln::image2d<t_rg8> t_image2d_rg8;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<unsigned> t_histo;
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rg8 img_rg8;
+ t_histo histo;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+ img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+ histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+
+ return 0;
+}
--
1.5.6.5
14 years, 6 months
- 1
- 0
last-svn-commit-42-g0bf1f8f Import files from milena/sandbox/green.
by Yann Jacquelet
* mln/accu/stat/histo1d.hh: New header file.
* mln/accu/stat/histo2d.hh: New header file.
* mln/accu/stat/histo3d_hsl.hh: New header file.
* mln/accu/stat/histo3d_rgb.hh: New header file.
* mln/clustering/k_mean.hh: New header file.
* mln/clustering/kmean1d.hh: New header file.
* mln/clustering/kmean2d.hh: New header file.
* mln/clustering/kmean3d.hh: New header file.
* mln/clustering/kmean_rgb.hh: New header file.
* mln/display/display_histo.hh: New header file.
* mln/display/project_histo.hh: New header file.
* mln/fun/p2b/achromatic.hh: New header file.
* mln/fun/p2b/component_equals.hh: New header file.
* mln/fun/v2v/achromatism.hh: New header file.
* mln/fun/v2v/hue_concentration.hh: New header file.
* mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
* mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
* mln/fun/v2v/log.hh: New header file.
* mln/fun/v2v/rg_to_rgb.hh: New header file.
* mln/fun/v2v/rgb8_to_int_u8: New header file.
* mln/fun/v2v/rgb_to_achromastism_map.hh: New header file.
* mln/fun/v2v/rgb_to_hsv.hh: New header file.
* mln/fun/v2v/rgb_to_hue_map.hh: New header file.
* mln/fun/v2v/rgb_to_saturation_map.hh: New header file.
* mln/fun/v2v/rgb_to_value_map.hh: New header file.
* mln/img_path.hh: New header file.
* mln/io/plot/save_image_sh.hh: New header file.
* mln/math/cell.hh: New header file.
* mln/math/floor.hh: New header file.
* tests/accu/stat/histo1d/Makefile.am: New makefile.
* tests/accu/stat/histo1d/histo1d.cc: New source.
* tests/accu/stat/histo2d/Makefile.am: New makefile.
* tests/accu/stat/histo2d/histo2d.cc: New source.
---
scribo/sandbox/green/ChangeLog | 47 +
scribo/sandbox/green/README | 223 ++++-
scribo/sandbox/green/mln/accu/stat/histo1d.hh | 340 +++++++
scribo/sandbox/green/mln/accu/stat/histo2d.hh | 358 +++++++
.../sandbox/green/mln/accu/stat/histo3d_hsl.hh | 0
.../sandbox/green/mln/accu/stat/histo3d_rgb.hh | 0
.../sandbox/green/mln/clustering/k_mean.hh | 0
.../sandbox/green/mln/clustering/kmean1d.hh | 0
.../sandbox/green/mln/clustering/kmean2d.hh | 0
.../sandbox/green/mln/clustering/kmean3d.hh | 0
.../sandbox/green/mln/clustering/kmean_rgb.hh | 0
.../sandbox/green/mln/display/display_histo.hh | 0
.../sandbox/green/mln/display/project_histo.hh | 0
.../sandbox/green/mln/fun/p2b/achromatic.hh | 0
.../sandbox/green/mln/fun/p2b/component_equals.hh | 0
.../sandbox/green/mln/fun/v2v/achromatism.hh | 0
.../sandbox/green/mln/fun/v2v/hue_concentration.hh | 0
.../green/mln/fun/v2v/int_u16_to_int_u14.hh | 0
.../sandbox/green/mln/fun/v2v/log.hh | 0
.../sandbox/green/mln/fun/v2v/rg_to_rgb.hh | 0
.../sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh | 0
.../sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh | 0
.../green/mln/fun/v2v/rgb_to_achromatism_map.hh | 0
.../sandbox/green/mln/fun/v2v/rgb_to_hsv.hh | 0
.../sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh | 0
scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh | 111 ++
.../green/mln/fun/v2v/rgb_to_saturation_map.hh | 0
.../sandbox/green/mln/fun/v2v/rgb_to_value_map.hh | 0
{milena => scribo}/sandbox/green/mln/img_path.hh | 0
scribo/sandbox/green/mln/io/plot/save_image_sh.hh | 1056 ++++++++++++++++++++
{milena => scribo}/sandbox/green/mln/math/ceil.hh | 0
{milena => scribo}/sandbox/green/mln/math/floor.hh | 0
{milena => scribo}/sandbox/green/mln/value/hsv.hh | 0
scribo/sandbox/green/mln/value/rg.hh | 175 ++++
.../green/tests/accu/stat/histo1d/Makefile.am | 153 +++
.../green/tests/accu/stat/histo1d/histo1d.cc | 21 +
.../green/use/accu/stat/histo1d/Makefile.am | 153 +++
.../sandbox/green/use/accu/stat/histo1d/histo1d.cc | 24 +
.../green/use/accu/stat/histo2d/Makefile.am | 153 +++
.../sandbox/green/use/accu/stat/histo2d/histo2d.cc | 33 +
40 files changed, 2829 insertions(+), 18 deletions(-)
create mode 100644 scribo/sandbox/green/mln/accu/stat/histo1d.hh
create mode 100644 scribo/sandbox/green/mln/accu/stat/histo2d.hh
copy {milena => scribo}/sandbox/green/mln/accu/stat/histo3d_hsl.hh (100%)
copy {milena => scribo}/sandbox/green/mln/accu/stat/histo3d_rgb.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/k_mean.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean1d.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean2d.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean3d.hh (100%)
copy {milena => scribo}/sandbox/green/mln/clustering/kmean_rgb.hh (100%)
copy {milena => scribo}/sandbox/green/mln/display/display_histo.hh (100%)
copy {milena => scribo}/sandbox/green/mln/display/project_histo.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/p2b/achromatic.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/p2b/component_equals.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/achromatism.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/hue_concentration.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/log.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rg_to_rgb.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh (100%)
create mode 100644 scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh (100%)
copy {milena => scribo}/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh (100%)
copy {milena => scribo}/sandbox/green/mln/img_path.hh (100%)
create mode 100644 scribo/sandbox/green/mln/io/plot/save_image_sh.hh
copy {milena => scribo}/sandbox/green/mln/math/ceil.hh (100%)
copy {milena => scribo}/sandbox/green/mln/math/floor.hh (100%)
copy {milena => scribo}/sandbox/green/mln/value/hsv.hh (100%)
create mode 100644 scribo/sandbox/green/mln/value/rg.hh
create mode 100644 scribo/sandbox/green/tests/accu/stat/histo1d/Makefile.am
create mode 100644 scribo/sandbox/green/tests/accu/stat/histo1d/histo1d.cc
create mode 100644 scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
create mode 100644 scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
create mode 100644 scribo/sandbox/green/use/accu/stat/histo2d/Makefile.am
create mode 100644 scribo/sandbox/green/use/accu/stat/histo2d/histo2d.cc
diff --git a/scribo/sandbox/green/ChangeLog b/scribo/sandbox/green/ChangeLog
index ed399c5..6a3c8fa 100644
--- a/scribo/sandbox/green/ChangeLog
+++ b/scribo/sandbox/green/ChangeLog
@@ -1,3 +1,50 @@
+2010-06-24 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Import files from milena/sandbox/green.
+
+ * mln/accu/stat/histo1d.hh: New header file.
+ * mln/accu/stat/histo2d.hh: New header file.
+ * mln/accu/stat/histo3d_hsl.hh: New header file.
+ * mln/accu/stat/histo3d_rgb.hh: New header file.
+ * mln/clustering/k_mean.hh: New header file.
+ * mln/clustering/kmean1d.hh: New header file.
+ * mln/clustering/kmean2d.hh: New header file.
+ * mln/clustering/kmean3d.hh: New header file.
+ * mln/clustering/kmean_rgb.hh: New header file.
+ * mln/display/display_histo.hh: New header file.
+ * mln/display/project_histo.hh: New header file.
+ * mln/fun/p2b/achromatic.hh: New header file.
+ * mln/fun/p2b/component_equals.hh: New header file.
+ * mln/fun/v2v/achromatism.hh: New header file.
+ * mln/fun/v2v/hue_concentration.hh: New header file.
+ * mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
+ * mln/fun/v2v/int_u16_to_int_u14.hh: New header file.
+ * mln/fun/v2v/log.hh: New header file.
+ * mln/fun/v2v/rg_to_rgb.hh: New header file.
+ * mln/fun/v2v/rgb8_to_int_u8: New header file.
+ * mln/fun/v2v/rgb_to_achromastism_map.hh: New header file.
+ * mln/fun/v2v/rgb_to_hsv.hh: New header file.
+ * mln/fun/v2v/rgb_to_hue_map.hh: New header file.
+ * mln/fun/v2v/rgb_to_saturation_map.hh: New header file.
+ * mln/fun/v2v/rgb_to_value_map.hh: New header file.
+ * mln/img_path.hh: New header file.
+ * mln/io/plot/save_image_sh.hh: New header file.
+ * mln/math/cell.hh: New header file.
+ * mln/math/floor.hh: New header file.
+ * tests/accu/stat/histo1d/Makefile.am: New makefile.
+ * tests/accu/stat/histo1d/histo1d.cc: New source.
+ * tests/accu/stat/histo2d/Makefile.am: New makefile.
+ * tests/accu/stat/histo2d/histo2d.cc: New source.
+
+2010-06-21 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
+
+ Save histogram library.
+
+ * mln/accu/histo/histo1d.hh: New header file.
+ * mln/accu/histo/histo2d.hh: New header file.
+ * mln/accu/histo/histo3d_rgb.hh: New header file.
+ * mln/accu/histo/histo3d_hsl.hh: New header file.
+
2010-06-21 Yann Jacquelet <jacquelet(a)lrde.epita.fr>
Simple integration test.
diff --git a/scribo/sandbox/green/README b/scribo/sandbox/green/README
index 4eb71b7..3efe50d 100644
--- a/scribo/sandbox/green/README
+++ b/scribo/sandbox/green/README
@@ -1,32 +1,219 @@
-Le travail est classé dans deux répertoires ok et ko.
-Le répertoire ok correspond aux sources qui ont été reprises et retestées.
-Le répertoire ko correspond aux sources qui ont été juste transférées.
+I ARBORESCENCE
+--------------
-La première brique logicielle importante sur laquelle s'appuie mes travaux est
-la création d'histogrammes sous forme d'image.
+bench ==> Comparaison d'algorithmes d'un point de vue temps d'exécution.
+bug ==> Bug rencontrés dans milena et archivés sous forme de programme.
+build ==> Répertoire d'exécution, non sauvé dans git.
+demo ==> Première version d'un algorithme pour voir son comportement.
+doc ==> Documentation tex ou code minimal pour de petits exemples.
+exp ==> Version avancée des algorithmes pour traitées les bases de données.
+mln ==> Partie mise en librairie milena des différents travaux.
+tests ==> Tests unitaires sur certains algorithmes.
+tools ==> Découpage de certains algorithmes pour mieux les tester séparément.
+use ==> Test de compilation, code minimal pour compiler un élément.
+II COMPILATION
+--------------
-CREATION DES HISTOGRAMMES
--------------------------
+L'unité minimale de code choisie est le répertoire.
+Donc aller dans le répertoire qui nous interesse,
+par exemple, green/demo/annotating/hsv et lancé le make
-ko/mln/accu/stat/histo1d.hh: histogramme image valeur scalaire.
-ko/mln/accu/stat/histo2d.hh: histogramme image valeur vectorielle 2d.
-ko/mln/accu/stat/histo3d_hsl.hh: histogramme image valeur vectorielle 3d (HSL).
-ko/mln/accu/stat/histo3d_rgb.hh: histogramme image valeur vectorielle 3d (RGB).
+#:~/git/olena/scribo/sandbox/green$cd demo/annotating/hsv
+#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$ make -f Makefile.am
+Cette opération créé dans build le répertoire de compilation
+green/build/demo/annotating/hsv. Dans ce répertoire aura été copié un
+Makefile et tous les fichiers qui ne sont pas des sources. Par
+exemple, des fichiers de calibration comme gaussian.sh (pour vérifier
+la mire du filtre de gaussienne) ou de la documentation à la sauvette
+sous forme de fichiers textes jetés à la va vite dans le répertoire
+pour ne pas perdre l'information recherchée. En l'occurence, ici, il
+n'y a rien à copier. Rendons-nous dans le répertoire de compilation et lançons
+le makefile.
+#:~/git/olena/scribo/sandbox/green/demo/annotating/hsv$
+cd ../../../build/demo/annotating/hsv
+#:~/git/olena/scribo/sandbox/green/build/demo/annotating/hsv$ make clean all
-ok/mln/accu/histo/histo1d.hh: histogramme image valeur scalaire entière.
-ok/mln/accu/histo/histo2d.hh: histogramme image valeur vectorielle 2d entière.
-ok/mln/accu/histo/histo3d.hh: histogramme image valeur vectorielle 3d entière.
+L'exécutable est généré par le makefile, il porte le nom du
+répertoire. Si il y a besoin de mettre à jour le makefile, le faire
+dans le répertoire des sources en éditant Makefile.am, puis en
+régénérant le Makefile dans le répertoire d'exécution par la commande
+make -f Makefile.am depuis le répertoire source.
-SAUVEGARDE DES HISTOGRAMMES
----------------------------
+III MAKEFILE
+------------
+Les makefiles utilisés sont tous les mêmes avec quelques variables
+dont le contenu change dans leur partie en-tête.
+Pour chaque répertoire, le makefile doit savoir si le chemin courant
+est un répertoire de compilation ou un répertoire de source. Pour les
+identifier, il a recours à un pattern qui malheureusemnt fait
+intervenir le nom de la branche de développement (bench,demo,bug,exp ...).
+SOURCE_PATTERN= green/demo
+BUILD__PATTERN= green/build/demo
-VISUALISATION DES HISTOGRAMMES
-------------------------------
\ No newline at end of file
+Si un makefile ne fonctionne pas, il faut vérifier ceci en premier
+lieu. Ici, le makefile doit être situé dans la branche démo.
+
+Autre élément à savoir, la compilation nécessite d'inclure la
+librairie milena, ainsi que les développements propres en vu de leur
+intégration futur dans milena, ceci est fait par un jeu d'INCLUDES1
+et INCLUDES2.
+
+INCLUDES1= -I$(HOME)/git/olena/scribo/sandbox/green
+INCLUDES2= -I$(HOME)/git/olena/milena
+INCLUDES= $(INCLUDES1) $(INCLUDES2)
+
+Suivant l'allure du compte où l'on exécute les makefiles, il faut
+revoir le chemin pour trouver des deux répertoires.
+
+Enfin, les options de compilations ne sont pas toujours les mêmes. Les
+trois lignes possibles sont toutes présentes et seule celle qui est
+utilisée n'est pas commentée. Typiquement, dans la branche de
+développement démo où les perfomances ne sont pas le problème, on
+compilera avec tout le matériel pour utiliser gdb et sans
+optimisation. A l'inverse, dans la branche d'expérimentation, où le
+code a déjà été testé, on cherche à aller vite car on exécute ce code
+sur de nombreuses images. Dans cette optique, pas de débugage, pas de
+traçage, optimisation conséquente.
+
+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)
+
+Une dernière dernière information, dans le cadre des développements
+exp, et tools, on utilise la librairie boost soit pour la
+virtualisation du filesystem, soit pour le formatage des fichiers text
+(réalisation de colonnes, mettre des entiers sur un certain nombre de
+caractères). Une ligne de chargement des librairies peut apparaitre donc.
+
+LOADLIBES= -lboost_filesystem
+
+On retrouvera les includes suivantes dans les sources:
+
+#include <boost/format.hpp>
+#include <boost/filesystem.hpp>
+
+
+IV CHEMINS DES IMAGES
+---------------------
+
+Toutes les images ont toujours été locales sur mon ordinateur. La
+politique a toujours été d'utiliser un fichier img_path pour coder les
+chemins des images. Les chemins étant plutôt long, j'ai toujours eu
+tendance à faire en sorte qu'ils soient compilés en dur (sauf pour la
+partie développement tools qui est vraiment voué à donner des
+exécutables indépendants et génériques). Le fichier mln/img_path.hh
+code la position de toutes les images dans mon arborescence. Il faudra
+donc veiller à changer tous les chemins pour les adapter au compte
+dans lequel on voudra reprendre le code. Dans le code, les références
+aux positions des images sont faites via des macros.
+
+Toutes les images sont située dans git/img. En règle générale, je ne
+traite que des images au format .pgm, .pbm et .ppm. Il m'arrive
+fréquemment de dumper des images au format .sh (gnuplot shell
+image). Pour la branche tools, nous avons utilisé les dumps de milena
+comme format de transfert d'un utilitaire à un autre. Les images sont
+classées suivant leur provenance. Nous avons tout d'abord la base
+OLENA (copie des images de tests milena), la base INIM (très peu
+utilisée voire jamais), la base ICDAR (très utilisée, surtout dans
+exp), la base AFP (très utilisée dans exp) et les bases ANNOTATING1 et
+ANNOTATING2 (pas très utilisées ni l'une, ni l'autre).
+
+La plus part du temps, sauver les résultats dans le répertoire
+d'exécution courant est largement suffisant. Parfois, il est
+nécessaire de sauvegarder de grosses quantités d'informations et de
+les classer comme dans la branche de développement exp. C'est pour
+cela, qu'un certain nombre de macros définissent des endroits pour
+sauvegarder les résultats lors d'expérimentation de grande ampleur sur
+toute la base ICDAR ou AFP.
+
+
+V GNUPLOT SCRIPT SHELL IMAGE FORMAT
+-----------------------------------
+
+J'abrège le nom du format par gnuplot shell format. En fait, c'est un
+format d'image particulier qui a besoin de gnuplot pour être lu. Il
+est donc compatible avec aucun viewer si ce n'est gnuplot, mais a la
+caractéristique d'afficher tous les points de manière visible. Par
+ailleurs, comme il s'agit d'un script gnuplot il permet d'insérer très
+facilement une fonction pour visualiser les données autrement (par
+exemple, changer d'espace: HSL, HSV). Le fichier tire son nom de la
+façon dont il fonctionne. C'est un script shell qui fait un appel à
+gnuplot et lui passe le jeu de données directement à partir de ce même
+fichier, pas besoin de faire appel à un autre fichier. Une fois
+généré, le fichier doit être modifié pour avoir les permissions
+d'exécution (chmod 755 gnuplot_shell_file.sh). Comme je trouve le format
+extrêmement pratique, il se retrouve preque partout dans mes sources.
+
+
+V MLN
+-----
+
+a) La sauvegarde des images au format gnuplot shell
+
+* mln/io/plot/save_image_sh.hh: Librairie sauvegarde format gnuplot shell.
+
+to do ...
+
+
+
+b) Les histogrammes
+
+Un des travaux demandés par théo est la réalisation d'une librairie
+d'histogramme permettant de fournir un résultat sous forme d'image.
+L'intérêt est ensuite de pouvoir filtrer directement ces histogrammes
+par les algorithmes de milena, ou encore d'étudier les valeurs
+caractéristiques par d'autres accumulateurs. Les codes réellement
+utilisés sont histo1d et histo3d RGB. Tous les autres codes sont très
+expérimentaux. Notemment, le code HSL demande de quantifier l'espace
+de comptage puisqu'il est décrit sous la forme de triplets de float
+(les autres sont inférés). Néanmoins, le code est à conserver car il
+contient une séquence d'appels pour les routines permettant de
+considérer la dimension de la teinte comme circulaire.
+
+* mln/accu/stat/histo1d.hh: Accumulateur histogramme image1d.
+* use/accu/stat/histo1d: Code minimal utilisant un histogramme 1d.
+
+* mln/accu/stat/histo2d.hh: Accumulateur histogramme image2d.
+* mln/value/rg.hh: Définition du type vectoriel 2d rouge/vert (RG).
+* mln/fun/v2v/rgb_to_rg.hh: Transformation de l'espace RGB vers l'espace RG.
+* use/accu/stat/histo2d: Code minimal utilisant un histogramme 2d.
+
+
+* mln/accu/stat/histo3d_rgb.hh: Accumulateur histogramme image3d RGB.
+* mln/accu/stat/histo3d_hsl.hh: Accumulateur histogramme image3d HSL.
+
+* use/accu/stat/histo3_rgb: Code minimal utilisant un histogramme 3d RGB.
+* use/accu/stat/histo3_hsl: Code minimal utilisant un histogramme 3d HSL.
+
+
+
+* tests/accu/stat/histo1d
+
+
+
+
+* tests/accu/stat/histo2d
+
+
+
+* use/accu/stat/histo3d_rgb
+* tests/accu/stat/histo3d_rgb
+
+* use/accu/stat/histo3d_hsl
+* tests/accu/stat/histo3d_hsl
+
+
+c) La visualisation des histogrammes 3d
+
+* demo/accu/stat/histo2d
+
+* mln/display/dispay_histo.hh
+* mln/displayproject_histo.hh
diff --git a/scribo/sandbox/green/mln/accu/stat/histo1d.hh b/scribo/sandbox/green/mln/accu/stat/histo1d.hh
new file mode 100644
index 0000000..d480cf0
--- /dev/null
+++ b/scribo/sandbox/green/mln/accu/stat/histo1d.hh
@@ -0,0 +1,340 @@
+// 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.
+
+#ifndef MLN_ACCU_STAT_HISTO1D_HH
+#define MLN_ACCU_STAT_HISTO1D_HH
+
+/// \file
+///
+/// \brief Define a histogram as accumulator which returns an image1d.
+///
+/// This source implements the discrete histogram version. It was
+/// created for images which the values are derived from integer
+/// type. The number of bins is directly infered from the cardinality
+/// of the image value. So the int_u8 image has got 256 bins, the
+/// int_u<14> image has got 16384 bins. But, this code doesn't work
+/// for that quantification because of the coord limitation (signed
+/// short, as it is defined in mln/core/def/coord.hh). Take care of
+/// the limitation from the result image value. We hard code unsigned,
+/// but it sometimes not enought to count data in one bin. That last
+/// case has not occured since the beginning of the creation of the type.
+///
+/// The following sample is a typical use of the histogram.
+///
+/// #include <mln/accu/stat/histo1d.hh>
+/// #include <mln/data/compute.hh>
+/// #include <mln/core/image/image1d.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;
+/// mln::image2d<t_int_u8> img;
+/// mln::image1d<unsigned> histo;
+///
+/// mln::io::pgm::load(img, OLENA_IMG_PATH"/lena.pgm");
+/// histo = mln::data::compute(mln::accu::meta::histo::histo1d(), img);
+///
+/// return 0;
+/// }
+
+
+#include <iostream>
+
+#include <mln/accu/internal/base.hh>
+
+#include <mln/arith/plus.hh>
+
+#include <mln/core/concept/meta_accumulator.hh>
+#include <mln/core/image/image1d.hh>
+#include <mln/core/macros.hh>
+
+#include <mln/literal/zero.hh>
+
+#include <mln/trace/entering.hh>
+#include <mln/trace/exiting.hh>
+
+#include <mln/trait/value/comp.hh>
+
+#include <mln/value/ops.hh>
+
+namespace mln
+{
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ // Forward declaration
+ template <typename V>
+ struct histo1d;
+
+ } // end of namespace mln::accu::stat
+
+
+ namespace meta
+ {
+
+ namespace stat
+ {
+
+ struct histo1d : public Meta_Accumulator<histo1d>
+ {
+ template <typename V>
+ struct with
+ {
+ typedef accu::stat::histo1d<V> ret;
+ };
+ };
+
+ } // end of namespace mln::accu::meta::stat
+
+ } // end of namespace mln::accu::meta
+
+ } // end of namespace mln::accu
+
+ namespace trait
+ {
+
+ template <typename V>
+ struct accumulator_< mln::accu::stat::histo1d<V> >
+ {
+ typedef accumulator::has_untake::no has_untake;
+ typedef accumulator::has_set_value::no has_set_value;
+ typedef accumulator::has_stop::no has_stop;
+ typedef accumulator::when_pix::use_v when_pix;
+ };
+
+ template <typename V>
+ struct set_precise_binary_<op::eq,
+ accu::stat::histo1d<V>,
+ accu::stat::histo1d<V> >
+ {
+ typedef bool ret;
+ };
+
+ } // end of namespace mln::trait
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ /// \brief Define a histogram as accumulator which returns an image1d.
+ ///
+ /// Param V defines the type of the input image value. It is in
+ /// this space that we count the values. For instance, this
+ /// histogram works well for image2d<int_u8> or with
+ /// image2d<int_u<14> >. The number of bins depends directly the
+ /// values V. For 8 bits there is 256 bins, for 14 bits there
+ /// is 16384 bins. Note that over quantification works too (up
+ /// to 14 bits).
+ ///
+ /// \ingroup modaccuvalues
+
+ template <typename V>
+ struct histo1d :
+ public mln::accu::internal::base<image1d<unsigned>, histo1d<V> >
+ {
+ typedef V argument;
+ typedef image1d<unsigned> result;
+ typedef result q_result;
+
+ /// Constructors
+ /// \{
+ /// \brief Infer the size of the resulting image1d domain.
+ ///
+ /// By evaluating the minimum and the maximum of V, we define the domain
+ /// of the resulting image1d.
+ histo1d();
+ /// \}
+
+
+ /// Manipulators.
+ /// \{
+ /// \brief Initialize the histogram with zero value.
+ ///
+ /// This method must be called just before starting the use of the
+ /// histogram. If it's not, resulting values won't converge to the
+ /// density.
+ void init();
+
+
+ /// \brief Update the histogram with the graylevel of the pixel t.
+ /// \param[in] t a graylevel pixel of type V.
+ ///
+ /// The end user shouldn't call this method. In place of it, he can
+ /// go through the data compute interface.
+ void take(const argument& t);
+
+
+ /// \brief Update the histogram with an other histogram.
+ /// \param[in] other the other histogram.
+ ///
+ /// The end user shouldn't call this method. This is part of
+ /// data compute interface mechanism.
+
+ void take(const histo1d<V>& other);
+ /// \}
+
+ /// Accessors.
+ /// \{
+ /// \brief Return the histogram as an image1d.
+ ///
+ /// This is the machinery to communicate with data compute interface.
+ /// The end user should'nt use it.
+ result to_result() const;
+ operator result () const;
+ /// \}
+
+ /// \brief Check whethever this accumulator is able to return a result.
+ ///
+ /// Depends if the resulting image1d is valid. We can assume it is quite
+ /// always the case.
+ bool is_valid() const;
+
+ protected:
+ result count_;
+ };
+
+ /// \brief Check wethever an histogram is equal to an other one.
+ /// \param[in] histo1 the first histogram to compare with.
+ /// \param[in] histo2 the second histogram.
+ ///
+ /// The operator compares all the bins from the two histograms.
+ /// Nobody uses this method unless unitary tests.
+
+ template <typename V>
+ bool operator==(const histo1d<V>& histo1, const histo1d<V>& histo2);
+
+#ifndef MLN_INCLUDE_ONLY
+
+ template <typename V>
+ inline
+ histo1d<V>::histo1d()
+ {
+ trace::entering("mln::accu::stat::histo1d::cstor");
+ typedef mln_trait_value_comp(V,0) comp;
+ typedef point<grid::tick, V> v_point1d;
+ typedef box<v_point1d> v_box1d;
+
+ // comp keep a trace of the dimension of the theorical image.
+ // mln_min(comp) --> 0
+ // mln_max(comp) --> 2^(n-1) [127 for n=7][255 for n=8] ...
+
+ count_.init_(box1d(point1d(mln_min(comp)),
+ point1d(mln_max(comp))));
+
+ // std::cout << "min : " << mln_min(comp) << std::endl;
+ // std::cout << "max : " << mln_max(comp) << std::endl;
+
+ trace::exiting("mln::accu::stat::histo1d::cstor");
+ }
+
+ template <typename V>
+ inline
+ void histo1d<V>::init()
+ {
+ data::fill(count_, literal::zero);
+ }
+
+ template <typename V>
+ inline
+ void histo1d<V>::take(const argument& t)
+ {
+ // Just convert a graylevel value (int_u8 like) to a position for an
+ // iterator on the resulting image.
+ ++count_(point1d(t));
+ }
+
+
+ template <typename V>
+ inline
+ void histo1d<V>::take(const histo1d<V>& other)
+ {
+ count_ += other.count_;
+ }
+
+ template <typename V>
+ inline
+ typename histo1d<V>::result histo1d<V>::to_result() const
+ {
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ histo1d<V>::operator result() const
+ {
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ bool histo1d<V>::is_valid() const
+ {
+ bool result = count_.is_valid();
+
+ return result;
+ }
+
+ template <typename V>
+ bool operator==(const histo1d<V>& histo1, const histo1d<V>& histo2)
+ {
+ trace::entering("mln::accu::stat::histo1d::operator==");
+
+ bool result = true;
+ const image1d<unsigned>& res1 = histo1.to_result();
+ const image1d<unsigned>& res2 = histo2.to_result();
+
+ mln_precondition(res1.is_valid());
+ mln_precondition(res2.is_valid());
+
+ mln_piter(image1d<unsigned>) p1(res1.domain());
+ mln_piter(image1d<unsigned>) p2(res2.domain());
+
+ for_all_2(p1, p2)
+ result &= (res1(p1) == res2(p2));
+
+ trace::exiting("mln::accu::stat::histo1d::operator==");
+ return result;
+ }
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::accu::stat
+
+ } // end of namespace mln::accu
+
+} // end of namespace mln
+
+#endif // ! MLN_ACCU_STAT_HISTO1D_HH
diff --git a/scribo/sandbox/green/mln/accu/stat/histo2d.hh b/scribo/sandbox/green/mln/accu/stat/histo2d.hh
new file mode 100644
index 0000000..c28723c
--- /dev/null
+++ b/scribo/sandbox/green/mln/accu/stat/histo2d.hh
@@ -0,0 +1,358 @@
+// 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.
+
+#ifndef MLN_ACCU_STAT_HISTO2D_HH
+# define MLN_ACCU_STAT_HISTO2D_HH
+
+/// \file
+///
+/// \brief Define a histogram as accumulator which returns an image2d.
+///
+/// This source implements the discrete histogram version. It was
+/// created for images which the values are derived from integer
+/// type. The number of bins is directly infered from the cardinality
+/// of the image value. It works with vectorial image, typically RGB
+/// space where only RG are preserved. See histo1d.hh for limitations
+/// of such implementation. 8 bits quantification starts to be
+/// expensive, it produces image2d with [0..255,0..255] as domain.
+///
+/// The following sample is a typical use of the histogram.
+///
+/// #include <mln/accu/stat/histo2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<unsigned> t_histo;
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+/// t_histo histo;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+/// histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+///
+/// return 0;
+/// }
+
+# include <iostream>
+
+# include <mln/accu/internal/base.hh>
+
+# include <mln/core/macros.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/alias/point2d.hh>
+# include <mln/core/alias/box2d.hh>
+
+# include <mln/trait/value/comp.hh>
+
+# include <mln/arith/plus.hh>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/value/ops.hh>
+
+namespace mln
+{
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ // Forward declaration
+ template <typename V>
+ struct histo2d;
+
+ } // end of namespace mln::accu::stat
+
+ namespace meta
+ {
+
+ namespace stat
+ {
+
+ struct histo2d : public Meta_Accumulator<histo2d>
+ {
+ template <typename V>
+ struct with
+ {
+ typedef accu::stat::histo2d<V> ret;
+ };
+ };
+
+ } // end of namespace mln::accu::meta::stat
+
+ } // end of namespace mln::accu::meta
+
+ } // end of namespace mln::accu
+
+
+ namespace trait
+ {
+
+ template <typename V>
+ struct accumulator_< mln::accu::stat::histo2d<V> >
+ {
+ typedef accumulator::has_untake::no has_untake;
+ typedef accumulator::has_set_value::no has_set_value;
+ typedef accumulator::has_stop::no has_stop;
+ typedef accumulator::when_pix::use_v when_pix;
+ };
+
+ template <typename V>
+ struct set_precise_binary_<op::eq,
+ accu::stat::histo2d<V>,
+ accu::stat::histo2d<V> >
+ {
+ typedef bool ret;
+ };
+
+ } // end of namespace mln::trait
+
+ namespace accu
+ {
+
+ namespace stat
+ {
+
+ /// \brief Define an histogram which returns an image3d .
+ ///
+ /// Param V defines the space in which we count the values.
+ /// For instance, this histogram works image2d<rgb<2>> or
+ /// image2d<rgb<7>>. The histogram count the occurrence of each value.
+ /// The number of bins depends of the grayscale values, for 8 bits there
+ /// is 256x3 bins. Note that over
+ /// quantification works too.
+ ///
+ /// \ingroup modaccuvalues
+
+ template <typename V>
+ struct histo2d :
+ public mln::accu::internal::base<image2d<unsigned>, histo2d<V> >
+ {
+ typedef V argument;
+ typedef image2d<unsigned> result;
+ typedef result q_result;
+
+ /// Constructors
+ /// \{
+ /// \brief Initialize the size of the resulting image1d.
+ ///
+ /// Initialize the size the resulting image from the theorical dynamic
+ /// of the greylevel values (Use V to manage it).
+ histo2d();
+ /// \}
+
+
+ /// Manipulators.
+ /// \{
+ /// \brief Initialize the histogram with zero value.
+ ///
+ /// This method must be called just before starting the use of the
+ /// histogram. If it's not, resulting values won't converge to the
+ /// density.
+ void init();
+
+
+ /// \brief Update the histogram with the RGB pixel t.
+ /// \param[in] t a greylevel pixel of type V.
+ ///
+ /// The end user shouldn't call this method. In place of it, he can
+ /// go through the data compute interface.
+ void take(const argument& t);
+
+
+ /// \brief Update the histogram with an other histogram.
+ /// \param[in] other the other histogram.
+ void take(const histo2d<V>& other);
+ /// \}
+
+ /// Accessors.
+ /// \{
+ /// \brief Return the histogram as an image1d.
+ ///
+ /// This is the machinery to communicate with data compute interface.
+ /// The end user should'nt use it.
+ result to_result() const;
+ operator result () const;
+ /// \}
+
+ /// \brief Check whethever this accumulator is able to return a result.
+ ///
+ /// Depends if the resulting image1d is valid. We can assume it is quite
+ /// always the case.
+ bool is_valid() const;
+
+ protected:
+ result count_;
+ };
+
+ /// \brief Check wethever an histogram is equal to an other one.
+ /// \param[in] histo1 the first histogram to compare with.
+ /// \param[in] histo2 the second histogram.
+ ///
+ /// The operator compare all the bins from the two histogram.
+
+ template <typename V>
+ bool operator==(const histo2d<V>& histo1,
+ const histo2d<V>& histo2);
+
+#ifndef MLN_INCLUDE_ONLY
+
+ template <typename V>
+ inline
+ histo2d<V>::histo2d()
+ {
+ trace::entering("mln::accu::stat::histo2d::histo2d");
+ typedef mln_trait_value_comp(V,0) comp0;
+ typedef mln_trait_value_comp(V,1) comp1;
+
+ // comp keep a trace of the dimension of the theorical image.
+ // mln_min(comp) --> 0
+ // mln_max(comp) --> 2^(n-1) [127 for n=7][255 for n=8] ...
+
+ count_.init_(box2d(point2d(mln_min(comp0),
+ mln_min(comp1)),
+ point2d(mln_max(comp0),
+ mln_max(comp1))));
+
+ trace::exiting("mln::accu::stat::histo2d::histo2d");
+ }
+
+ template <typename V>
+ inline
+ void histo2d<V>::init()
+ {
+ trace::entering("mln::accu::stat::histo2d::init");
+
+ data::fill(count_, 0);
+ trace::exiting("mln::accu::stat::histo2d::init");
+ }
+
+ template <typename V>
+ inline
+ void histo2d<V>::take(const argument& t)
+ {
+ trace::entering("mln::accu::stat::histo2d::take");
+
+ // Just convert a greyscale value (int_u8 like) to a position for an
+ // iterator on the resulting image.
+ // Take care to the constructor : Point(slice, row, column)
+ ++count_(point2d(t.red(), t.green()));
+
+ trace::exiting("mln::accu::stat::histo2d::take");
+ }
+
+
+ template <typename V>
+ inline
+ void histo2d<V>::take(const histo2d<V>& other)
+ {
+ trace::entering("mln::accu::stat::histo2d::take");
+
+ count_ += other.count_;
+
+ trace::exiting("mln::accu::stat::histo2d::take");
+ }
+
+ template <typename V>
+ inline
+ typename histo2d<V>::result histo2d<V>::to_result() const
+ {
+ trace::entering("mln::accu::stat::histo2d::to_result");
+
+ trace::exiting("mln::accu::stat::histo2d::to_result");
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ histo2d<V>::operator result() const
+ {
+ trace::entering("mln::accu::stat::histo2d::operator result");
+
+ trace::exiting("mln::accu::stat::histo2d::operator result");
+ return count_;
+ }
+
+ template <typename V>
+ inline
+ bool histo2d<V>::is_valid() const
+ {
+ trace::entering("mln::accu::stat::histo2d::is_valid");
+ bool result = count_.is_valid();
+
+ trace::exiting("mln::accu::stat::histo2d::is_valid");
+ return result;
+ }
+
+ template <typename V>
+ bool operator==(const histo2d<V>& histo1,
+ const histo2d<V>& histo2)
+ {
+ trace::entering("mln::accu::stat::operator==");
+
+ bool result = true;
+ const image2d<unsigned>& res1 = histo1.to_result();
+ const image2d<unsigned>& res2 = histo2.to_result();
+
+ mln_precondition(res1.is_valid());
+ mln_precondition(res2.is_valid());
+
+ mln_piter(image2d<unsigned>) p1(res1.domain());
+ mln_piter(image2d<unsigned>) p2(res2.domain());
+
+ for_all_2(p1, p2)
+ result &= (res1(p1) == res2(p2));
+
+ trace::exiting("mln::accu::stat::operator==");
+ return result;
+ }
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::accu::stat
+
+ } // end of namespace mln::accu
+
+} // end of namespace mln
+
+#endif // ! MLN_ACCU_STAT_HISTO2D_HH
diff --git a/milena/sandbox/green/mln/accu/stat/histo3d_hsl.hh b/scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
similarity index 100%
copy from milena/sandbox/green/mln/accu/stat/histo3d_hsl.hh
copy to scribo/sandbox/green/mln/accu/stat/histo3d_hsl.hh
diff --git a/milena/sandbox/green/mln/accu/stat/histo3d_rgb.hh b/scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
similarity index 100%
copy from milena/sandbox/green/mln/accu/stat/histo3d_rgb.hh
copy to scribo/sandbox/green/mln/accu/stat/histo3d_rgb.hh
diff --git a/milena/sandbox/green/mln/clustering/k_mean.hh b/scribo/sandbox/green/mln/clustering/k_mean.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/k_mean.hh
copy to scribo/sandbox/green/mln/clustering/k_mean.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean1d.hh b/scribo/sandbox/green/mln/clustering/kmean1d.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean1d.hh
copy to scribo/sandbox/green/mln/clustering/kmean1d.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean2d.hh b/scribo/sandbox/green/mln/clustering/kmean2d.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean2d.hh
copy to scribo/sandbox/green/mln/clustering/kmean2d.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean3d.hh b/scribo/sandbox/green/mln/clustering/kmean3d.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean3d.hh
copy to scribo/sandbox/green/mln/clustering/kmean3d.hh
diff --git a/milena/sandbox/green/mln/clustering/kmean_rgb.hh b/scribo/sandbox/green/mln/clustering/kmean_rgb.hh
similarity index 100%
copy from milena/sandbox/green/mln/clustering/kmean_rgb.hh
copy to scribo/sandbox/green/mln/clustering/kmean_rgb.hh
diff --git a/milena/sandbox/green/mln/display/display_histo.hh b/scribo/sandbox/green/mln/display/display_histo.hh
similarity index 100%
copy from milena/sandbox/green/mln/display/display_histo.hh
copy to scribo/sandbox/green/mln/display/display_histo.hh
diff --git a/milena/sandbox/green/mln/display/project_histo.hh b/scribo/sandbox/green/mln/display/project_histo.hh
similarity index 100%
copy from milena/sandbox/green/mln/display/project_histo.hh
copy to scribo/sandbox/green/mln/display/project_histo.hh
diff --git a/milena/sandbox/green/mln/fun/p2b/achromatic.hh b/scribo/sandbox/green/mln/fun/p2b/achromatic.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/p2b/achromatic.hh
copy to scribo/sandbox/green/mln/fun/p2b/achromatic.hh
diff --git a/milena/sandbox/green/mln/fun/p2b/component_equals.hh b/scribo/sandbox/green/mln/fun/p2b/component_equals.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/p2b/component_equals.hh
copy to scribo/sandbox/green/mln/fun/p2b/component_equals.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/achromatism.hh b/scribo/sandbox/green/mln/fun/v2v/achromatism.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/achromatism.hh
copy to scribo/sandbox/green/mln/fun/v2v/achromatism.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/hue_concentration.hh b/scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/hue_concentration.hh
copy to scribo/sandbox/green/mln/fun/v2v/hue_concentration.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh b/scribo/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh
copy to scribo/sandbox/green/mln/fun/v2v/int_u16_to_int_u14.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/log.hh b/scribo/sandbox/green/mln/fun/v2v/log.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/log.hh
copy to scribo/sandbox/green/mln/fun/v2v/log.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rg_to_rgb.hh b/scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
copy to scribo/sandbox/green/mln/fun/v2v/rg_to_rgb.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh b/scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb8_to_int_u8.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh b/scribo/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb8_to_rgbn.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb_to_achromatism_map.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb_to_hsv.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb_to_hue_map.hh
diff --git a/scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh
new file mode 100644
index 0000000..d4c1e46
--- /dev/null
+++ b/scribo/sandbox/green/mln/fun/v2v/rgb_to_rg.hh
@@ -0,0 +1,111 @@
+// 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.
+
+#ifndef MLN_FUN_V2V_RGB_TO_RG_HH
+# define MLN_FUN_V2V_RGB_TO_RG_HH
+
+# include <mln/value/rg.hh>
+# include <mln/value/rgb.hh>
+# include <mln/core/contract.hh>
+
+/// \file
+///
+/// \brief Convert a rgb value to a rg value.
+///
+/// This source implements the conversion between rgb space and rg space.
+///
+/// The following sample is a typical use of the rgb/rg conversion function.
+///
+/// #include <mln/accu/stat/histo2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<unsigned> t_histo;
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+/// t_histo histo;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+/// histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+///
+/// return 0;
+/// }
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace v2v
+ {
+
+ /// \brief Convert a rgb value to a rg value.
+ ///
+ /// Param n defines the quantification used for rgb space and rg space.
+ ///
+ /// \ingroup modfunv2v
+
+ template <unsigned n>
+ struct rgb_to_rg : Function_v2v< rgb_to_rg<n> >
+ {
+ typedef value::rg<n> result;
+ typedef value::rgb<n> argument;
+
+ /// \brief Convert rgb value to rg value.
+ ///
+ /// \param[in] v the rgb value to convert.
+ ///
+ /// Conversion is done by calling the rg constructor. There is
+ /// no modification of values. The red/green fields from rgb the value
+ /// are preserved. Blue value is dropped.
+
+ result operator()(const argument& v) const
+ {
+ return value::rg<n>(v);
+ }
+ };
+
+ } // end of namespace mln::fun::v2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+#endif // ! MLN_FUN_V2V_RGB_TO_RG_HH
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb_to_saturation_map.hh
diff --git a/milena/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh b/scribo/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh
similarity index 100%
copy from milena/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh
copy to scribo/sandbox/green/mln/fun/v2v/rgb_to_value_map.hh
diff --git a/milena/sandbox/green/mln/img_path.hh b/scribo/sandbox/green/mln/img_path.hh
similarity index 100%
copy from milena/sandbox/green/mln/img_path.hh
copy to scribo/sandbox/green/mln/img_path.hh
diff --git a/scribo/sandbox/green/mln/io/plot/save_image_sh.hh b/scribo/sandbox/green/mln/io/plot/save_image_sh.hh
new file mode 100644
index 0000000..137f78d
--- /dev/null
+++ b/scribo/sandbox/green/mln/io/plot/save_image_sh.hh
@@ -0,0 +1,1056 @@
+// 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.
+
+#ifndef MLN_IO_PLOT_SAVE_IMAGE_SH_HH
+# define MLN_IO_PLOT_SAVE_IMAGE_SH_HH
+
+/// \file
+///
+/// \brief Define some functions to export to gnuplot format as a script shell.
+///
+/// Theses routines are dedicated to image visualization. The aim is to display
+/// image whatever the value used as pixel. The behaviour of gnuplot is more
+/// like xv than imageMagick. A Gnuplot script shell file is a text dump file
+/// with a preambule to let gnuplot interpret data. As a script shell, you can
+/// launch it (don't forget the permissions), and every thing is packed in it.
+/// The script file call gnuplot in batch mode, the result window persists and
+/// that's all.
+///
+
+# include <fstream>
+# include <string>
+
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+# include <mln/core/macros.hh>
+# include <mln/core/contract.hh>
+# include <mln/core/image/image1d.hh>
+# include <mln/core/image/image2d.hh>
+# include <mln/core/image/image3d.hh>
+
+# include <mln/geom/min_ind.hh>
+# include <mln/geom/max_ind.hh>
+# include <mln/geom/min_row.hh>
+# include <mln/geom/max_row.hh>
+# include <mln/geom/min_col.hh>
+# include <mln/geom/max_col.hh>
+
+# include <mln/trait/value_.hh>
+
+# include <mln/value/int_u.hh>
+# include <mln/value/int_s.hh>
+# include <mln/value/rgb.hh>
+# include <mln/value/hsl.hh>
+# include <mln/value/hsi.hh>
+
+# include <mln/util/array.hh>
+
+
+namespace mln
+{
+
+ namespace io
+ {
+
+ namespace plot
+ {
+
+ /// \brief Save an image as a gnuplot script shell.
+ ///
+ /// Every thing is save. The image could be 1d, 2d or 3d. The value of
+ /// the pixels could be int_u<n>, int_s<n>, float, double, hsl_f, hsl_d,
+ /// hsi_f, hsi_d and rgb<n>.
+ ///
+ /// \param[in] img the image which contains the data to save.
+ /// \param[in] filename the name of the unix script shell.
+ /// \return the status of the opening file operation.
+ ///
+ /// The result depends on the permission to save the file with
+ /// filename parameter as unix path. The script shell file must have the
+ /// permission to execute (chmod 755). Launch the script shell to call
+ /// gnuplot in batchmode with fine parameters.
+
+ template <typename I>
+ bool save_image_sh(const Image<I>& img, const std::string& filename);
+
+ /// \brief Save a stack of image.
+ ///
+ /// This is an experimental support.
+ ///
+ /// \param[in] stack the stack of image to save.
+ /// \param[in] filename the name of the unix script shell.
+ /// \return the status of the opening file operation.
+ ///
+ /// The result depends on the permission to save the file with
+ /// filename parameter as unix path. The script shell file must have the
+ /// permission to execute (chmod 755). Launch the script shell to call
+ /// gnuplot in batchmode with fine parameters.
+ template <typename I>
+ bool save_image_sh(const util::array< image1d<I> >& stack,
+ const std::string& filename);
+
+ template <typename I>
+ bool save_image_sh(const util::array< util::array< image1d<I> > >& stack,
+ const std::string& filename);
+
+ } // end of namespace mln::io::plot
+
+ } // end of namespace mln::io
+
+
+ namespace io
+ {
+
+ namespace plot
+ {
+
+#ifndef MLN_INCLUDE_ONLY
+
+ //------------------------------------------------------------------------
+ // Impl.
+ //------------------------------------------------------------------------
+
+ namespace impl
+ {
+
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_array_image1d(const array<array<image1d<I>>>&,
+ // const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_array_array_image1d(const util::array< util::array<
+ image1d<I> > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d");
+
+ mln_precondition(!stack.is_empty());
+ mln_precondition(!stack[0].is_empty());
+ mln_precondition(stack[0][0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0][0]);
+ unsigned max_ind = geom::max_ind(stack[0][0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "plot '-' with line";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+ for (unsigned j = 1; j < stack[i].size(); ++j)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line";
+ }
+ }
+
+ out << std::endl;
+
+ mln_eiter(util::array< util::array< image1d<I> > >) e0(stack);
+
+ for_all (e0)
+ {
+ mln_eiter(util::array< image1d<I> >) e1(stack[e0.index_()]);
+
+ for_all (e1)
+ {
+ mln_piter(image1d< I >)
+ p(stack[e0.index_()][e1.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e0.index_()][e1.index_()](p) << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d");
+
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_array_image1d_vec3(
+ // const array<array<image1d<vec<3,T>>>>&,
+ // const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_array_array_image1d_vec3(
+ const util::array<util::array<image1d<algebra::vec<3,T> > > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec3");
+
+ typedef algebra::vec<3,T> t_val;
+ typedef image1d<t_val> t_img;
+ typedef util::array<t_img> t_array;
+ typedef util::array<t_array> t_stack;
+
+ mln_precondition(!stack.is_empty());
+ mln_precondition(!stack[0].is_empty());
+ mln_precondition(stack[0][0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0][0]);
+ unsigned max_ind = geom::max_ind(stack[0][0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "splot '-' with line palette";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+ for (unsigned j = 1; j < stack[i].size(); ++j)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line palette";
+ }
+ }
+
+ out << std::endl;
+
+ mln_eiter(t_stack) e0(stack);
+
+ for_all (e0)
+ {
+ mln_eiter(t_array) e1(stack[e0.index_()]);
+
+ for_all (e1)
+ {
+ mln_piter(t_img) p(stack[e0.index_()][e1.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e0.index_()][e1.index_()](p)[0] << " ";
+ out << stack[e0.index_()][e1.index_()](p)[1] << " ";
+ out << stack[e0.index_()][e1.index_()](p)[2] << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec3");
+
+ return result;
+ }
+
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_array_image1d_vec2(
+ // const array<array<image1d<vec<2,T>>>>&,
+ // const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_array_array_image1d_vec2(
+ const util::array<util::array<image1d<algebra::vec<2,T> > > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec2");
+
+ typedef algebra::vec<2,T> t_val;
+ typedef image1d<t_val> t_img;
+ typedef util::array<t_img> t_array;
+ typedef util::array<t_array> t_stack;
+
+ mln_precondition(!stack.is_empty());
+ mln_precondition(!stack[0].is_empty());
+ mln_precondition(stack[0][0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0][0]);
+ unsigned max_ind = geom::max_ind(stack[0][0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "splot '-' with line";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+ for (unsigned j = 1; j < stack[i].size(); ++j)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line";
+ }
+ }
+
+ out << std::endl;
+
+ mln_eiter(t_stack) e0(stack);
+
+ for_all (e0)
+ {
+ mln_eiter(t_array) e1(stack[e0.index_()]);
+
+ for_all (e1)
+ {
+ mln_piter(t_img) p(stack[e0.index_()][e1.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e0.index_()][e1.index_()](p)[0] << " ";
+ out << stack[e0.index_()][e1.index_()](p)[1] << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::"
+ "save_image_sh_array_array_image1d_vec2");
+
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_array_image1d(const array<image1d<I>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_array_image1d(const util::array< image1d<I> >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_array_image1d");
+ mln_precondition(!stack.is_empty());
+ mln_precondition(stack[0].is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_ind = geom::min_ind(stack[0]);
+ unsigned max_ind = geom::max_ind(stack[0]);
+
+ if (result)
+ {
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_ind;
+ out << ":" << max_ind;
+ out << "]" << std::endl;
+ out << "plot '-' with line";
+
+ for (unsigned i = 1; i < stack.size(); ++i)
+ {
+
+ out << ",\\" << std::endl;
+ out << " '-' with line";
+ }
+
+ out << std::endl;
+
+ mln_eiter(util::array< image1d<I> >) e(stack);
+
+ for_all (e)
+ {
+ mln_piter(image1d< I >) p(stack[e.index_()].domain());
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << stack[e.index_()](p) << std::endl;;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ }
+
+ out << "EOF" << std::endl;
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_array_image1d");
+ return result;
+ }
+
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d_rgb(const image2d<rgb<n>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <unsigned n>
+ inline
+ bool save_image_sh_image2d_rgb(const image2d<value::rgb<n> >& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d_rgb");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ if (result)
+ {
+ mln_piter(image2d< value::rgb<n> >) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, r, g, b) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):3:4:5 with rgbimage" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p).red() << " ";
+ out << img(p).green() << " ";
+ out << img(p).blue() << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d_rgb");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d_hsl(const image2d<hsl_<T,T,T>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_image2d_hsl(const image2d<value::hsl_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d_hsl");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ typedef mln::value::hsl_<T,T,T> hsl;
+
+ if (result)
+ {
+ mln_piter(image2d< hsl >) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "q(l,s) = (l < 0.5)? (l*(1+s)):(l+s-(l*s))" << std::endl;
+ out << "p(l,s) = (2.0 * l - q(l,s))" << std::endl;
+ out << "n(x) = (x < 0)?(x+1):(x > 1)?(x-1) : (x)"<< std::endl;
+ out << std::endl;
+ out << "c(p,q,t) = (t <(1.0/6.0))?(p+(q-p)*6.0*t):\\"<< std::endl;
+ out << " (t <(1.0/2.0))?(q) :\\" << std::endl;
+ out << " (t<(2.0/3.0))?(p+(q-p)*6.0*((2.0/3.0)-t)):\\" << std::endl;
+ out << " (p)" << std::endl;
+ out << std::endl;
+ out << "r(h,s,l) = c(p(l,s),q(l,s),n(h/360.0+1.0/3.0))"<< std::endl;
+ out << "g(h,s,l) = c(p(l,s),q(l,s),n(h/360.0))" << std::endl;
+ out << "b(h,s,l) = c(p(l,s),q(l,s),n(h/360.0-1.0/3.0))"<< std::endl;
+ out << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set palette gray" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):\\" << std::endl;
+ out << " (r(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (g(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (b(\\$3,\\$4,\\$5)) with rgbimage" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p).hue() << " ";
+ out << img(p).sat() << " ";
+ out << img(p).lum() << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d_hsl");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d_hsi(const image2d<hsi_<T,T,T>>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename T>
+ inline
+ bool save_image_sh_image2d_hsi(const image2d<value::hsi_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d_hsi");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ typedef mln::value::hsi_<T,T,T> hsi;
+
+ if (result)
+ {
+ mln_piter(image2d< hsi >) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "teta(h) = (h/180.0) * pi" << std::endl;
+ out << "alpha(s,h) = s*cos(teta(h))" << std::endl;
+ out << "beta(s,h) = s*sin(teta(h))" << std::endl;
+ out << "n(x) = (x < 0)?(x+1) : (x > 1)?(x-1):(x)"<< std::endl;
+ out << std::endl;
+ out << "c(p,q,t) = (t <(1.0/6.0))?(p+(q-p)*6.0*t):\\"<< std::endl;
+ out << " (t <(1.0/2.0))?(q) :\\" << std::endl;
+ out << " (t <(2.0/3.0))?(p+(q-p)*6.0*((2.0/3.0)-t)):\\"<< std::endl;
+ out << " (p)" << std::endl;
+ out << std::endl;
+ out << "r(h,s,i) = (sqrt(3.0)/3.0) * i \\" << std::endl;
+ out << " + (2.0/(sqrt(6.0))) * beta(s,h)" << std::endl;
+ out << "g(h,s,i) = (sqrt(3.0)/3.0) * i \\" << std::endl;
+ out << " + (2.0/(sqrt(2.0))) * alpha(s,h)\\" << std::endl;
+ out << " - (1.0/(sqrt(6.0))) * beta(s,h)" << std::endl;
+ out << "b(h,s,i) = (sqrt(3.0)/3.0) * i \\" << std::endl;
+ out << " - (2.0/(sqrt(2.0))) * alpha(s,h) \\"<< std::endl;
+ out << " - (1.0/(sqrt(6.0))) * beta(s,h)" << std::endl;
+ out << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set palette gray" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):\\" << std::endl;
+ out << " (r(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (g(\\$3,\\$4,\\$5)):\\" << std::endl;
+ out << " (b(\\$3,\\$4,\\$5)) with rgbimage" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p).hue() << " ";
+ out << img(p).sat() << " ";
+ out << img(p).inty() << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:" << filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d_hsi");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image2d(const image2d<I>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_image2d(const image2d<I>& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image2d");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+ unsigned min_row = geom::min_row(img);
+ unsigned max_row = geom::max_row(img);
+ unsigned min_col = geom::min_col(img);
+ unsigned max_col = geom::max_col(img);
+
+ if (result)
+ {
+ mln_piter(image2d<I>) p(img.domain());
+
+ // Output data prelude (terminal X11, image).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "set palette gray" << std::endl;
+ out << "set xrange [" << min_col;
+ out << ":" << max_col;
+ out << "]" << std::endl;
+ out << "set yrange [-" << max_row;
+ out << ":" << min_row;
+ out << "]" << std::endl;
+ out << "plot '-' using 2:(-\\$1):3 with image" <<std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << img(p) << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:"<< filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image2d");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image1d(const image1d<I>&, const string&)
+ //----------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh_image1d(const image1d<I>& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image1d");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+
+ if (result)
+ {
+ mln_piter(image1d<I>) p(img.domain());
+
+ // Output data prelude (terminal X11, impulse).
+ out << "#!/bin/sh" << std::endl;
+ out << "##########################" << std::endl;
+ out << "# Two columns = (x, val) #" << std::endl;
+ out << "##########################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "plot '-' with impulse" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.ind() << " ";
+ out << img(p) << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:"<< filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image1d");
+ return result;
+ }
+
+ //----------------------------------------------------------------------
+ // save_image_sh_image3d(const image3d<I>&, const string&)
+ //----------------------------------------------------------------------
+
+
+ template <typename I>
+ inline
+ bool save_image_sh_image3d(const image3d<I>& img,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::impl::save_image_sh_image3d");
+ mln_precondition(img.is_valid());
+
+ std::ofstream out(filename.c_str());
+ bool result = !out.fail();
+
+ if (result)
+ {
+ mln_piter(image3d<I>) p(img.domain());
+
+ // Output data prelude (terminal X11, pointtype 0).
+ out << "#!/bin/sh" << std::endl;
+ out << "####################################" << std::endl;
+ out << "# Columns = (x, y, z, val) #" << std::endl;
+ out << "####################################" << std::endl;
+ out << std::endl;
+ out << "gnuplot <<EOF" << std::endl;
+ out << "set terminal x11 persist 1" << std::endl;
+ out << "splot '-' with points palette pointtype 7" << std::endl;
+
+ // Output data.
+ for_all(p)
+ {
+ out << p.row() << " ";
+ out << p.col() << " ";
+ out << p.sli() << " ";
+ out << img(p) << std::endl;
+ }
+
+ // Close gnuplot data stream.
+ out << "e" << std::endl;
+ out << "EOF" << std::endl;
+
+ out.close();
+ }
+ else
+ {
+ std::cerr << "ERROR[mln::io::plot::save_image_sh]:"<< filename;
+ std::cerr << " couldn't be opened !!" << std::endl;
+ }
+
+ trace::exiting("mln::io::plot::impl::save_image_sh_image3d");
+ return result;
+ }
+
+ } // end of namespace impl
+
+
+ //------------------------------------------------------------------------
+ // Internal.
+ //------------------------------------------------------------------------
+
+ namespace internal
+ {
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const util::array< image1d<I> >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_image1d(stack, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const util::array<
+ util::array <image1d<I> > >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_array_image1d(stack, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(
+ const util::array<util::array<image1d<algebra::vec<3,T> > > >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_array_image1d_vec3(stack, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(
+ const util::array<util::array<image1d<algebra::vec<2,T> > > >& stack,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_array_array_image1d_vec2(stack, filename);
+ }
+
+ template <unsigned n>
+ inline
+ bool save_image_sh_dispatch(const image2d<value::rgb<n> >& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d_rgb(img, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(const image2d<value::hsl_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d_hsl(img, filename);
+ }
+
+ template <typename T>
+ inline
+ bool save_image_sh_dispatch(const image2d<value::hsi_<T,T,T> >& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d_hsi(img, filename);
+ }
+
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const image2d<I>& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image2d(img, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const image1d<I>& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image1d(img, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const image3d<I>& img,
+ const std::string& filename)
+ {
+ return impl::save_image_sh_image3d(img, filename);
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh_dispatch(const Image<I>& img,
+ const std::string& filename)
+ {
+ return save_image_sh_dispatch(exact(img), filename);
+ }
+
+ } // end of namespace mln::io::plot::internal
+
+ //------------------------------------------------------------------------
+ // Facade.
+ //------------------------------------------------------------------------
+
+ template <typename I>
+ inline
+ bool save_image_sh(const Image<I>& img, const std::string& filename)
+ {
+ trace::entering("mln::io::plot::save_image_sh");
+
+ bool result = internal::save_image_sh_dispatch(img, filename);
+
+ trace::exiting("mln::io::plot::save_image_sh");
+ return result;
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh(const util::array< image1d<I> >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::save_image_sh");
+
+ bool result = internal::save_image_sh_dispatch(stack, filename);
+
+ trace::exiting("mln::io::plot::save_image_sh");
+ return result;
+ }
+
+ template <typename I>
+ inline
+ bool save_image_sh(const util::array< util::array< image1d<I> > >& stack,
+ const std::string& filename)
+ {
+ trace::entering("mln::io::plot::save_image_sh");
+
+ bool result = internal::save_image_sh_dispatch(stack, filename);
+
+ trace::exiting("mln::io::plot::save_image_sh");
+ return result;
+ }
+
+
+#endif // ! MLN_INCLUDE_ONLY
+
+
+ } // end of namespace mln::io::plot
+
+ } // end of namespace mln::io
+
+} // end of namespace mln
+
+#endif // ! MLN_IO_PLOT_SAVE_IMAGE_SH_HH
diff --git a/milena/sandbox/green/mln/math/ceil.hh b/scribo/sandbox/green/mln/math/ceil.hh
similarity index 100%
copy from milena/sandbox/green/mln/math/ceil.hh
copy to scribo/sandbox/green/mln/math/ceil.hh
diff --git a/milena/sandbox/green/mln/math/floor.hh b/scribo/sandbox/green/mln/math/floor.hh
similarity index 100%
copy from milena/sandbox/green/mln/math/floor.hh
copy to scribo/sandbox/green/mln/math/floor.hh
diff --git a/milena/sandbox/green/mln/value/hsv.hh b/scribo/sandbox/green/mln/value/hsv.hh
similarity index 100%
copy from milena/sandbox/green/mln/value/hsv.hh
copy to scribo/sandbox/green/mln/value/hsv.hh
diff --git a/scribo/sandbox/green/mln/value/rg.hh b/scribo/sandbox/green/mln/value/rg.hh
new file mode 100644
index 0000000..d083ffd
--- /dev/null
+++ b/scribo/sandbox/green/mln/value/rg.hh
@@ -0,0 +1,175 @@
+// Copyright (C) 2007, 2008, 2009, 2010 EPITA LRDE
+//
+// This file is part of Olena.
+//
+// Olena is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation, version 2 of the License.
+//
+// Olena is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Olena. If not, see <http://www.gnu.org/licenses/>.
+//
+// As a special exception, you may use this file as part of a free
+// software project without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to produce
+// an executable, this file does not by itself cause the resulting
+// executable to be covered by the GNU General Public License. This
+// exception does not however invalidate any other reasons why the
+// executable file might be covered by the GNU General Public License.
+
+#ifndef MLN_VALUE_RG_HH
+# define MLN_VALUE_RG_HH
+
+/// \file
+///
+/// \brief Define the red/green vectorial image type.
+///
+/// This source implements the red/green (RG) vectorial image type. It
+/// is a partial copy of the rgb type. This type doesn't manage
+/// anykind of interaction. Its purpose is limited to store a couple
+/// of values. Do not use it outside this purpose, i can't garantie
+/// the behaviour.
+///
+/// The following sample is a typical use of the rg type.
+///
+/// #include <mln/accu/stat/histo2d.hh>
+/// #include <mln/core/image/image2d.hh>
+/// #include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+/// typedef mln::image2d<t_rg8> t_image2d_rg8;
+/// typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+/// typedef mln::image2d<unsigned> t_histo;
+/// t_image2d_rgb8 img_rgb8;
+/// t_image2d_rg8 img_rg8;
+/// t_histo histo;
+///
+/// mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+/// img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+/// histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+///
+/// return 0;
+/// }
+
+
+# include <mln/algebra/vec.hh>
+# include <mln/value/concept/vectorial.hh>
+# include <mln/value/int_u.hh>
+# include <mln/value/rgb8.hh>
+# include <mln/trait/value_.hh>
+
+
+namespace mln
+{
+
+ namespace value
+ {
+
+ // Forward declaration.
+ template <unsigned n> struct rg;
+
+ } // end of namespace mln::value
+
+ namespace trait
+ {
+
+ template <unsigned n>
+ struct value_< mln::value::rg<n> >
+ {
+ enum {
+ dim = 2,
+ nbits = dim * n,
+ card = mln_value_card_from_(nbits)
+ };
+
+ typedef trait::value::nature::vectorial nature;
+ typedef trait::value::kind::color kind;
+ typedef trait::value::quant::high quant;
+
+ typedef void comp;
+ typedef mln::value::int_u<n> comp_0;
+ typedef mln::value::int_u<n> comp_1;
+
+ static comp_0 get_comp_0(const mln::value::rg<n>& v){return v.red(); }
+ static comp_1 get_comp_1(const mln::value::rg<n>& v){return v.green();}
+
+ typedef algebra::vec<dim, float> sum;
+
+ static const char* name()
+ {
+ static std::string s = std::string("rg").append(1, 8 + '0');
+ return s.c_str();
+ }
+ };
+
+ } // end of namespace mln::trait
+
+ namespace value
+ {
+
+ /// \brief Define the red/green vectorial image type.
+ ///
+ /// Param n defines the quantification used for red/green space.
+
+ template <unsigned n>
+ struct rg :public mln::value::Vectorial< rg<n> >,
+ public internal::value_like_<
+ algebra::vec< 2, int_u<n> >, // Equivalent.
+ algebra::vec< 2, int_u<n> >, // Encoding.
+ algebra::vec< 2, int >, // Interoperation.
+ rg<n> > // Exact.
+ {
+ typedef int_u<n> t_red;
+ typedef int_u<n> t_green;
+
+ int_u<n> red() const {return this->v_[0];}
+ int_u<n>& red() {return this->v_[0];}
+ int_u<n> green() const {return this->v_[1];}
+ int_u<n>& green() {return this->v_[1];}
+
+ /// Constructors
+ /// \{
+ /// \brief Create a rg value.
+ ///
+ /// Two constructors exist, the first one do nothing and the second one
+ /// initializes the red/green components from a rgb value.
+ rg(){}
+ rg(const rgb8& val){this->v_[0] = val.red(); this->v_[1] = val.green();}
+ /// \}
+
+ /// \brief Affect a rg value to this object.
+ /// \param[in] rhs the value to affect to this object.
+ ///
+ /// If the two objects are different, then then copy the
+ /// underline array of values.
+
+ rg operator=(const rg& rhs)
+ {
+ if (&rhs != this)
+ this->v_ = rhs.v_;
+
+ return *this;
+ }
+ };
+
+ } // end of namespace mln::value
+
+} // end of namespace mln
+
+#endif // ! MLN_VALUE_RG_HH
diff --git a/scribo/sandbox/green/tests/accu/stat/histo1d/Makefile.am b/scribo/sandbox/green/tests/accu/stat/histo1d/Makefile.am
new file mode 100644
index 0000000..77f9015
--- /dev/null
+++ b/scribo/sandbox/green/tests/accu/stat/histo1d/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/tests
+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)/
+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/tests/accu/stat/histo1d/histo1d.cc b/scribo/sandbox/green/tests/accu/stat/histo1d/histo1d.cc
new file mode 100644
index 0000000..5a5c4c4
--- /dev/null
+++ b/scribo/sandbox/green/tests/accu/stat/histo1d/histo1d.cc
@@ -0,0 +1,21 @@
+/// TEST HISTO1D
+
+#include <mln/accu/stat/histo1d.hh>
+#include <mln/data/compute.hh>
+#include <mln/core/image/image1d.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;
+ mln::image2d<t_int_u8> img;
+ mln::image1d<unsigned> histo;
+
+ mln::io::pgm::load(img, OLENA_IMG_PATH"/lena.pgm");
+ histo = mln::data::compute(mln::accu::meta::stat::histo1d(), img);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am b/scribo/sandbox/green/use/accu/stat/histo1d/Makefile.am
new file mode 100644
index 0000000..a96b2e9
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo1d/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/use
+BUILD__PATTERN= green/build/use
+
+
+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/use/accu/stat/histo1d/histo1d.cc b/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
new file mode 100644
index 0000000..1c6176b
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo1d/histo1d.cc
@@ -0,0 +1,24 @@
+/// \file
+///
+/// \brief Minimal code for building 1d image histogram version.
+///
+
+#include <mln/accu/stat/histo1d.hh>
+#include <mln/data/compute.hh>
+#include <mln/core/image/image1d.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;
+ mln::image2d<t_int_u8> img;
+ mln::image1d<unsigned> histo;
+
+ mln::io::pgm::load(img, OLENA_IMG_PATH"/lena.pgm");
+ histo = mln::data::compute(mln::accu::meta::stat::histo1d(), img);
+
+ return 0;
+}
diff --git a/scribo/sandbox/green/use/accu/stat/histo2d/Makefile.am b/scribo/sandbox/green/use/accu/stat/histo2d/Makefile.am
new file mode 100644
index 0000000..a96b2e9
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo2d/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/use
+BUILD__PATTERN= green/build/use
+
+
+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/use/accu/stat/histo2d/histo2d.cc b/scribo/sandbox/green/use/accu/stat/histo2d/histo2d.cc
new file mode 100644
index 0000000..6369b5a
--- /dev/null
+++ b/scribo/sandbox/green/use/accu/stat/histo2d/histo2d.cc
@@ -0,0 +1,33 @@
+/// \file
+///
+/// \brief Minimal code for building 2d image histogram version.
+///
+
+#include <mln/accu/stat/histo2d.hh>
+#include <mln/core/image/image2d.hh>
+#include <mln/data/compute.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::fun::v2v::rgb_to_rg<8> t_rgb_to_rg;
+ typedef mln::image2d<t_rg8> t_image2d_rg8;
+ typedef mln::image2d<t_rgb8> t_image2d_rgb8;
+ typedef mln::image2d<unsigned> t_histo;
+ t_image2d_rgb8 img_rgb8;
+ t_image2d_rg8 img_rg8;
+ t_histo histo;
+
+ mln::io::ppm::load(img_rgb8, OLENA_IMG_PATH"/lena.ppm");
+ img_rg8 = mln::data::transform(img_rgb8, t_rgb_to_rg());
+ histo = mln::data::compute(mln::accu::meta::stat::histo2d(), img_rg8);
+
+ return 0;
+}
--
1.5.6.5
14 years, 6 months
- 1
- 0