[Olena-patches] r3517: Create workflow based on small tools

12 Mar 2009

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox

ChangeLog:
2009-03-12  Fabien Freling  <fabien.freling@lrde.epita.fr>

	Create workflow based on small tools.
	* fabien/bin/dumpl32_to_colorize.cc: New.
	* fabien/igr/Makefile: Update.
	* fabien/igr/check.sh: New script shell for testing.
	* fabien/igr/clo_vol.cc: Implement closing volume.
	* fabien/igr/grad.cc: Implement gradient.
	* fabien/igr/graph.cc: Implement graph.
	* fabien/igr/wst.cc: Implement watershed.

---
 TODO                       |    6 
 bin/dumpl32_to_colorize.cc |   61 ++++++++
 igr/Makefile               |   40 +++--
 igr/check.sh               |   32 ++++
 igr/clo_vol.cc             |   63 ++++++++
 igr/grad.cc                |   63 ++++++++
 igr/graph.cc               |  329 +++++++++++++++++++++++++++++++++++++++++++++
 igr/wst.cc                 |   71 +++++++++
 8 files changed, 650 insertions(+), 15 deletions(-)

Index: trunk/milena/sandbox/fabien/igr/clo_vol.cc
===================================================================

--- trunk/milena/sandbox/fabien/igr/clo_vol.cc	(revision 0)
+++ trunk/milena/sandbox/fabien/igr/clo_vol.cc	(revision 3517)
@@ -0,0 +1,63 @@
+#include <iostream>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+
+#include <mln/core/alias/neighb2d.hh>
+#include <mln/core/alias/window2d.hh>
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/alias/window3d.hh>
+
+#include <mln/io/dump/all.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/int_u12.hh>
+
+#include <mln/morpho/closing/volume.hh>
+
+
+
+///////////////////
+//               //
+// Main Function //
+//               //
+///////////////////
+
+
+int main(int argc, char *argv[])
+{
+  using namespace mln;
+  using value::int_u8;
+  using value::int_u12;
+
+  if (argc != 4)
+  {
+    std::cout << "Usage: " << argv[0] << " <input.dump> <dimensions> <closure_lambda>"
+	      << std::endl;
+    return 1;
+  }
+
+  unsigned closure_lambda = atoi(argv[3]);
+  unsigned dim = atoi(argv[2]);
+  if (dim != 2 && dim != 3)
+  {
+    std::cout << "<dimensions> invalid" << std::endl;
+    return 1;
+  }
+
+  if (dim == 2)
+  {
+    image2d<int_u12> input;
+    io::dump::load(input, argv[1]);
+    image2d<int_u12> clo = morpho::closing::volume(input, c4(), closure_lambda);
+    io::dump::save(clo, "clo_vol.dump");
+  }
+  else
+  {
+    image3d<int_u12> input;
+    io::dump::load(input, argv[1]);
+    image3d<int_u12> clo = morpho::closing::volume(input, c6(), closure_lambda);
+    io::dump::save(clo, "clo_vol.dump");
+  }
+
+  return 0;
+}
Index: trunk/milena/sandbox/fabien/igr/graph.cc
===================================================================
--- trunk/milena/sandbox/fabien/igr/graph.cc	(revision 0)
+++ trunk/milena/sandbox/fabien/igr/graph.cc	(revision 3517)
@@ -0,0 +1,329 @@
+#include <iostream>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+#include <mln/core/image/image_if.hh>
+
+#include <mln/core/alias/neighb2d.hh>
+#include <mln/core/alias/window2d.hh>
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/alias/window3d.hh>
+
+#include <mln/io/dump/all.hh>
+#include <mln/io/dicom/load.hh>
+#include <mln/io/pgm/save.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/int_u12.hh>
+#include <mln/value/label_16.hh>
+#include <mln/value/label_32.hh>
+
+#include <mln/morpho/watershed/flooding.hh>
+
+#include <mln/math/diff_abs.hh>
+
+#include <mln/labeling/mean_values.hh>
+
+#include <mln/convert/to_fun.hh>
+
+#include <mln/make/graph.hh>
+#include <mln/util/graph.hh>
+
+#include <mln/fun/l2l/wrap.hh>
+
+#include <mln/core/var.hh>
+#include <mln/morpho/elementary/dilation.hh>
+
+#include <mln/core/routine/extend.hh>
+
+#include <mln/core/alias/vec3d.hh>
+#include <mln/debug/draw_graph.hh>
+#include <mln/accu/center.hh>
+#include <mln/io/dump/all.hh>
+#include <mln/value/label_8.hh>
+#include <mln/value/rgb16.hh>
+#include <mln/accu/compute.hh>
+#include <mln/core/alias/dpoint2d.hh>
+#include <mln/draw/box.hh>
+#include <mln/level/stretch.hh>
+#include <mln/fun/v2v/id.hh>
+#include <mln/fun/l2l/wrap.hh>
+#include <mln/core/image/line_graph_elt_neighborhood.hh>
+#include <mln/labeling/mean_values.hh>
+#include <mln/extension/adjust_fill.hh>
+#include <mln/extract/all.hh>
+#include <mln/make/region_adjacency_graph.hh>
+
+
+
+
+// Given a color image and a wshed image, computes the component graph.
+// Vertex values are computed thanks to a RGB image.
+
+namespace mln
+{
+
+  template <typename V>
+  value::int_u8 dist(const V& c1, const V& c2)
+  {
+    unsigned d = math::diff_abs(c1.red(), c2.red());
+    unsigned d_;
+    d_ = math::diff_abs(c1.green(), c2.green());
+
+    if (d_ > d)
+      d = d_;
+
+    d_ = math::diff_abs(c1.blue(), c2.blue());
+
+    if (d_ > d)
+      d = d_;
+    return d;
+  }
+
+
+  // ima_v, image on graph vertices; value = mean color per vertex (watershed basin)
+  template <typename I>
+  inline
+  pw::image<fun::i2v::array<value::int_u8>,
+	    p_edges<util::graph, fun::i2v::array<mln_site(I)> > >
+  make_edge_graph_image(const I& ima_v, const util::graph& g)
+  {
+    // edge sites.
+    typedef fun::i2v::array<mln_site(I)> edge_site_t;
+    edge_site_t edge_site(g.e_nmax(), literal::origin);
+    typedef p_edges<util::graph, edge_site_t > pe_t;
+    pe_t pe(g, edge_site);
+
+    // edge values
+    typedef fun::i2v::array<value::int_u8> edge_values_t;
+    edge_values_t edge_values(g.e_nmax());
+
+    // image on graph edges
+    typedef pw::image<edge_values_t, pe_t> ima_e_t;
+    ima_e_t ima_e = (edge_values | pe);
+
+    mln_piter(ima_e_t) e(ima_e.domain());
+    for_all(e) // in ima_e
+      ima_e(e) = math::diff_abs(ima_v.function()(e.element().v1()), ima_v.function()(e.element().v2()));
+
+    return ima_e;
+  }
+
+
+  template <typename I, typename J>
+  inline
+  util::array<mln_value(I)>
+  mean_color_values(const I& input, const J& w, mln_value(J) nbasins)
+  {
+    // Cf. sandbox/theo/color/segment_rgb_pixels.cc
+
+    util::array<float> m_3f = labeling::compute(accu::mean<mln_value(I)>(),
+						input, // input color image
+						w, // watershed labeling
+						nbasins);
+    m_3f[0] = literal::zero;
+
+    util::array<mln_value(I)> m;
+    convert::from_to(m_3f, m);
+    m[0] = 150u;
+
+    /*io::ppm::save(level::transform(w,
+	  convert::to< fun::i2v::array<mln_value(I)> >(m)),
+	"wst_rag_wshd_color.ppm");*/
+
+    return m;
+  }
+
+
+  template <typename I, typename J>
+  pw::image<fun::i2v::array<mln_value(I)>, p_vertices<util::graph, fun::i2v::array<mln_site(I)> > >
+  make_vertex_graph_image(const util::graph& g, const I&input, const J& w, const mln_value(J)& nbasins)
+  {
+    typedef util::array<mln_site(I)> vertex_sites_t;
+    vertex_sites_t site_values;
+    convert::from_to(labeling::compute(accu::center<mln_site(I)>(), w, nbasins),
+				       site_values);
+
+    typedef fun::i2v::array<mln_site(J)> f_sites_t;
+    f_sites_t sites;
+    convert::from_to(site_values, sites);
+
+    // p_vertices
+    typedef p_vertices<util::graph, f_sites_t> S;
+    S pv(g, sites);
+
+
+    typedef fun::i2v::array<mln_value(I)> vertex_values_t;
+    vertex_values_t vertex_values;
+    convert::from_to(mean_color_values(input, w, nbasins), vertex_values);
+
+    mln_VAR(ima_v, (vertex_values | pv));
+
+    return ima_v;
+  }
+
+
+  template <typename I, typename V>
+  struct edge_to_color : Function_p2v< edge_to_color<I,V> >
+  {
+    typedef V result;
+
+    edge_to_color(const I& ima)
+      : ima_(ima)
+    {
+    }
+
+    V
+    operator()(const unsigned& e) const
+    {
+      return convert::to<V>(ima_.function()(e));
+    }
+
+    const I& ima_;
+  };
+
+  template <typename V>
+  inline
+  unsigned
+  find_root(util::array<V>& parent, const unsigned& x)
+  {
+    if (parent[x] == x)
+      return x;
+    else
+      return parent[x] = find_root(parent, parent[x]);
+  }
+
+
+  template <typename I, typename V, typename E>
+  inline
+  image2d<mln_value(I)>
+  make_debug_graph_image(const I& input,
+			 const V& ima_v, const E& ima_e,
+			 unsigned box_size, const value::int_u12& bg)
+  {
+    image2d<mln_value(I)> ima;
+    initialize(ima, input);
+
+    data::fill(ima, bg);
+    debug::draw_graph(ima, ima_v.domain(),
+		      pw::cst(150u),
+		      edge_to_color<E, mln_value(I)>(ima_e));
+
+    dpoint2d tl(-box_size,-box_size);
+    dpoint2d br(box_size,box_size);
+    mln_piter(V) p(ima_v.domain());
+    for_all(p)
+    {
+      box2d b(p + tl, p + br);
+      b.crop_wrt(ima.domain());
+      data::fill((ima | b).rw(), convert::to<mln_value(I)>(ima_v(p)));
+    }
+
+    return ima;
+  }
+
+}
+
+
+
+
+
+///////////////////
+//               //
+// Main Function //
+//               //
+///////////////////
+
+
+int main(int argc, char *argv[])
+{
+  using namespace mln;
+  using value::int_u8;
+  using value::int_u12;
+  using value::label_16;
+  using value::label_32;
+  typedef label_32 L;
+
+  if (argc != 6)
+  {
+    std::cout << "Usage: " << argv[0] << " <wst.dump> <dimensions> <ima.dcm> <dist_max> <nbasins>"
+	      << std::endl;
+    return 1;
+  }
+
+  unsigned dim = atoi(argv[2]);
+  unsigned dist_max = atoi(argv[4]);
+  if (dim != 2 && dim != 3)
+  {
+    std::cout << "<dimensions> invalid" << std::endl;
+    return 1;
+  }
+
+  L nbasins = atoi(argv[5]);
+  unsigned nbasins2 = 0;
+
+  if (dim == 2)
+  {
+    image2d<L> wshed;
+    io::dump::load(wshed, argv[1]);
+    image2d<int_u12> dcm;
+    io::dicom::load(dcm, argv[3]);
+
+    /// Build graph
+    util::graph g = make::graph(wshed, c4(), nbasins);
+    // Build graph images and compute distance values with a RGB image.
+    mln_VAR(ima_v, make_vertex_graph_image(g, dcm, wshed, nbasins));
+    mln_VAR(ima_e, make_edge_graph_image(ima_v, g));
+
+    /// Try to merge vertices.
+    mln_piter_(ima_e_t) e(ima_e.domain());
+    util::array<label_16> parent(g.v_nmax());
+    for (unsigned i = 0; i < parent.nelements(); ++i)
+      parent[i] = i;
+
+    for_all(e)
+    {
+      unsigned v1 = e.element().v1();
+      unsigned v2 = e.element().v2();
+      if (ima_e(e) <= dist_max && find_root(parent, v1) != find_root(parent, v2))
+	parent[find_root(parent, v1)] = find_root(parent, v2);
+    }
+
+    fun::i2v::array<label_16> f(parent.nelements());
+    std::vector<unsigned> new_label(parent.nelements(), 0);
+    for (unsigned i = 0; i < parent.nelements(); ++i)
+    {
+      unsigned p = find_root(parent, i);
+      mln_assertion(parent[p] == find_root(parent, i));
+      if (new_label[p] == 0)
+	new_label[p] = nbasins2++;
+      f(i) = new_label[p];
+    }
+    mln_invariant(f(0) == 0u);
+    --nbasins2; // nbasins2 does not count the basin with label 0.
+    image2d<label_16> wsd2 = level::transform(wshed, f);
+
+    /// Reconstruct a graph from the simplified image.
+    util::graph g2 = make::graph(wsd2, c4(), nbasins2);
+
+    // Compute distance values with a RGB image.
+    mln_VAR(ima_v2, make_vertex_graph_image(g2, dcm, wsd2, nbasins2));
+    mln_VAR(ima_e2, make_edge_graph_image(ima_v2, g2));
+
+    mln_VAR(wsd_, morpho::elementary::dilation(extend(wshed | (pw::value(wshed) == 0u), wshed), c8()));
+    data::fill((wshed | (pw::value(wshed) == 0u)).rw(), wsd_);
+
+    mln_VAR(wsd2_, morpho::elementary::dilation(extend(wsd2 | (pw::value(wsd2) == 0u), wsd2), c8()));
+    data::fill((wsd2 | (pw::value(wsd2) == 0u)).rw(), wsd2_);
+
+    io::pgm::save(level::stretch(int_u8(), labeling::mean_values(dcm, wshed, nbasins)), "wsd_original.pgm");
+    io::pgm::save(level::stretch(int_u8(), labeling::mean_values(dcm, wsd2, nbasins2)), "wsd_mean_colors.pgm");
+  }
+  else
+  {
+    // FIXME
+  }
+
+  std::cout << nbasins2 << std::endl;
+
+  return 0;
+}
Index: trunk/milena/sandbox/fabien/igr/check.sh
===================================================================
--- trunk/milena/sandbox/fabien/igr/check.sh	(revision 0)
+++ trunk/milena/sandbox/fabien/igr/check.sh	(revision 3517)
@@ -0,0 +1,32 @@
+#!/bin/zsh
+
+process_file ()
+{
+  echo "Processing $3..."
+  dist_max=10
+
+  ./grad $1 $2
+  for lambda_closing in 10 50 100 500 1000 5000 10000 50000; do
+    echo "  for lambda_closing = ${lambda_closing}";
+    ./clo_vol grad.dump $2 ${lambda_closing}
+    nbasins=`./wst clo_vol.dump $2`
+    ../bin/dumpl32_to_colorize wst.dump $2 $nbasins results/colorize_${3}_${lambda_closing}.ppm
+
+    if [ ${lambda_closing} -eq 100 ]; then
+      for lambda_dist in 10 50 100; do
+	nbasins_after=`./graph wst.dump $2 $1 $lambda_dist $nbasins`
+	mv wsd_original.pgm results/graph_${3}_${lambda_closing}_${lambda_dist}_01.pgm
+	mv wsd_mean_colors.pgm results/graph_${3}_${lambda_closing}_${lambda_dist}_02.pgm
+	echo "nbasins was" $nbasins "and now is" $nbasins_after "( diff =" $(($nbasins - $nbasins_after)) ")"
+      done
+    fi
+  done
+#  rm *.dump
+}
+
+process_file "/Users/HiSoKa/Work/IGR/souris18/irm/IM_0049.dcm" 2 "49"
+#process_file "/Users/HiSoKa/Work/IGR/souris18/irm/IM_0052.dcm" 3 "52"
+process_file "/Users/HiSoKa/Work/IGR/souris18/irm/IM_0055.dcm" 2 "55"
+process_file "/Users/HiSoKa/Work/IGR/souris18/irm/IM_0058.dcm" 2 "58"
+#process_file "/Users/HiSoKa/Work/IGR/souris18/irm/IM_0061.dcm" 3 "61"
+#process_file "/Users/HiSoKa/Work/IGR/souris18/irm/IM_0064.dcm" 3 "64"

Property changes on: trunk/milena/sandbox/fabien/igr/check.sh
___________________________________________________________________
Name: svn:executable
   + *

Index: trunk/milena/sandbox/fabien/igr/wst.cc
===================================================================
--- trunk/milena/sandbox/fabien/igr/wst.cc	(revision 0)
+++ trunk/milena/sandbox/fabien/igr/wst.cc	(revision 3517)
@@ -0,0 +1,71 @@
+#include <iostream>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+
+#include <mln/core/alias/neighb2d.hh>
+#include <mln/core/alias/window2d.hh>
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/alias/window3d.hh>
+
+#include <mln/io/dump/all.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/int_u12.hh>
+#include <mln/value/label_16.hh>
+#include <mln/value/label_32.hh>
+
+#include <mln/morpho/watershed/flooding.hh>
+
+
+
+///////////////////
+//               //
+// Main Function //
+//               //
+///////////////////
+
+
+int main(int argc, char *argv[])
+{
+  using namespace mln;
+  using value::int_u8;
+  using value::int_u12;
+  using value::label_16;
+  using value::label_32;
+  typedef label_32 L;
+
+  if (argc != 3)
+  {
+    std::cout << "Usage: " << argv[0] << " <ima.dcm> <dimensions>"
+	      << std::endl;
+    return 1;
+  }
+
+  unsigned dim = atoi(argv[2]);
+  if (dim != 2 && dim != 3)
+  {
+    std::cout << "<dimensions> invalid" << std::endl;
+    return 1;
+  }
+
+  L nbasins;
+
+  if (dim == 2)
+  {
+    image2d<int_u12> input;
+    io::dump::load(input, argv[1]);
+    image2d<L> wshed = morpho::watershed::flooding(input, c4(), nbasins);
+    io::dump::save(wshed, "wst.dump");
+  }
+  else
+  {
+    image3d<int_u12> input;
+    io::dump::load(input, argv[1]);
+    image3d<L> wshed = morpho::watershed::flooding(input, c6(), nbasins);
+    io::dump::save(wshed, "wst.dump");
+  }
+
+  std::cout << nbasins << std::endl;
+
+  return 0;
+}
Index: trunk/milena/sandbox/fabien/igr/grad.cc
===================================================================
--- trunk/milena/sandbox/fabien/igr/grad.cc	(revision 0)
+++ trunk/milena/sandbox/fabien/igr/grad.cc	(revision 3517)
@@ -0,0 +1,63 @@
+#include <iostream>
+#include <mln/core/image/image2d.hh>
+#include <mln/core/image/image3d.hh>
+
+#include <mln/core/alias/neighb2d.hh>
+#include <mln/core/alias/window2d.hh>
+#include <mln/core/alias/neighb3d.hh>
+#include <mln/core/alias/window3d.hh>
+
+#include <mln/io/dicom/load.hh>
+#include <mln/io/dump/save.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/int_u12.hh>
+
+#include <mln/morpho/elementary/gradient.hh>
+
+
+
+///////////////////
+//               //
+// Main Function //
+//               //
+///////////////////
+
+
+int main(int argc, char *argv[])
+{
+  using namespace mln;
+  using value::int_u8;
+  using value::int_u12;
+
+  if (argc != 3)
+  {
+    std::cout << "Usage: " << argv[0] << " <ima.dcm> <dimensions>"
+	      << std::endl;
+    return 1;
+  }
+
+  unsigned dim = atoi(argv[2]);
+  if (dim != 2 && dim != 3)
+  {
+    std::cout << "<dimensions> invalid" << std::endl;
+    return 1;
+  }
+
+  if (dim == 2)
+  {
+    image2d<int_u12> dcm2;
+    io::dicom::load(dcm2, argv[1]);
+    image2d<int_u12> grad2 = morpho::elementary::gradient(dcm2, c4());
+    io::dump::save(grad2, "grad.dump");
+  }
+  else
+  {
+    image3d<int_u12> dcm3;
+    io::dicom::load(dcm3, argv[1]);
+    image3d<int_u12> grad3 = morpho::elementary::gradient(dcm3, c6());
+    io::dump::save(grad3, "grad.dump");
+  }
+
+  return 0;
+}
Index: trunk/milena/sandbox/fabien/igr/Makefile
===================================================================
--- trunk/milena/sandbox/fabien/igr/Makefile	(revision 3516)
+++ trunk/milena/sandbox/fabien/igr/Makefile	(revision 3517)
@@ -1,32 +1,46 @@
-DICOM_INC = -I/Users/HiSoKa/Downloads/gdcm-2.0.10/Source/Common/ \
-	    -I/Users/HiSoKa/Downloads/gdcmbin/Source/Common/ \
-	    -I/Users/HiSoKa/Downloads/gdcm-2.0.10/Source/DataDictionary/ \
-	    -I/Users/HiSoKa/Downloads/gdcm-2.0.10/Source/MediaStorageAndFileFormat/ \
-	    -I/Users/HiSoKa/Downloads/gdcm-2.0.10/Source/DataStructureAndEncodingDefinition/
-DICOM_LIB = -L/Users/HiSoKa/Downloads/gdcmbin/bin \
+DCM_SRC=/Users/HiSoKa/Downloads/gdcm-2.0.10
+DCM_BIN=/Users/HiSoKa/Downloads/gdcmbin
+DICOM_INC = -I${DCM_SRC}/Source/Common/ \
+	    -I${DCM_BIN}/Source/Common/ \
+	    -I${DCM_SRC}/Source/DataDictionary/ \
+	    -I${DCM_SRC}/Source/MediaStorageAndFileFormat/ \
+	    -I${DCM_SRC}/Source/DataStructureAndEncodingDefinition/
+DICOM_LIBS = -L${DCM_BIN}/bin \
 	    -lgdcmCommon -lgdcmDICT -lgdcmDSED -lgdcmIOD -lgdcmMSFF -lgdcmexpat -lgdcmjpeg12 -lgdcmjpeg16 -lgdcmjpeg8 -lgdcmopenjpeg -lgdcmuuid -lgdcmzlib \
 	    -framework CoreFoundation
 CXXFLAGS = -DNDEBUG -O1
 
-all: 2d 3d wsd2d wsd3d
+all: 2d 3d wsd2d wsd3d grad
 
 2d: seg_vol_irm.hh seg2d.cc
-	g++ -I../../../ ${DICOM_INC} ${DICOM_LIB} ${CXXFLAGS} seg2d.cc -o seg2d
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} seg2d.cc -o seg2d
 
 3d: seg_vol_irm.hh seg3d.cc
-	g++ -I../../../ ${DICOM_INC} ${DICOM_LIB} ${CXXFLAGS} seg3d.cc -o seg3d
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} seg3d.cc -o seg3d
 
 wsd2d: watershed.hh watershed2d.cc
-	g++ -I../../../ ${DICOM_INC} ${DICOM_LIB} ${CXXFLAGS} $^ -o wsd2d
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} $^ -o wsd2d
 
 wsd3d: watershed.hh watershed3d.cc
-	g++ -I../../../ ${DICOM_INC} ${DICOM_LIB} ${CXXFLAGS} $^ -o wsd3d
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} $^ -o wsd3d
 
 wsd3dg: watershed.hh watershed3d.cc
-	g++ -I../../../ ${DICOM_INC} ${DICOM_LIB} -g $^ -o wsd3dg
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} -g $^ -o wsd3dg
 
 nbasins: nbasins_finder.cc
-	g++ -I../../../ ${DICOM_INC} ${DICOM_LIB} ${CXXFLAGS} $^ -o nbasins_finder
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} $^ -o nbasins_finder
+	
+grad: grad.cc
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} $^ -o grad
+	
+clo_vol: clo_vol.cc
+	g++ -I../../../ ${CXXFLAGS} $^ -o clo_vol
+
+wst: wst.cc
+	g++ -I../../../ ${CXXFLAGS} $^ -o wst
+	
+graph: graph.cc
+	g++ -I../../../ ${DICOM_INC} ${DICOM_LIBS} ${CXXFLAGS} $^ -o graph
 	
 clean:
 	rm -rf *.dump *.p?m *.plot *.log *.csv
Index: trunk/milena/sandbox/fabien/TODO
===================================================================
--- trunk/milena/sandbox/fabien/TODO	(revision 3516)
+++ trunk/milena/sandbox/fabien/TODO	(revision 3517)
@@ -26,5 +26,7 @@
 [X] Create 3D US morpho with 2D stack
 [ ] Create macro for_all_slice
 [X] Batch process watershed with 2D, 3D and any combination of parameters
-[ ] Cut into small tools
-[ ] Test 3D workflow on 2D images
+[X] Cut into small tools
+[X] Test 3D workflow on 2D images
+[ ] Create colorized colors for graph
+[ ] Diff with %
Index: trunk/milena/sandbox/fabien/bin/dumpl32_to_colorize.cc
===================================================================
--- trunk/milena/sandbox/fabien/bin/dumpl32_to_colorize.cc	(revision 0)
+++ trunk/milena/sandbox/fabien/bin/dumpl32_to_colorize.cc	(revision 3517)
@@ -0,0 +1,61 @@
+#include <mln/core/image/image2d.hh>
+#include <mln/make/image3d.hh>
+#include <mln/debug/slices_2d.hh>
+#include <mln/debug/colorize.hh>
+
+#include <mln/value/int_u8.hh>
+#include <mln/value/int_u12.hh>
+#include <mln/value/label_32.hh>
+#include <mln/value/rgb8.hh>
+#include <mln/core/concept/literal.hh>
+
+#include <mln/io/dump/load.hh>
+#include <mln/io/ppm/save.hh>
+
+
+int usage(char* argv[])
+{
+  std::cerr << "usage: " << argv[0] << " input.dump dim nbasins output.ppm" << std::endl;
+  return 1;
+}
+
+
+
+int main(int argc, char* argv[])
+{
+  using namespace mln;
+  using value::int_u8;
+  using value::int_u12;
+  using value::label_32;
+  using value::rgb8;
+
+  if (argc != 5)
+    return usage(argv);
+
+  unsigned dim = atoi(argv[2]);
+  unsigned nbasins = atoi(argv[3]);
+  if (dim != 2 && dim != 3)
+  {
+    std::cout << "<dimensions> invalid" << std::endl;
+    return 1;
+  }
+
+  if (dim == 2)
+  {
+    image2d<label_32> ima2d;
+    io::dump::load(ima2d, argv[1]);
+    image2d<rgb8> ima_rgb = debug::colorize(rgb8(), ima2d, nbasins);
+    io::ppm::save(ima_rgb, argv[4]);
+  }
+  else
+  {
+    image3d<label_32> ima3d;
+    io::dump::load(ima3d, argv[1]);
+    image3d<rgb8> ima_rgb = debug::colorize(rgb8(), ima3d, nbasins);
+
+    image2d<rgb8> ima_result = debug::slices_2d(ima_rgb, 1.f, literal::black);
+    io::ppm::save(ima_result, argv[4]);
+  }
+
+  return 0;
+}

    