[Olena-patches] 1555: Overhaul mln::t_image.

27 Nov 2007

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


Index: ChangeLog
from Roland Levillain <roland@lrde.epita.fr>

	Overhaul mln::t_image.

	* mln/core/t_image.hh (mln::internal::data_t< t_image >): New.
	(mln::t_image): Revamp.
	Inherit from internal::image_morpher_< I, mln_pset(I), t_image >.
	(t_image::super_): Adjust typedef.
	(t_image::psite, t_image::value)
	(t_image::rvalue, t_image::vset):
	New properties.
	(t_image::lvalue): Fix properties.
	(t_image::t_image): Adjust for mln::internal::data_t< t_image >.
	Document ctor.
	(t_image::has_data, t_image::values): New methods.
	(t_image::c1_, t_image::c2_, t_image::b_): Remove.
	Superseded by data_::dim1_, data_::dim2_ and data_::box_.
	(t_image::exchange_coords_): New method.
	Use it to redefine...
	(t_image::transpose_): ...this method.
	Document.
	(t_image::owns_, t_image::operator()): Adjust.
	* tests/t_image.cxx: Rename as...
	* tests/t_image.cc: ...this.
	s/image2d_b/image2d/.

 mln/core/t_image.hh | 215 ++++++++++++++++++++++++++++++++++++++++------------
 tests/t_image.cc | 8 -
 2 files changed, 173 insertions(+), 50 deletions(-)

Index: mln/core/t_image.hh

--- mln/core/t_image.hh	(revision 1555)
+++ mln/core/t_image.hh	(working copy)
@@ -33,12 +33,45 @@
  * \brief Definition of the "transposed" image class mln::t_image.
  */
 
-# include <mln/core/internal/image_adaptor.hh>
+# include <mln/core/internal/image_morpher.hh>
+# include <mln/core/box.hh>
 
 
 namespace mln
 {
 
+  // Fwd decl.
+  template <typename I> struct t_image;
+
+  namespace internal
+  {
+    
+    /// Data held by a mln::t_image.
+    template <typename I>
+    struct data_< t_image<I> >
+    {
+      /// \brief Build the data object held by a t_image.
+      ///
+      /// \param ima  The underlying image.
+      /// \param dim1 The first dimension to be swapped.
+      /// \param dim2 The second dimension to be swapped.
+      /// \param box  The bounding box (domain) of the morphed image.
+      data_(I& ima, unsigned dim1, unsigned dim2,
+	    mln::box_<mln_point(I)>& box);
+
+      /// Underlying image.
+      I ima_;
+      /// The swapped dimensions.
+      /// \{
+      unsigned dim1_;
+      unsigned dim2_;
+      /// \}
+      /// The bounding box of the morphed image.
+      mln::box_<mln_point(I)> box_;
+    };
+
+  } // end of namespace mln::internal
+
 
   /*! \brief Transposed image class.
    *
@@ -47,11 +80,52 @@
    * \warning This class only works on images whose domain is a box.
    */
   template <typename I>
-  struct t_image : public internal::image_adaptor_< I, t_image<I> >
+  class t_image
+    : public internal::image_morpher_< I, mln_pset(I), t_image<I> >
   {
+  public:
+    /// Super type.
+    typedef
+      internal::image_morpher_< I, mln_pset(I), t_image<I> > super_;
+
+    /// Point_Site associated type.
+    typedef mln_psite(I) psite;
+
+    /// Value associated type.
+    typedef mln_value(I) value;
+
+    /// Type returned by the read-write pixel value operator.
+    typedef typename internal::morpher_lvalue_<I>::ret lvalue;
+
+    /// Return type of read-only access.
+    typedef mln_rvalue(I) rvalue;
+
+    /// Value set associated type.
+    typedef mln::value::set<value> vset;
+
+
     /// Skeleton.
     typedef t_image< tag::image_<I> > skeleton;
 
+  public:
+    /// \brief Build the generalized transpose of an image.
+    ///
+    /// In the 2-dimension case, \a dim1 and \a dim2 must be resp. 1 and 2
+    /// (or 2 and 1), and t_image is a transpose of a matrix with the
+    /// usual meaning.
+    ///
+    /// In dimensions greater than 2, mln::t_image represents a view
+    /// of the underlying image where two dimensions (i.e., two
+    /// components of each point) have been exchanged.
+    ///
+    /// \param ima  The underlying image.
+    /// \param dim1 The first dimension to be swapped.
+    /// \param dim2 The second dimension to be swapped.
+    t_image(I& ima, unsigned dim1, unsigned dim2);
+
+    /// Test if this image has been initialized.
+    bool has_data() const;
+
     /// Test if a pixel value is accessible at \p p.
     bool owns_(const mln_point(I)& p) const;
 
@@ -61,90 +135,108 @@
     /// Read-only access of pixel value at point site \p p.
     mln_rvalue(I) operator()(const mln_point(I)& p) const;
 
-    /// Type returned by the read-write pixel value operator.
-    typedef typename internal::morpher_lvalue_<I>::ret lvalue;
-
     /// Read-write access of pixel value at point site \p p.
     lvalue operator()(const mln_point(I)& p);
 
-    /// Constructor.
-    t_image(I& ima, unsigned c1, unsigned c2);
+    /// Give the set of values of the image.
+    const vset& values() const;
 
   protected:
-
-    typedef internal::image_adaptor_< I, t_image<I> > super_;
-    const unsigned c1_, c2_; // coords to swap
-    box_<mln_point(I)> b_;
-
+    /// Exchange components \a dim1_ and \a dim2_ of point \a p.
     mln_point(I) transpose_(const mln_point(I)& p) const;
+    /// Exchange components \a dim1 and \a dim2 of point \a p.
+    mln_point(I) exchange_coords_(const mln_point(I)& p,
+				  unsigned dim1, unsigned dim2) const;
   };
 
 
+  /* FIXME: Shouldn't we move these elsewhere?  I (Roland) think mixing
+     data structure and routines is confusing, even if they are
+     closely related.  What about mln/geom/swap_coords.hh?  */
   template <typename I>
-  t_image<I> swap_coords(Image<I>& ima, unsigned c1, unsigned c2);
+  t_image<I>
+  swap_coords(Image<I>& ima, unsigned dim1, unsigned dim2);
 
   template <typename I>
-  t_image<const I> swap_coords(const Image<I>& ima, unsigned c1, unsigned c2);
+  t_image<const I>
+  swap_coords(const Image<I>& ima, unsigned dim1, unsigned dim2);
 
 
 
 # ifndef MLN_INCLUDE_ONLY
 
+  namespace internal
+  {
+
+    // internal::data_< t_image<I,S> >
+
   template <typename I>
-  t_image<I> swap_coords(Image<I>& ima, unsigned c1, unsigned c2)
+    data_< t_image<I> >::data_(I& ima,
+			       unsigned dim1, unsigned dim2,
+			       mln::box_<mln_point(I)>& box)
+      : ima_(ima),
+	dim1_(dim1), dim2_(dim2),
+	box_(box)
   {
-    typedef mln_point(I) P;
-    mln_precondition(c1 != c2);
-    mln_precondition(c1 <= P::dim && c2 <= P::dim);
-    t_image<I> tmp(exact(ima), c1, c2);
-    return tmp;
   }
 
+  } // end of namespace mln::internal
+
+
   template <typename I>
-  t_image<const I> swap_coords(const Image<I>& ima, unsigned c1, unsigned c2)
+  t_image<I>::t_image(I& ima, unsigned dim1, unsigned dim2)
   {
-    typedef mln_point(I) P;
-    mln_precondition(c1 != c2);
-    mln_precondition(c1 <= P::dim && c2 <= P::dim);
-    t_image<const I> tmp(exact(ima), c1, c2);
-    return tmp;
+    mln_precondition(ima.has_data());
+    /* FIXME: Add a precondition on the fact that the domain of ima is
+       a box.  */
+    // We don't use mln::t_image::transpose here, since one its
+    // prerequisite is that data_ is initialized, which is not done
+    // yet at this point.
+    box_<mln_point(I)> box(exchange_coords_(ima.bbox().pmin(), dim1, dim2),
+			   exchange_coords_(ima.bbox().pmax(), dim1, dim2));
+    this->data_ = new internal::data_< t_image<I> >(ima, dim1, dim2, box);
   }
 
   template <typename I>
-  t_image<I>::t_image(I& ima, unsigned c1, unsigned c2)
-    : super_(ima),
-      c1_(c1),
-      c2_(c2)
+  bool t_image<I>::has_data() const
   {
-    mln_precondition(ima.has_data());
-    b_.pmin() = transpose_(this->adaptee_.bbox().pmin());
-    b_.pmax() = transpose_(this->adaptee_.bbox().pmax());
+    mln_invariant(this->delegatee_()->has_data());
+    return true;
+  }
+
+  template <typename I>
+  bool
+  t_image<I>::owns_(const mln_point(I)& p) const
+  {
+    mln_precondition(this->has_data());
+    return this->delegatee_()->owns_(transpose_(p));
   }
 
   template <typename I>
   mln_point(I)
   t_image<I>::transpose_(const mln_point(I)& p) const
   {
-    mln_point(I) tmp(p);
-    tmp[c1_] = p[c2_];
-    tmp[c2_] = p[c1_];
-    return tmp;
+    mln_precondition(this->has_data());
+    return exchange_coords_(p, this->data_->dim1_, this->data_->dim2_);
   }
 
   template <typename I>
-  const box_<mln_point(I)>&
-  t_image<I>::domain() const
+  mln_point(I)
+  t_image<I>::exchange_coords_(const mln_point(I)& p,
+			       unsigned dim1, unsigned dim2) const
   {
-    mln_precondition(this->has_data());
-    return b_;
+    mln_point(I) tmp(p);
+    tmp[dim1] = p[dim2];
+    tmp[dim2] = p[dim1];
+    return tmp;
   }
 
   template <typename I>
-  bool
-  t_image<I>::owns_(const mln_point(I)& p) const
+  const box_<mln_point(I)>&
+  t_image<I>::domain() const
   {
     mln_precondition(this->has_data());
-    return this->adaptee_.owns_(transpose_(p));
+    return this->data_->box_;
   }
 
   template <typename I>
@@ -152,7 +244,7 @@
   t_image<I>::operator()(const mln_point(I)& p) const
   {
     mln_precondition(this->owns_(p));
-    return this->adaptee_(transpose_(p));
+    return this->data_->ima_(transpose_(p));
   }
 
   template <typename I>
@@ -160,7 +252,38 @@
   t_image<I>::operator()(const mln_point(I)& p)
   {
     mln_precondition(this->owns_(p));
-    return this->adaptee_(transpose_(p));
+    return this->data_->ima_(transpose_(p));
+  }
+
+  template <typename I>
+  const typename t_image<I>::vset&
+  t_image<I>::values() const
+  {
+    mln_precondition(this->delegatee_() != 0);
+    return this->delegatee_()->values();
+  }
+
+
+  template <typename I>
+  t_image<I>
+  swap_coords(Image<I>& ima, unsigned dim1, unsigned dim2)
+  {
+    typedef mln_point(I) P;
+    mln_precondition(dim1 != dim2);
+    mln_precondition(dim1 <= P::dim && dim2 <= P::dim);
+    t_image<I> tmp(exact(ima), dim1, dim2);
+    return tmp;
+  }
+
+  template <typename I>
+  t_image<const I>
+  swap_coords(const Image<I>& ima, unsigned dim1, unsigned dim2)
+  {
+    typedef mln_point(I) P;
+    mln_precondition(dim1 != dim2);
+    mln_precondition(dim1 <= P::dim && dim2 <= P::dim);
+    t_image<const I> tmp(exact(ima), dim1, dim2);
+    return tmp;
   }
 
 # endif // ! MLN_INCLUDE_ONLY
Index: tests/t_image.cc
--- tests/t_image.cc	(revision 1423)
+++ tests/t_image.cc	(working copy)
@@ -30,7 +30,7 @@
  * \brief Tests on mln::t_image.
  */
 
-#include <mln/core/image2d_b.hh>
+#include <mln/core/image2d.hh>
 #include <mln/core/t_image.hh>
 
 #include <mln/debug/iota.hh>
@@ -41,12 +41,12 @@
 {
   using namespace mln;
 
-  typedef image2d_b<int> I;
+  typedef image2d<int> I;
 
   I ima(2, 3);
   debug::iota(ima);
   debug::println(ima);
 
-  t_image<I> tima(ima, 0, 1);
-  debug::println(tima);
+  t_image<I> t_ima(ima, 0, 1);
+  debug::println(t_ima);
 }

    

[Olena-patches] 1555: Overhaul mln::t_image<I>.

Roland Levillain