proto-1.0 277: Add grey level self-dual reconstruction and clean reconstruction classes. - Olena-patches

11 Oct 2005

https://svn/svn/oln/prototypes/proto-1.0/olena
Index: ChangeLog
from  Damien Thivolle  damien@lrde.epita.fr
Add grey level self-dual reconstruction and clean reconstruction classes.
* tests/morpho/tests/reconstruction: Remove. Split into two files
    (binary and grey level).
    * tests/morpho/tests/reconstruction_binary: New. Test reconstruction
    algorithms on binary images.
    * tests/morpho/tests/reconstruction_greylevel: New. Test
    reconstruction algorithms on grey level images.
    * oln/funobj/invert.hh: Now use UCHAR_MAX.
    * oln/morpho/reconstruction_by_dilation.hh: Call exact() when passing
    input images to the upper class.
    * oln/morpho/reconstruction_by_erosion.hh: Likewise.
    * oln/morpho/reconstruction_selfdual.hh: Add grey level self-dual
    reconstruction class.
    * oln/canvas/reconstruction.hh: Remove useless image boxes.
oln/canvas/reconstruction.hh                |   62 +++-----------
 oln/funobj/invert.hh                        |    2 
 oln/morpho/reconstruction_by_dilation.hh    |   21 ++--
 oln/morpho/reconstruction_by_erosion.hh     |   18 ++--
 oln/morpho/reconstruction_selfdual.hh       |  122 ++++++++++++++++++++++++++--
 tests/morpho/tests/reconstruction_greylevel |  106 ++++++++++++++++++++++++
 6 files changed, 256 insertions(+), 75 deletions(-)
Index: tests/morpho/tests/reconstruction_greylevel

--- tests/morpho/tests/reconstruction_greylevel	(revision 0)
+++ tests/morpho/tests/reconstruction_greylevel	(revision 0)
@@ -0,0 +1,106 @@
+// -*- C++ -*-
+
+#include "data.hh"
+#include <oln/basics2d.hh>
+#include <ntg/all.hh>
+
+#include <oln/core/gen/image_with_nbh.hh>
+
+#include <oln/morpho/reconstruction.hh>
+
+#include <oln/io/read_image.hh>
+
+#include <oln/level/compare.hh>
+#include <oln/utils/md5.hh>
+#include <oln/level/invert.hh>
+
+// FIXME: Debug.
+#include <oln/io/write_image.hh>
+
+bool check()
+{
+  using namespace oln;
+  image2d<unsigned char> marker;
+  image2d<unsigned char> mask;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_dil_hyb;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_dil_seq;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_dil_par;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_ero_hyb;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_ero_seq;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_ero_par;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_selfdual;
+  image_with_nbh<image2d<unsigned char>, neighborhood2d> res_selfdual_invert;
+
+  utils::key::value_type data_key[16] =
+    {0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x0, 0xb2, 0x4,
+     0xe9, 0x80, 0x9, 0x98, 0xec, 0xf8, 0x42, 0x7e};
+  utils::key key(data_key);
+
+  marker = io::read(rdata("marker.pgm"));
+  mask = io::read(rdata("mask.pgm"));
+
+  res_dil_hyb =
+    morpho::reconstruction(join(marker, neighb_c4()),
+			   mask,
+			   morpho::tag::hybrid(),
+			   morpho::tag::by_dilation());
+  res_dil_seq =
+    morpho::reconstruction(join(marker, neighb_c4()),
+			   mask,
+			   morpho::tag::sequential(),
+			   morpho::tag::by_dilation());
+
+  res_dil_par =
+    morpho::reconstruction(join(marker, neighb_c4()),
+			   mask,
+			   morpho::tag::parallel(),
+			   morpho::tag::by_dilation());
+
+  image2d<unsigned char> marker_c(level::invert(marker));
+
+  res_ero_hyb =
+    morpho::reconstruction(join(marker_c, neighb_c4()),
+			   level::invert(mask),
+			   morpho::tag::hybrid(),
+			   morpho::tag::by_erosion());
+  res_ero_seq =
+    morpho::reconstruction(join(marker_c, neighb_c4()),
+			   level::invert(mask),
+			   morpho::tag::sequential(),
+			   morpho::tag::by_erosion());
+
+  res_ero_par =
+    morpho::reconstruction(join(marker_c, neighb_c4()),
+			   level::invert(mask),
+			   morpho::tag::parallel(),
+			   morpho::tag::by_erosion());
+
+  res_selfdual =
+    morpho::reconstruction_selfdual(join(marker, neighb_c4()),
+				    mask);
+
+  res_selfdual_invert =
+    morpho::reconstruction_selfdual(join(marker_c, neighb_c4()),
+				    level::invert(mask));
+
+  if (utils::md5(res_dil_hyb) != key)
+    return true;
+
+
+  if (!level::is_equal(res_dil_hyb, res_dil_seq))
+    return true;
+  if (!level::is_equal(res_ero_hyb, res_ero_seq))
+    return true;
+  if (!level::is_equal(res_dil_hyb, res_dil_par))
+    return true;
+  if (!level::is_equal(res_ero_hyb, res_ero_par))
+    return true;
+  if (!level::is_equal(res_selfdual, level::invert(res_selfdual_invert)))
+    return true;
+  if (!level::is_equal(res_dil_hyb, level::invert(res_ero_seq)))
+    return true;
+
+  return false;
+}
+
+
Index: oln/funobj/invert.hh
--- oln/funobj/invert.hh	(revision 276)
+++ oln/funobj/invert.hh	(working copy)
@@ -46,7 +46,7 @@
     {
       unsigned char operator()(const unsigned char& v) const
       {
-	return 255 - v;
+	return UCHAR_MAX - v;
       }
bool operator()(const bool& v) const
Index: oln/morpho/reconstruction_by_dilation.hh
--- oln/morpho/reconstruction_by_dilation.hh	(revision 276)
+++ oln/morpho/reconstruction_by_dilation.hh	(working copy)
@@ -53,9 +53,6 @@
    using super_type::output;
    using super_type::bkd_p;
    using super_type::fwd_p;
-	using super_type::n;
-	using super_type::p;
-
void impl_bkd_loop_body()
    {
@@ -71,7 +68,7 @@
binary_reconstruction_by_dilation(const abstract::binary_image<I1>& marker,
    				  const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -123,7 +120,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -155,7 +152,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -199,7 +196,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -244,7 +241,7 @@
greylevel_reconstruction_by_dilation(const abstract::greylevel_image<I1>& marker,
    				     const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -294,7 +291,7 @@
greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
    			 const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -326,7 +323,7 @@
greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
    			 const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -360,7 +357,7 @@
    {
      output[fwd_p] =
        f_max_alt(output[fwd_p].value(),
-		      local_sup_value(join(output, marker.nbh_get()), fwd_p));
+		      local_sup_value(join(save, marker.nbh_get()), fwd_p));
    }
void impl_second_step()
@@ -375,7 +372,7 @@
greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
    			 const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
Index: oln/morpho/reconstruction_selfdual.hh
--- oln/morpho/reconstruction_selfdual.hh	(revision 276)
+++ oln/morpho/reconstruction_selfdual.hh	(working copy)
@@ -57,7 +57,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -74,7 +74,8 @@
void impl_bkd_loop_body()
    {
-	  if (output[bkd_p] < mask[bkd_p])
+	  // output[bkd_p] < mask[bkd_p]
+	  if (not output[bkd_p] and mask[bkd_p])
        output[bkd_p] = mask[bkd_p] and
          (output[bkd_p] or local_or_value_bkd(join(output, marker.nbh_get()), bkd_p));
      else
@@ -84,7 +85,8 @@
void impl_fwd_loop_body()
    {
-	  if (output[fwd_p] < mask[fwd_p])
+	  // output[fwd_p] < mask[fwd_p]
+	  if (not output[fwd_p] and mask[fwd_p])
        output[fwd_p] = mask[fwd_p] and
          (output[fwd_p] or local_or_value_fwd(join(output, marker.nbh_get()), fwd_p));
      else
@@ -95,16 +97,120 @@
void impl_fifo_loop_body()
    {
+	  // output[n] < mask[p]
+	  if (not output[n] and mask[p])
+	    {
+	      // output[n] < output[p] and mask[n] != output[n]
+	      if (output[p] and mask[n] != output[n])
+		{
+		  output[n] = output[p] and mask[n];
+		  fifo.push(n);
+		}
+	    }
+	  else
+	    // output[n] > output[p] && mask[n] != output[n]
+	    if (output[n] and not output[p] and mask[n] != output[n])
+	      {
+		output[n] = output[p] or mask[n];
+		fifo.push(n);
+	      }
+	}
+
+	bool impl_test_fifo_push()
+	{
+	  // (output[n] < output[bkd_p] and output[n] < mask[n]) or
+	  // (output[n] > output[bkd_p] and output[n] > mask[n])
+	  return output.hold(n) &&
+	    ((not output[n] and output[bkd_p] and mask[n]) ||
+	     (output[n] and not output[bkd_p] and not mask[n]));
+	}
+
+	void impl_preconditions() const
+	{
+	}
+
+      };
+
+
+
+      // GREY LEVEL
+
+      template<typename I1, typename I2>
+      struct greylevel_reconstruction <I1, I2, tag::selfdual_type, tag::none_type>
+	: public canvas::reconstruction<I1, I2, tag::hybrid_type,
+	    greylevel_reconstruction<I1, I2, tag::selfdual_type, tag::none_type> >
+      {
+	typedef greylevel_reconstruction<I1, I2, tag::selfdual_type,
+					 tag::none_type> self_type;
+	typedef canvas::reconstruction<I1, I2, tag::hybrid_type,
+				       self_type> super_type;
+	typedef oln_type_of(I1, value) value_type;
+
+	greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
+				 const abstract::greylevel_image<I2>& mask) :
+	  super_type(marker.exact(), mask.exact())
+	{
+	  mlc_is_a(I1, abstract::image_with_nbh)::ensure();
+	}
+
+	using super_type::mask;
+	using super_type::marker;
+	using super_type::output;
+	using super_type::fwd_p;
+	using super_type::bkd_p;
+	using super_type::p;
+	using super_type::n;
+	using super_type::fifo;
+
+
+	void impl_bkd_loop_body()
+	{
+	  if (output[bkd_p] < mask[bkd_p])
+	    {
+	      value_type max =
+		f_max_alt(output[bkd_p].value(),
+			  local_sup_value_bkd(join(output, marker.nbh_get()), bkd_p));
+	      output[bkd_p] = f_min_alt(mask[bkd_p].value(), max);
+	    }
+	  else
+	    {
+	      value_type min =
+		f_min_alt(output[bkd_p].value(),
+			  local_inf_value_bkd(join(output, marker.nbh_get()), bkd_p));
+	      output[bkd_p] = f_max_alt(mask[bkd_p].value(), min);
+	    }
+	}
+
+	void impl_fwd_loop_body()
+	{
+	  if (output[fwd_p] < mask[fwd_p])
+	    {
+	      value_type max =
+		f_max_alt(output[fwd_p].value(),
+			  local_sup_value_fwd(join(output, marker.nbh_get()), fwd_p));
+	      output[fwd_p] = f_min_alt(mask[fwd_p].value(), max);
+	    }
+	  else
+	    {
+	      value_type min =
+		f_min_alt(output[fwd_p].value(),
+			  local_inf_value_fwd(join(output, marker.nbh_get()), fwd_p));
+	      output[fwd_p] = f_max_alt(mask[fwd_p].value(), min);
+	    }
+	}
+
+	void impl_fifo_loop_body()
+	{
      if (output[n] < mask[p])
        {
-	      if (output[n] < output[p] && mask[n] != output[n])
+	      if (output[n] < output[p] and mask[n] != output[n])
    	{
    	  output[n] = f_min_alt(output[p].value(), mask[n].value());
    	  fifo.push(n);
    	}
        }
      else
-	    if (output[n] > output[p] && mask[n] != output[n])
+	    if (output[n] > output[p] and mask[n] != output[n])
          {
    	output[n] = f_max_alt(output[p].value(), mask[n].value());
    	fifo.push(n);
@@ -113,9 +219,9 @@
bool impl_test_fifo_push()
    {
-	  return output.hold(n) &&
-	    ((output[n] < output[bkd_p] && output[n] < mask[n]) ||
-	     (output[n] > output[bkd_p] && output[n] > mask[n]));
+	  return output.hold(n) and
+	    ((output[n] < output[bkd_p] and output[n] < mask[n]) or
+	     (output[n] > output[bkd_p] and output[n] > mask[n]));
    }
void impl_preconditions() const
Index: oln/morpho/reconstruction_by_erosion.hh
--- oln/morpho/reconstruction_by_erosion.hh	(revision 276)
+++ oln/morpho/reconstruction_by_erosion.hh	(working copy)
@@ -70,7 +70,7 @@
binary_reconstruction_by_erosion(const abstract::binary_image<I1>& marker,
    				 const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -122,7 +122,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -154,7 +154,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -198,7 +198,7 @@
binary_reconstruction(const abstract::binary_image<I1>& marker,
    		      const abstract::binary_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -250,7 +250,7 @@
greylevel_reconstruction_by_erosion(const abstract::greylevel_image<I1>& marker,
    				     const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -300,7 +300,7 @@
greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
    			 const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -332,7 +332,7 @@
greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
    			 const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
@@ -365,7 +365,7 @@
    {
      output[fwd_p] =
        f_min_alt(output[fwd_p].value(),
-		      local_inf_value(join(output, marker.nbh_get()), fwd_p));
+		      local_inf_value(join(save, marker.nbh_get()), fwd_p));
    }
void impl_second_step()
@@ -380,7 +380,7 @@
greylevel_reconstruction(const abstract::greylevel_image<I1>& marker,
    			 const abstract::greylevel_image<I2>& mask) :
-	  super_type(marker, mask)
+	  super_type(marker.exact(), mask.exact())
    {
      mlc_is_a(I1, abstract::image_with_nbh)::ensure();
    }
Index: oln/canvas/reconstruction.hh
--- oln/canvas/reconstruction.hh	(revision 276)
+++ oln/canvas/reconstruction.hh	(working copy)
@@ -108,11 +108,7 @@
void init()
       {
-	// FIXME: We can't use `output = clone(marker)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	output_type output_tmp(clone(marker));
-	output = output_tmp;
+	output = clone(marker);
       }
void run()
@@ -146,12 +142,12 @@
oln_type_of(I1, concrete) get_output()
       {
-	return output.unbox();
+	return output;
       }
protected:
-      reconstruction(const abstract::image<I1>& marker,
+      reconstruction(const abstract::image_with_nbh<I1>& marker,
    	     const abstract::image<I2>& mask) :
    marker(marker.exact()),
    mask(mask.exact()),
@@ -180,7 +176,7 @@
       oln_type_of(I1, point) p;
       oln_type_of(I1, niter) n;
-      box<oln_type_of(I1, concrete)> output;
+      oln_type_of(I1, concrete) output;
std::queue<oln_type_of(I1, point) > fifo;
@@ -203,17 +199,8 @@
void impl_init()
       {
-	// FIXME: We can't use `output = clone(marker)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	output_type output_tmp(clone(marker));
-	output = output_tmp;
-	// FIXME: We can't use `save = clone(marker)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	output_type save_tmp(clone(marker));
-	save = save_tmp;
-
+	output = clone(marker);
+	save = clone(marker);
       }
bool impl_is_stable() const
@@ -223,31 +210,27 @@
void impl_re_loop()
       {
-	// FIXME: We can't use `save = clone(output)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	save.unbox() = clone(output);
+	save = clone(output);
       }
oln_type_of(I1, concrete) get_output()
       {
-	return output.unbox();
+	return output;
       }
protected:
-      reconstruction(const abstract::image<I1>& marker,
+      reconstruction(const abstract::image_with_nbh<I1>& marker,
    	     const abstract::image<I2>& mask) :
    super_type(marker),
    marker(marker.exact()),
    mask(mask.exact()),
    n(marker)
       {
-	mlc_is_a(I1, abstract::image_with_nbh)::ensure();
       }
-      box<oln_type_of(I1, concrete)> save;
-      box<oln_type_of(I1, concrete)> output;
+      oln_type_of(I1, concrete) save;
+      oln_type_of(I1, concrete) output;
       box<const I1> marker;
       box<const I2> mask;
       oln_type_of(I1, point) p;
@@ -293,16 +276,8 @@
void impl_init()
       {
-	// FIXME: We can't use `output = clone(marker)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	output_type output_tmp(clone(marker));
-	output = output_tmp;
-	// FIXME: We can't use `save = clone(marker)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	output_type save_tmp(clone(marker));
-	save = save_tmp;
+	output = clone(marker);
+	save = clone(marker);
       }
bool impl_is_stable() const
@@ -312,15 +287,12 @@
void impl_re_loop()
       {
-	// FIXME: We can't use `save = clone(output)' directly here,
-	// because box's op=(const abstract::image<II>& rhs) would be
-	// called, which is empty (see oln/core/box.hh).
-	save.unbox() = clone(output);
+	save = clone(output);
       }
oln_type_of(I1, concrete) get_output()
       {
-	return output.unbox();
+	return output;
       }
protected:
@@ -336,8 +308,8 @@
    mlc_check_method_impl(E, void, second_step,	, );
       }
-      box<oln_type_of(I1, concrete)> save;
-      box<oln_type_of(I1, concrete)> output;
+      oln_type_of(I1, concrete) save;
+      oln_type_of(I1, concrete) output;
       box<const I1> marker;
       box<const I2> mask;
       oln_type_of(I1, fwd_piter) fwd_p;

    