Index: oln/convert/nbh_to_se.hh
===================================================================
--- oln/convert/nbh_to_se.hh	(revision 130)
+++ oln/convert/nbh_to_se.hh	(working copy)
@@ -28,15 +28,9 @@
 #ifndef OLENA_CONVERT_NBH_TO_SE_HH
 # define OLENA_CONVERT_NBH_TO_SE_HH
 
-# include <oln/basics.hh>
+# include <oln/core/abstract/neighborhood.hh>
+# include <oln/core/2d/dpoint2d.hh>
 
-// because of the internal function in this file
-//# include <oln/basics1d.hh>
-# include <oln/basics2d.hh>
-//# include <oln/basics3d.hh>
-//# include <oln/core/1d/neighborhood1d.hh>
-# include <oln/core/2d/neighborhood2d.hh>
-//# include <oln/core/3d/neighborhood3d.hh>
 
 namespace oln {
   namespace convert {
@@ -45,10 +39,10 @@
     ** \see nbh_to_cse
     */
     template<class N>
-    oln_type_of(N, window)
+    oln_nbh_type_of(N, window)
     nbh_to_se(const oln::abstract::neighborhood<N>& nbh)
     {
-      oln_type_of(N, window) output;
+      oln_nbh_type_of(N, window) output;
 
       for (unsigned i = 0; i < nbh.card(); i++)
 	output.add(nbh[i]);
@@ -66,15 +60,15 @@
     ** \see nbh_to_cs
     */
     template<class N>
-    oln_type_of(N, window)
+    oln_nbh_type_of(N, window)
     nbh_to_cse(const oln::abstract::neighborhood<N>& nbh)
     {
-      oln_type_of(N, window) output;
+      oln_nbh_type_of(N, window) output;
 
       for (unsigned i = 0; i < nbh.card(); i++)
 	output.add(nbh[i]);
 
-      oln_type_of(N, dpoint) zero;
+      oln_nbh_type_of(N, dpoint) zero;
       dpoint_zero(zero);
       output.add(zero);
       return output;
Index: oln/basics2d.hh
===================================================================
--- oln/basics2d.hh	(revision 130)
+++ oln/basics2d.hh	(working copy)
@@ -36,7 +36,7 @@
 # include <oln/core/2d/image2d.hh>
 # include <oln/core/2d/fwd_piter2d.hh>
 # include <oln/core/2d/bkd_piter2d.hh>
-# include <oln/core/2d/fwd_witer2d.hh>
+# include <oln/core/2d/fwd_qiter2d.hh>
 # include <oln/core/2d/window2d.hh>
 # include <oln/core/2d/neighborhood2d.hh>
 
Index: oln/core/typedefs.hh
===================================================================
--- oln/core/typedefs.hh	(revision 0)
+++ oln/core/typedefs.hh	(revision 0)
@@ -0,0 +1,107 @@
+// Copyright (C) 2005 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library 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 OLENA_CORE_TYPEDEFS_HH
+# define OLENA_CORE_TYPEDEFS_HH
+
+// FIXME: rename this present file (?)
+
+
+# include <mlc/types.hh>
+# include <mlc/typedef.hh>
+# include <mlc/properties.hh>
+# include <mlc/to_string.hh>
+
+
+
+
+namespace oln
+{
+
+  mlc_equip_namespace_with_properties();
+
+  // category::image
+
+  mlc_decl_typedef(data_type);
+  mlc_decl_typedef(value_type);
+  mlc_decl_typedef(neighb_type);
+  mlc_decl_typedef(value_storage_type);
+  mlc_decl_typedef(storage_type);
+  mlc_decl_typedef(point_type);
+  mlc_decl_typedef(dpoint_type);
+  mlc_decl_typedef(image_type);
+  mlc_decl_typedef(concrete_type);
+
+  mlc_decl_typedef(piter_type);
+  mlc_decl_typedef(fwd_piter_type);
+  mlc_decl_typedef(bkd_piter_type);
+  mlc_decl_typedef(iter_type);
+
+  mlc_decl_typedef(delegated_type);
+  mlc_decl_typedef(size_type);
+  mlc_decl_typedef(se_type);
+  mlc_decl_typedef(window_type);
+
+  mlc_decl_typedef(image_neighbness_type);
+  mlc_decl_typedef(image_constness_type);
+  mlc_decl_typedef(image_dimension_type);
+  mlc_decl_typedef(image_typeness_type);
+  mlc_decl_typedef(image_valuedness_type);
+
+  // extension in image_operators
+  mlc_decl_typedef(output_type);
+  mlc_decl_typedef(input_type);
+  mlc_decl_typedef(input1_type);
+  mlc_decl_typedef(input2_type);
+
+  // category::window
+
+  mlc_decl_typedef(fwd_qiter_type);
+  mlc_decl_typedef(bkd_qiter_type);
+
+
+
+} // end of namespace oln
+
+
+
+// FIXME: memo...
+
+//   namespace category
+//   {
+//     struct data_storage;
+//     struct struct_elt;
+//     struct neighborhood;
+//     struct point;
+//     struct size;
+//     struct piter;
+//     struct niter;
+//     // FIXME: ...
+//   }
+
+
+#endif // ! OLENA_CORE_TYPEDEFS_HH
Index: oln/core/value_box.hh
===================================================================
--- oln/core/value_box.hh	(revision 130)
+++ oln/core/value_box.hh	(working copy)
@@ -29,7 +29,7 @@
 # define OLENA_CORE_VALUE_BOX_HH
 
 # include <iostream>
-# include <oln/core/properties.hh>
+# include <oln/core/abstract/image.hh>
 
 
 
Index: oln/core/apply.hh
===================================================================
--- oln/core/apply.hh	(revision 130)
+++ oln/core/apply.hh	(working copy)
@@ -31,7 +31,7 @@
 # include <mlc/fun.hh>
 
 # include <oln/basics.hh>
-# include <oln/core/abstract/op.hh>
+# include <oln/core/abstract/image_operator.hh>
 # include <oln/core/ch_value_type.hh>
 
 namespace oln {
@@ -46,27 +46,20 @@
     struct apply1_type;
   }
 
-  // Category.
-  template <typename F, typename I>
-  struct set_category< impl::apply1_type<F, I> >
-  {
-    typedef category::image ret;
-  };
-
   // Super type.
   template <typename F, typename I>
   struct set_super_type< impl::apply1_type<F, I> >
   {
     typedef typename ch_value_type<I,
 				   typename F::result_type>::ret output_type;
-    typedef typename abstract::op<output_type, impl::apply1_type<F, I> > ret;
+    typedef typename abstract::image_operator<output_type, impl::apply1_type<F, I> > ret;
   };
 
   namespace impl {
 
     template <typename F, typename I>
     struct apply1_type :
-      public abstract::op<
+      public abstract::image_operator<
         typename ch_value_type<I, typename F::result_type>::ret,
         apply1_type<F, I> >
     {
@@ -122,20 +115,13 @@
     struct apply2_type;
   }
 
-  // Category.
-  template <typename F, typename I1, typename I2>
-  struct set_category< impl::apply2_type<F, I1, I2> >
-  {
-    typedef category::image ret;
-  };
-
   // Super type.
   template <typename F, typename I1, typename I2>
   struct set_super_type< impl::apply2_type<F, I1, I2> >
   {
     typedef typename ch_value_type<I1,
 				   typename F::result_type>::ret output_type;
-    typedef typename abstract::op<output_type,
+    typedef typename abstract::image_operator<output_type,
 				  impl::apply2_type<F, I1, I2> > ret;
   };
 
@@ -143,7 +129,7 @@
 
     template <typename F, typename I1, typename I2>
     struct apply2_type :
-      public abstract::op<
+      public abstract::image_operator<
         typename ch_value_type<I1, typename F::result_type>::ret,
         apply2_type<F, I1, I2> >
     {
Index: oln/core/ch_value_type.hh
===================================================================
--- oln/core/ch_value_type.hh	(revision 130)
+++ oln/core/ch_value_type.hh	(working copy)
@@ -28,7 +28,7 @@
 #ifndef OLENA_CORE_CH_VALUE_TYPE_HH
 # define OLENA_CORE_CH_VALUE_TYPE_HH
 
-# include <oln/core/properties.hh>
+# include <oln/core/abstract/image.hh>
 
 namespace oln {
 
Index: oln/core/box.hh
===================================================================
--- oln/core/box.hh	(revision 130)
+++ oln/core/box.hh	(working copy)
@@ -28,8 +28,7 @@
 #ifndef OLENA_CORE_BOX_HH
 # define OLENA_CORE_BOX_HH
 
-# include <oln/core/properties.hh>
-# include <oln/core/abstract/entry.hh>
+# include <oln/core/abstract/image_entry.hh>
 
 namespace oln {
 
Index: oln/core/pw/times.hh
===================================================================
--- oln/core/pw/times.hh	(revision 130)
+++ oln/core/pw/times.hh	(working copy)
@@ -31,35 +31,40 @@
 # include <oln/core/pw/abstract/binary_function.hh>
 # include <oln/core/pw/literal.hh>
 # include <ntg/all.hh>
+# include <oln/core/pw/macros.hh>
 
 
 namespace oln {
 
+  // fwd decl
+  namespace pw {
+    template <typename L, typename R> struct times;
+  }
 
-  namespace pw { // means "point-wise"
+  // super type
+  template <typename L, typename R>
+  struct set_super_type < pw::times<L, R> > { typedef pw::abstract::binary_function<L, R, pw::times<L, R> > ret; };
 
-    // fwd decl
-    template <typename L, typename R> struct times;
+  // props
+  template <typename L, typename R>
+  struct set_props < category::pw, pw::times<L, R> >
+  {
+    typedef ntg_return_type(times,
+			    oln_pw_type_of(L, value),
+			    oln_pw_type_of(R, value)) value_type;
+  };
 
-    template <typename L, typename R>
-    struct traits < times<L, R> >
-    {
-      typedef abstract::binary_function<L, R, times<L, R> > super_type;
-      typedef typename traits<super_type>::point_type point_type;
-      typedef typename traits<super_type>::size_type  size_type;
-      typedef ntg_return_type(times,
-			      oln_pw_value_type(L),
-			      oln_pw_value_type(R)) value_type;
-    };
 
+  namespace pw {
+
     template <typename L, typename R>
     struct times : public abstract::binary_function < L, R, times<L, R> >
     {
       typedef times<L, R> self_type;
 
-      typedef oln_pw_point_type(self_type) point_type;
-      typedef oln_pw_value_type(self_type) value_type;
-      typedef oln_pw_size_type(self_type)  size_type;
+      typedef oln_pw_type_of(self_type, point) point_type;
+      typedef oln_pw_type_of(self_type, value) value_type;
+      typedef oln_pw_type_of(self_type, size)  size_type;
 
       typedef abstract::binary_function<L, R, self_type> super_type;
 
Index: oln/core/pw/image.hh
===================================================================
--- oln/core/pw/image.hh	(revision 130)
+++ oln/core/pw/image.hh	(working copy)
@@ -32,7 +32,7 @@
 # include <mlc/cmp.hh>
 # include <oln/core/box.hh>
 # include <oln/core/abstract/image_typeness.hh>
-# include <oln/core/abstract/entry.hh>
+# include <oln/core/abstract/image_entry.hh>
 # include <oln/core/pw/abstract/function.hh>
 
 // FIXME: remove
@@ -43,20 +43,28 @@
 namespace oln {
 
 
+  // fwd decl
+  namespace pw {
+    template <typename I> struct image;
+  }    
+
+  // super type
+  template <typename I>
+  struct set_super_type < pw::image<I> > { typedef pw::abstract::function< pw::image<I> > ret; };
+
+  // props
+  template <typename I>
+  struct set_props < category::pw, pw::image<I> >
+  {
+    typedef oln_type_of(I, point) point_type;
+    typedef oln_type_of(I, value) value_type;
+    typedef oln_type_of(I, size)  size_type;
+  };
+
+
   namespace pw { // means "point-wise"
 
-    // fwd decl
-    template <typename I> struct image;
-    
     template <typename I>
-    struct traits < image<I> >
-    {
-      typedef oln_type_of(I, point) point_type;
-      typedef oln_type_of(I, value) value_type;
-      typedef oln_type_of(I, size)  size_type;
-    };
-
-    template <typename I>
     struct image : public abstract::function < image<I> >
     {
       oln::box<const I> ima;
@@ -107,25 +115,18 @@
 
   // fwd decl
   template <typename F> class image_from_pw;
-  
-  // category
-  template <typename F>
-  struct set_category< image_from_pw<F> > { typedef category::image ret; };
 
   // super
   template <typename F>
-  struct set_super_type < image_from_pw<F> >
-  {
-    typedef abstract::image_entry< image_from_pw<F> > ret;
-  };
+  struct set_super_type < image_from_pw<F> > { typedef abstract::image_entry< image_from_pw<F> > ret; };
 
   // props
   template <typename F>
-  struct set_props < category::image, image_from_pw<F> > : public props_of <category::image>
+  struct set_props < category::image, image_from_pw<F> >
   {
-    typedef oln_pw_point_type(F) point_type;
-    typedef oln_pw_value_type(F) value_type;
-    typedef oln_pw_size_type(F)  size_type;
+    typedef oln_pw_type_of(F, point) point_type;
+    typedef oln_pw_type_of(F, value) value_type;
+    typedef oln_pw_type_of(F, size)  size_type;
 
     typedef mlc::no_type delegated_type;
 
@@ -159,14 +160,10 @@
       this->exact_ptr = this;
     }
 
-    /// typedefs
+    typedef oln_pw_type_of(F, point) point_type;
+    typedef oln_pw_type_of(F, value) value_type;
+    typedef oln_pw_type_of(F, size)  size_type;
 
-    typedef image_from_pw<F> self_type;
-
-    typedef oln_type_of(self_type, size)  size_type;
-    typedef oln_type_of(self_type, value) value_type;
-    typedef oln_type_of(self_type, point) point_type;
-
     const size_type& impl_size() const
     {
       return this->fun.size();
@@ -251,7 +248,7 @@
     template <typename F>
     bool check(const pw::abstract::function<F>& pred)
     {
-      mlc::eq< oln_typeness_of(oln_pw_value_type(F)), typeness::binary_tag >::ensure();
+      mlc::eq< oln_typeness_of(oln_pw_type_of(F, value)), typeness::binary_tag >::ensure();
       return oln::check(for_all_p(pred));
     }
 
Index: oln/core/pw/div.hh
===================================================================
--- oln/core/pw/div.hh	(revision 130)
+++ oln/core/pw/div.hh	(working copy)
@@ -31,35 +31,40 @@
 # include <oln/core/pw/abstract/binary_function.hh>
 # include <oln/core/pw/literal.hh>
 # include <ntg/all.hh>
+# include <oln/core/pw/macros.hh>
 
 
 namespace oln {
 
+  // fwd decl
+  namespace pw {
+    template <typename L, typename R> struct div;
+  }
 
-  namespace pw { // means "point-wise"
+  // super type
+  template <typename L, typename R>
+  struct set_super_type < pw::div<L, R> > { typedef pw::abstract::binary_function<L, R, pw::div<L, R> > ret; };
 
-    // fwd decl
-    template <typename L, typename R> struct div;
+  // props
+  template <typename L, typename R>
+  struct set_props < category::pw, pw::div<L, R> >
+  {
+    typedef ntg_return_type(div,
+			    oln_pw_type_of(L, value),
+			    oln_pw_type_of(R, value)) value_type;
+  };
 
-    template <typename L, typename R>
-    struct traits < div<L, R> >
-    {
-      typedef abstract::binary_function<L, R, div<L, R> > super_type;
-      typedef typename traits<super_type>::point_type point_type;
-      typedef typename traits<super_type>::size_type  size_type;
-      typedef ntg_return_type(div,
-			      oln_pw_value_type(L),
-			      oln_pw_value_type(R)) value_type;
-    };
 
+  namespace pw {
+
     template <typename L, typename R>
     struct div : public abstract::binary_function < L, R, div<L, R> >
     {
       typedef div<L, R> self_type;
 
-      typedef oln_pw_point_type(self_type) point_type;
-      typedef oln_pw_value_type(self_type) value_type;
-      typedef oln_pw_size_type(self_type)  size_type;
+      typedef oln_pw_type_of(self_type, point) point_type;
+      typedef oln_pw_type_of(self_type, value) value_type;
+      typedef oln_pw_type_of(self_type, size)  size_type;
 
       typedef abstract::binary_function<L, R, self_type> super_type;
 
Index: oln/core/pw/plus.hh
===================================================================
--- oln/core/pw/plus.hh	(revision 130)
+++ oln/core/pw/plus.hh	(working copy)
@@ -30,36 +30,41 @@
 
 # include <oln/core/pw/abstract/binary_function.hh>
 # include <oln/core/pw/literal.hh>
+# include <oln/core/pw/macros.hh>
 # include <ntg/all.hh>
 
 
 namespace oln {
 
+  // fwd decl
+  namespace pw {
+    template <typename L, typename R> struct plus;
+  }
 
-  namespace pw { // means "point-wise"
+  // super type
+  template <typename L, typename R>
+  struct set_super_type < pw::plus<L, R> > { typedef pw::abstract::binary_function<L, R, pw::plus<L, R> > ret; };
 
-    // fwd decl
-    template <typename L, typename R> struct plus;
+  // props
+  template <typename L, typename R>
+  struct set_props < category::pw, pw::plus<L, R> >
+  {
+    typedef ntg_return_type(plus,
+			    oln_pw_type_of(L, value),
+			    oln_pw_type_of(R, value)) value_type;
+  };
 
-    template <typename L, typename R>
-    struct traits < plus<L, R> >
-    {
-      typedef abstract::binary_function<L, R, plus<L, R> > super_type;
-      typedef typename traits<super_type>::point_type point_type;
-      typedef typename traits<super_type>::size_type  size_type;
-      typedef ntg_return_type(plus,
-			      oln_pw_value_type(L),
-			      oln_pw_value_type(R)) value_type;
-    };
 
+  namespace pw {
+
     template <typename L, typename R>
     struct plus : public abstract::binary_function < L, R, plus<L, R> >
     {
       typedef plus<L, R> self_type;
 
-      typedef oln_pw_point_type(self_type) point_type;
-      typedef oln_pw_value_type(self_type) value_type;
-      typedef oln_pw_size_type(self_type)  size_type;
+      typedef oln_pw_type_of(self_type, point) point_type;
+      typedef oln_pw_type_of(self_type, value) value_type;
+      typedef oln_pw_type_of(self_type, size)  size_type;
 
       typedef abstract::binary_function<L, R, self_type> super_type;
 
Index: oln/core/pw/macros.hh
===================================================================
--- oln/core/pw/macros.hh	(revision 130)
+++ oln/core/pw/macros.hh	(working copy)
@@ -30,11 +30,6 @@
 
 
 
-# define oln_pw_point_type(F) typename oln::pw::traits<F>::point_type
-# define oln_pw_value_type(F) typename oln::pw::traits<F>::value_type
-# define oln_pw_size_type(F)  typename oln::pw::traits<F>::size_type
-
-
 // FIXME: rename?
 # define oln_pw_operator(NAME, SYMBOL, TYPE)			\
 template <typename L>						\
Index: oln/core/pw/abstract/function.hh
===================================================================
--- oln/core/pw/abstract/function.hh	(revision 130)
+++ oln/core/pw/abstract/function.hh	(working copy)
@@ -29,18 +29,53 @@
 # define OLENA_CORE_PW_ABSTRACT_FUNCTION_HH
 
 # include <mlc/any.hh>
-# include <oln/core/properties.hh>
-# include <oln/core/pw/macros.hh>
+# include <oln/core/abstract/image.hh>
+# include <oln/core/typedefs.hh>
 
 
+# define oln_pw_type_of(PointWiseType, Alias) \
+mlc_type_of(oln, oln::category::pw, PointWiseType, Alias)
+
+
 namespace oln {
 
 
-  namespace pw { // means "point-wise"
+  namespace category
+  {
+    struct pw; // means "point-wise"
+  }
 
-    template <typename T> struct traits;
 
+  template <>
+  struct set_default_props < category::pw >
+  {
+    typedef mlc::undefined_type point_type;
+    typedef mlc::undefined_type value_type;
+    typedef mlc::undefined_type size_type;
+  };
 
+
+  template <typename PWF>
+  struct get_props < category::pw, PWF >
+  {
+    typedef oln_pw_type_of(PWF, point) point_type;
+    typedef oln_pw_type_of(PWF, value) value_type;
+    typedef oln_pw_type_of(PWF, size)  size_type;
+
+    static void echo(std::ostream& ostr)
+    {
+      ostr << "props_of( oln::category::pw, " << mlc_to_string(PWF) << " ) =" << std::endl
+	   << "{" << std::endl
+	   << "\t point_type = " << mlc_to_string(point_type) << std::endl
+	   << "\t value_type = " << mlc_to_string(value_type) << std::endl
+	   << "\t size_type  = " << mlc_to_string(size_type)  << std::endl
+	   << "}" << std::endl;
+    }
+  };
+
+
+  namespace pw {
+
     // fwd decls
     namespace abstract {
       template <typename E> struct function;
@@ -50,22 +85,14 @@
     template <typename F> struct not_;
 
 
-    template <typename E>
-    struct traits < abstract::function<E> >
-    {
-      typedef oln_pw_point_type(E) point_type;
-      typedef oln_pw_value_type(E) value_type;
-      typedef oln_pw_size_type(E)  size_type;
-    };
-
     namespace abstract {
 
       template <typename E>
       struct function : public mlc::any<E>
       {
-	typedef oln_pw_point_type(E) point_type;
-	typedef oln_pw_value_type(E) value_type;
-	typedef oln_pw_size_type(E)  size_type;
+	typedef oln_pw_type_of(E, point) point_type;
+	typedef oln_pw_type_of(E, value) value_type;
+	typedef oln_pw_type_of(E, size)  size_type;
 
 	const size_type& size() const
 	{
Index: oln/core/pw/abstract/binary_function.hh
===================================================================
--- oln/core/pw/abstract/binary_function.hh	(revision 130)
+++ oln/core/pw/abstract/binary_function.hh	(working copy)
@@ -37,32 +37,40 @@
 namespace oln {
 
 
-  namespace pw { // means "point-wise"
-
-
-    // fwd decls
+  // fwd decl
+  namespace pw {
     namespace abstract {
       template <typename L, typename R, typename E> struct binary_function;
     }
+  }
 
+  // super type
+  template <typename L, typename R, typename E>
+  struct set_super_type < pw::abstract::binary_function<L, R, E> > { typedef pw::abstract::function<E> ret; };
 
-    template <typename L, typename R, typename E>
-    struct traits < abstract::binary_function<L, R, E> >
-    {
-      typedef oln_pw_point_type(L) left_point_type;
-      typedef oln_pw_point_type(R) right_point_type;
+  // props
+  template <typename L, typename R, typename E>
+  struct set_props < category::pw, pw::abstract::binary_function<L, R, E> >
+  {
+    typedef oln_pw_type_of(L, point) left_point_type;
+    typedef oln_pw_type_of(R, point) right_point_type;
+    
+    typedef oln_point_type_from_2(left_point_type, right_point_type) point_type;
+    
+    typedef oln_pw_type_of(L, size) left_size_type;
+    typedef oln_pw_type_of(R, size) right_size_type;
+    
+    typedef oln_size_type_from_2(left_size_type, right_size_type) size_type;
+  };
 
-      typedef oln_point_type_from_2(left_point_type, right_point_type) point_type;
 
-      typedef oln_pw_size_type(L) left_size_type;
-      typedef oln_pw_size_type(R) right_size_type;
 
-      typedef oln_size_type_from_2(left_size_type, right_size_type) size_type;
-    };
+  namespace pw {
 
-
     namespace abstract {
 
+
+      // internals
       namespace internal {
 
 	template <typename T1, typename T2>
@@ -95,6 +103,8 @@
       } // end of namespace oln::pw::abstract::internal
 
 
+
+
       template <typename L, typename R, typename E>
       struct binary_function : public function<E>
       {
@@ -112,11 +122,11 @@
 	}
 
 	typedef abstract::binary_function<L, R, E> self_type;
-	typedef oln_pw_point_type(self_type) point_type;
-	typedef oln_pw_size_type(self_type)  size_type;
+	typedef oln_pw_type_of(self_type, point) point_type;
+	typedef oln_pw_type_of(self_type, size)  size_type;
 
-	typedef internal::binary_function_helper<oln_pw_size_type(L),
-						 oln_pw_size_type(R) > _helper_type;
+	typedef internal::binary_function_helper<oln_pw_type_of(L, size),
+						 oln_pw_type_of(R, size) > _helper_type;
 
 	const size_type& impl_size() const
 	{
Index: oln/core/pw/minus.hh
===================================================================
--- oln/core/pw/minus.hh	(revision 130)
+++ oln/core/pw/minus.hh	(working copy)
@@ -31,35 +31,40 @@
 # include <oln/core/pw/abstract/binary_function.hh>
 # include <oln/core/pw/literal.hh>
 # include <ntg/all.hh>
+# include <oln/core/pw/macros.hh>
 
 
 namespace oln {
 
+  // fwd decl
+  namespace pw {
+    template <typename L, typename R> struct minus;
+  }
 
-  namespace pw { // means "point-wise"
+  // super type
+  template <typename L, typename R>
+  struct set_super_type < pw::minus<L, R> > { typedef pw::abstract::binary_function<L, R, pw::minus<L, R> > ret; };
 
-    // fwd decl
-    template <typename L, typename R> struct minus;
+  // props
+  template <typename L, typename R>
+  struct set_props < category::pw, pw::minus<L, R> >
+  {
+    typedef ntg_return_type(minus,
+			    oln_pw_type_of(L, value),
+			    oln_pw_type_of(R, value)) value_type;
+  };
 
-    template <typename L, typename R>
-    struct traits < minus<L, R> >
-    {
-      typedef abstract::binary_function<L, R, minus<L, R> > super_type;
-      typedef typename traits<super_type>::point_type point_type;
-      typedef typename traits<super_type>::size_type  size_type;
-      typedef ntg_return_type(minus,
-			      oln_pw_value_type(L),
-			      oln_pw_value_type(R)) value_type;
-    };
 
+  namespace pw {
+
     template <typename L, typename R>
     struct minus : public abstract::binary_function < L, R, minus<L, R> >
     {
       typedef minus<L, R> self_type;
 
-      typedef oln_pw_point_type(self_type) point_type;
-      typedef oln_pw_value_type(self_type) value_type;
-      typedef oln_pw_size_type(self_type)  size_type;
+      typedef oln_pw_type_of(self_type, point) point_type;
+      typedef oln_pw_type_of(self_type, value) value_type;
+      typedef oln_pw_type_of(self_type, size)  size_type;
 
       typedef abstract::binary_function<L, R, self_type > super_type;
 
@@ -82,10 +87,10 @@
     namespace abstract {
 
       template <typename E>
-      minus<literal<oln_pw_value_type(E)>, E>
+      minus<literal<oln_pw_type_of(E, value)>, E>
       function<E>::operator-() const
       {
-	typedef literal<oln_pw_value_type(E)> lit_type;
+	typedef literal<oln_pw_type_of(E, value)> lit_type;
 	static const lit_type lhs = 0;
 	minus< lit_type, E> tmp(lhs, this->exact());
 	return tmp;
Index: oln/core/pw/literal.hh
===================================================================
--- oln/core/pw/literal.hh	(revision 130)
+++ oln/core/pw/literal.hh	(working copy)
@@ -35,20 +35,27 @@
 
 namespace oln {
 
+  // fwd decl
+  namespace pw {
+    template <typename T> struct literal;
+  }
 
-  namespace pw { // means "point-wise"
+  // super type
+  template <typename T>
+  struct set_super_type < pw::literal<T> > { typedef pw::abstract::function< pw::literal<T> > ret; };
 
-    // fwd decl
-    template <typename T> struct literal;
+  // props
+  template <typename T>
+  struct set_props < category::pw, pw::literal<T> >
+  {
+    typedef any_point point_type;
+    typedef T         value_type;
+    typedef any_size  size_type;
+  };
 
-    template <typename T>
-    struct traits < literal<T> >
-    {
-      typedef any_point point_type;
-      typedef T         value_type;
-      typedef any_size  size_type;
-    };
 
+  namespace pw {
+
     template <typename T>
     struct literal : public abstract::function < literal<T> >
     {
Index: oln/core/pw/logic.hh
===================================================================
--- oln/core/pw/logic.hh	(revision 130)
+++ oln/core/pw/logic.hh	(working copy)
@@ -36,9 +36,8 @@
 namespace oln {
 
 
-  namespace pw { // means "point-wise"
+  namespace pw {
 
-
     // FIXME: move somewhere else
     namespace internal
     {
@@ -86,27 +85,39 @@
       };
     } // end of oln::pw::internal
 
+  } // end of namespace oln::pw
 
 
-    // fwd decl
+  // fwd decl
+  namespace pw {
     template <typename R> struct not_;
+  }
 
-    template <typename R>
-    struct traits < not_<R> >
-    {
-      typedef oln_pw_point_type(R) point_type;
-      typedef oln_pw_size_type(R) size_type;
-      typedef bool value_type;
-    };
+  // super type
+  template <typename R>
+  struct set_super_type < pw::not_<R> > { typedef pw::abstract::function < pw::not_<R> > ret; };
 
+  // props
+  template <typename R>
+  struct set_props < category::pw, pw::not_<R> >
+  {
+    typedef oln_pw_type_of(R, point) point_type;
+    typedef oln_pw_type_of(R, size)  size_type;
+    typedef bool value_type;
+  };
+
+
+  namespace pw
+  {
+
     template <typename R>
     struct not_ : public abstract::function < not_<R> >
     {
       typedef not_<R> self_type;
 
-      typedef oln_pw_point_type(self_type) point_type;
-      typedef oln_pw_value_type(self_type) value_type;
-      typedef oln_pw_size_type(self_type)  size_type;
+      typedef oln_pw_type_of(R, point) point_type;
+      typedef oln_pw_type_of(R, size)  size_type;
+      typedef oln_pw_type_of(R, value) value_type;
 
       R right;
 
@@ -146,7 +157,7 @@
       not_<E>
       function<E>::operator!() const
       {
-	mlc::eq< oln_typeness_of(oln_pw_value_type(E)), typeness::binary_tag >::ensure();
+	mlc::eq< oln_typeness_of(oln_pw_type_of(E, value)), typeness::binary_tag >::ensure();
 	not_<E> tmp(this->exact());
 	return tmp;
       }
Index: oln/core/pw/cmp.hh
===================================================================
--- oln/core/pw/cmp.hh	(revision 130)
+++ oln/core/pw/cmp.hh	(working copy)
@@ -29,12 +29,13 @@
 # define OLENA_CORE_PW_CMP_HH
 
 # include <oln/core/pw/abstract/binary_function.hh>
+# include <oln/core/pw/macros.hh>
 
 
 namespace oln {
 
 
-  namespace pw { // means "point-wise"
+  namespace pw {
 
 
     // FIXME: move somewhere else
@@ -80,29 +81,41 @@
 
 
 
-    // fwd decl
+  } // end of namespace pw
+
+
+  // fwd decl
+  namespace pw {
     template <typename L, typename R, typename C> struct cmp;
+  }
 
-    template <typename L, typename R, typename C>
-    struct traits < cmp<L, R, C> >
-    {
-      typedef abstract::binary_function<L, R, cmp<L, R, C> > super_type;
-      typedef typename traits<super_type>::point_type point_type;
-      typedef typename traits<super_type>::size_type  size_type;
-      typedef bool value_type;
-    };
+  // super type
+  template <typename L, typename R, typename C>
+  struct set_super_type < pw::cmp<L, R, C> > { typedef pw::abstract::binary_function<L, R, pw::cmp<L, R, C> > ret; };
 
+  // props
+  template <typename L, typename R, typename C>
+  struct set_props < category::pw, pw::cmp<L, R, C> >
+  {
+    typedef bool value_type;
+  };
 
+
+
+  
+  namespace pw
+  {
+
     template <typename L, typename R, typename C>
     struct cmp : public abstract::binary_function < L, R, cmp<L, R, C> >
     {
       typedef cmp<L, R, C> self_type;
 
-      typedef oln_pw_point_type(self_type) point_type;
-      typedef oln_pw_size_type(self_type)  size_type;
-      typedef oln_pw_value_type(self_type) value_type;
+      typedef oln_pw_type_of(self_type, point) point_type;
+      typedef oln_pw_type_of(self_type, value) value_type;
+      typedef oln_pw_type_of(self_type, size)  size_type;
 
-      typedef abstract::binary_function < L, R, self_type > super_type;
+      typedef abstract::binary_function<L, R, self_type> super_type;
 
       cmp(const abstract::function<L>& left,
 	  const abstract::function<R>& right) :
Index: oln/core/any/point.hh
===================================================================
--- oln/core/any/point.hh	(revision 130)
+++ oln/core/any/point.hh	(working copy)
@@ -28,6 +28,7 @@
 #ifndef OLENA_CORE_ANY_POINT_HH
 # define OLENA_CORE_ANY_POINT_HH
 
+# include <iostream> 
 # include <oln/core/abstract/point.hh>
 # include <oln/core/abstract/dpoint.hh>
 
@@ -38,13 +39,9 @@
   struct any_point;
   struct any_dpoint;
 
-  // category
-  template <>
-  struct set_category< any_point > { typedef category::point ret; };
-
   // props
   template <>
-  struct set_props < category::point, any_point > : public props_of<category::point>
+  struct set_props < category::point, any_point >
   {
     typedef any_dpoint dpoint_type;
   };
Index: oln/core/properties.hh
===================================================================
--- oln/core/properties.hh	(revision 130)
+++ oln/core/properties.hh	(working copy)
@@ -1,111 +0,0 @@
-// Copyright (C) 2005 EPITA Research and Development Laboratory
-//
-// This file is part of the Olena Library.  This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License version 2 as published by the
-// Free Software Foundation.
-//
-// This library 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 this library; see the file COPYING.  If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-//
-// As a special exception, you may use this file as part of a free
-// software library 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 OLENA_CORE_PROPERTIES_HH
-# define OLENA_CORE_PROPERTIES_HH
-
-# include <mlc/properties.hh>
-
-
-/*! \namespace oln
-** \brief oln namespace.
-*/
-namespace oln
-{
-
-  namespace category
-  {
-    struct data_storage;
-    struct image;
-    struct struct_elt;
-    struct neighborhood;
-    struct point;
-    struct size;
-    struct piter;
-    struct witer;
-    struct niter;
-    // FIXME: ...
-  }
-
-  namespace target
-  {
-    struct data_type;
-    struct value_type;
-    struct neighb_type;
-    struct value_storage_type;
-    struct storage_type;
-    struct point_type;
-    struct image_type;
-    struct concrete_type;
-    struct dpoint_type;
-    struct piter_type;
-    struct fwd_piter_type;
-    struct bkd_piter_type;
-    struct fwd_witer_type;
-    struct iter_type;
-    struct delegated_type;
-    struct size_type;
-    struct se_type;
-    struct window_type;
-
-    struct image_neighbness_type;
-    struct image_constness_type;
-    struct image_dimension_type;
-    struct image_typeness_type;
-    struct image_valuedness_type;
-    // FIXME: ...
-
-    struct dummy_type; // FIXME: remove (test purpose!)
-  }
-
-  mlc_equip_namespace_for_properties();
-
-
-  // FIXME: change name?
-  template <template <typename> class abstraction>
-  struct is_a // abstraction
-  {
-    template <typename E>
-    struct instantiated_with // E
-    {
-      typedef abstraction<E> ret;
-    };
-  };
-
-
-} // end of namespace oln
-
-
-
-/// macro to retrieve a type (TARGET) from a class (oln::TYPE)
-
-# define oln_type_of(TYPE, TARGET) mlc_type_of(oln, TYPE, TARGET)
-# define oln_type_of_(TYPE, TARGET) mlc_type_of_(oln, TYPE, TARGET)
-
-
-
-#endif // ! OLENA_CORE_PROPERTIES_HH
Index: oln/core/abstract/niter.hh
===================================================================
--- oln/core/abstract/niter.hh	(revision 130)
+++ oln/core/abstract/niter.hh	(working copy)
@@ -34,9 +34,10 @@
 # include <mlc/types.hh>
 # include <mlc/contract.hh>
 
+# include <oln/core/typedefs.hh>
+
 # include <oln/core/gen/image_with_nbh.hh>
 # include <oln/core/abstract/point.hh>
-# include <oln/core/properties.hh>
 # include <oln/core/abstract/image.hh>
 # include <oln/core/abstract/neighborhood.hh>
 # include <oln/core/abstract/image_neighbness.hh>
@@ -56,60 +57,60 @@
   for(p.start(); p.is_valid(); p.next()) \
   for(n.center_at(p), n.start(); n.is_valid(); n.next())
 
+
+
+# define oln_nit_type_of(NiterType, Alias) \
+mlc_type_of(oln, oln::category::niter, NiterType, Alias)
+
+
+
 namespace oln {
 
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct niter;
+
+  namespace category
+  {
+    struct niter;
   }
 
-  // category
-  template <typename E>
-  struct set_category< abstract::niter<E> > { typedef category::niter ret; };
 
+  template <>
+  struct set_default_props < category::niter >
+  {
+    typedef mlc::undefined_type point_type;
+    typedef mlc::undefined_type neighb_type;
+  };
 
-  /// properties of any type in category::niter
 
-  template <typename type>
-  struct props_of < category::niter, type >
+  template <typename N>
+  struct get_props < category::niter, N >
   {
-    typedef mlc::true_type user_defined_;
+    typedef oln_nit_type_of(N, point) point_type;
+    typedef oln_nit_type_of(N, neighb) neighb_type;
 
-    mlc_decl_prop(category::niter, point_type);
-    mlc_decl_prop(category::niter, dpoint_type);
-    mlc_decl_prop(category::niter, neighb_type);
-    mlc_decl_prop(category::niter, image_type);
-
     static void echo(std::ostream& ostr)
     {
-      ostr << "props_of( category::niter, "
-	   << typeid(type).name() << ") = {"
-	   << "  neighb_type = " << typeid(neighb_type).name()
-	   << "  image_type = " << typeid(image_type).name()
-	   << "  point_type = " << typeid(point_type).name() << "  }" << std::endl;
+      ostr << "props_of( oln::category::niter, " << mlc_to_string(N) << " ) =" << std::endl
+	   << "\t point_type  = " << mlc_to_string(point_type) << std::endl
+	   << "\t neighb_type = " << mlc_to_string(neighb_type) << std::endl
+	   << std::endl;
     }
-
   };
 
-  mlc_register_prop(category::niter, neighb_type);
-  mlc_register_prop(category::niter, point_type);
-  mlc_register_prop(category::niter, dpoint_type);
-  mlc_register_prop(category::niter, image_type);
 
 
   namespace abstract {
 
     template <typename E>
-    struct niter : public mlc::any__best_speed<E>
+    struct niter : public mlc::any<E>
     {
 
       /// typedefs
 
       typedef niter<E> self_type;
 
-      typedef oln_type_of(E, point) point_type;
-      typedef oln_type_of(E, neighb) neighb_type;
-      typedef oln_type_of(E, image) image_type;
+      typedef oln_nit_type_of(E, point) point_type;
+      typedef oln_nit_type_of(E, neighb) neighb_type;
+      typedef oln_nit_type_of(E, image) image_type;
 
       void start()
       {
@@ -118,17 +119,19 @@
 
       void next()
       {
+	precondition(this->is_valid());
 	this->exact().impl_next();
       }
 
       operator point_type() const
       {
+	precondition(this->is_valid());
 	return this->exact().impl_cast_point();
       }
 
-      void center_at(const point_type& pt)
+      void center_at(const point_type& p)
       {
-	this->exact().impl_center_at(pt);
+	this->exact().impl_center_at(p);
       }
 
       bool is_valid() const
@@ -138,22 +141,24 @@
 
       void invalidate()
       {
-	return this->exact().impl_invalidate();
+	this->exact().impl_invalidate();
       }
 
     protected:
 
-      template <typename T>
-      niter(const abstract::image_with_nbh<T>& ima) :
-	p_(), nbh_(ima.nbh_get())
+      template <typename I>
+      niter(const abstract::image_with_nbh<I>& ima) :
+	nbh_(ima.nbh_get())
       {
       }
 
+      const neighb_type& nbh_;
       point_type p_;
-      const neighb_type& nbh_;
     };
-  }
-}
 
+  } // end of namespace oln::abstract
 
+} // end of namespace oln
+
+
 #endif // ! OLENA_CORE_ABSTRACT_NITER_HH
Index: oln/core/abstract/image.hh
===================================================================
--- oln/core/abstract/image.hh	(revision 130)
+++ oln/core/abstract/image.hh	(working copy)
@@ -28,99 +28,123 @@
 #ifndef OLENA_CORE_ABSTRACT_IMAGE_HH
 # define OLENA_CORE_ABSTRACT_IMAGE_HH
 
-# include <mlc/types.hh>
+# include <oln/core/typedefs.hh>
 
-# include <oln/core/abstract/internal/image_impl.hh>
-# include <oln/core/properties.hh>
-# include <oln/core/value_box.hh>
 
+# define oln_type_of_(ImageType, Alias) \
+mlc_type_of_(oln, oln::category::image, ImageType, Alias)
 
-/*! \namespace oln
-** \brief oln namespace.
-*/
+# define oln_type_of(ImageType, Alias) \
+mlc_type_of(oln, oln::category::image, ImageType, Alias)
+
+
+
 namespace oln {
 
 
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct image;
-    template <typename E> struct readonly_image;
-    template <typename E> struct image_without_nbh;
+  // fwd decls
+  namespace abstract
+  {
+    template <typename I> class image_without_nbh;
+    template <typename I> class readonly_image;
   }
 
-  // category
-  template <typename E>
-  struct set_category< abstract::image<E> > { typedef category::image ret; };
 
+  namespace category
+  {
+    struct image;
+  }
 
 
-  /// properties of any type in category::image
+  /// Default properties of any image type.
 
-  template <typename type>
-  struct props_of <category::image, type>
+  template <>
+  struct set_default_props < category::image >
   {
-    typedef mlc::true_type user_defined_;
-    
-    mlc_decl_prop(category::image, concrete_type);
-    mlc_decl_prop(category::image, value_type);
-    mlc_decl_prop(category::image, point_type);
-    mlc_decl_prop(category::image, size_type);
-    mlc_decl_prop(category::image, piter_type);
-    mlc_decl_prop(category::image, fwd_piter_type);
-    mlc_decl_prop(category::image, bkd_piter_type);
-    mlc_decl_prop_with_default(category::image, value_storage_type, mlc::no_type);
-    mlc_decl_prop_with_default(category::image, storage_type, mlc::no_type);
-    mlc_decl_prop_with_default(category::image, delegated_type, mlc::no_type);
-    mlc_decl_prop_with_default(category::image, neighb_type, mlc::no_type);
+    typedef mlc::undefined_type concrete_type;
+    typedef mlc::undefined_type value_type;
+    typedef mlc::undefined_type point_type;
+    typedef mlc::undefined_type size_type;
+    typedef mlc::undefined_type piter_type;
+    typedef mlc::undefined_type fwd_piter_type;
+    typedef mlc::undefined_type bkd_piter_type;
 
+    typedef mlc::no_type value_storage_type;
+    typedef mlc::no_type storage_type;
+    typedef mlc::no_type delegated_type;
+    typedef mlc::no_type neighb_type;
 
-    mlc_decl_prop_with_default(category::image, image_neighbness_type, is_a<abstract::image_without_nbh>);
-    mlc_decl_prop_with_default(category::image, image_constness_type, is_a<abstract::readonly_image>);
-    mlc_decl_prop(category::image, image_dimension_type);
 
+    typedef is_a<abstract::image_without_nbh> image_neighbness_type;
+    typedef is_a<abstract::readonly_image> image_constness_type;
+    typedef mlc::undefined_type image_dimension_type;
+
     //...
 
+  };
+
+
+  /// Retrieval of any image type properties (FIXME: say 'packing').
+
+  template <typename I>
+  struct get_props < category::image, I >
+  {
+    typedef oln_type_of(I, concrete) concrete_type;
+    typedef oln_type_of(I, value) value_type;
+    typedef oln_type_of(I, point) point_type;
+    typedef oln_type_of(I, size) size_type;
+
+    typedef oln_type_of(I, piter) piter_type;
+    typedef oln_type_of(I, fwd_piter) fwd_piter_type;
+    typedef oln_type_of(I, bkd_piter) bkd_piter_type;
+
+    typedef oln_type_of(I, value_storage) value_storage_type;
+    typedef oln_type_of(I, storage) storage_type;
+    typedef oln_type_of(I, delegated) delegated_type;
+    typedef oln_type_of(I, neighb) neighb_type;
+
+
+    typedef oln_type_of(I, image_neighbness) image_neighbness_type;
+    typedef oln_type_of(I, image_constness) image_constness_type;
+    typedef oln_type_of(I, image_dimension) image_dimension_type;
+
+    //...
+
     static void echo(std::ostream& ostr)
     {
-      ostr << "props_of(" // FIXME: << typeid(oln::category::image).name()
-	   << ", " << typeid(type).name() << ") = {"
-	   << "  concrete_type = " << typeid(concrete_type).name()
-	   << "  value_type = " << typeid(value_type).name()
-	   << "  neighb_type = " << typeid(neighb_type).name()
-	   << "  point_type = " << typeid(point_type).name()
-	   << "  size_type = " << typeid(size_type).name()
-	   << "  fwd_piter_type = " << typeid(fwd_piter_type).name()
-	   << "  value_storage_type = " << typeid(value_storage_type).name()
-	   << "  storage_type = " << typeid(storage_type).name()
-	   << "  delegated_type = " << typeid(delegated_type).name()
+      ostr << "props_of( oln::category::image, " << mlc_to_string(I) << " ) =" << std::endl
+	   << "\t concrete_type = " << mlc_to_string(concrete_type) << std::endl
+	   << "\t value_type = " << mlc_to_string(value_type) << std::endl
+	   << "\t point_type = " << mlc_to_string(point_type) << std::endl
+	   << "\t size_type = " << mlc_to_string(size_type) << std::endl
 
-	   << "  image_constness_type = " << typeid(image_constness_type).name()
-	   << "  image_dimension_type = " << typeid(image_dimension_type).name()
-	   << "  image_neighbness_type = " << typeid(image_neighbness_type).name()
+	   << "\t piter_type = " << mlc_to_string(piter_type) << std::endl
+	   << "\t fwd_piter_type = " << mlc_to_string(fwd_piter_type) << std::endl
+	   << "\t bkd_piter_type = " << mlc_to_string(bkd_piter_type) << std::endl
 
-	   << "  }" << std::endl;
+	   << "\t value_storage_type = " << mlc_to_string(value_storage_type) << std::endl
+	   << "\t storage_type = " << mlc_to_string(storage_type) << std::endl
+	   << "\t delegated_type = " << mlc_to_string(delegated_type) << std::endl
+	   << "\t neighb_type = " << mlc_to_string(neighb_type) << std::endl
+
+	   << "\t image_neighbness_type = " << mlc_to_string(image_neighbness_type)  << std::endl
+	   << "\t image_constness_type = " << mlc_to_string(image_constness_type) << std::endl
+	   << "\t image_dimension_type = " << mlc_to_string(image_dimension_type) << std::endl
+
+	   << std::endl;
     }
 
   };
 
-  mlc_register_prop(category::image, neighb_type);
-  mlc_register_prop(category::image, concrete_type);
-  mlc_register_prop(category::image, value_type);
-  mlc_register_prop(category::image, point_type); 
-  mlc_register_prop(category::image, size_type); 
-  mlc_register_prop(category::image, piter_type); 
-  mlc_register_prop(category::image, fwd_piter_type); 
-  mlc_register_prop(category::image, bkd_piter_type); 
-  mlc_register_prop(category::image, value_storage_type);
-  mlc_register_prop(category::image, storage_type);
-  mlc_register_prop(category::image, delegated_type);
+} // end of namespace oln
 
-  mlc_register_prop(category::image, image_constness_type);
-  mlc_register_prop(category::image, image_dimension_type);
-  mlc_register_prop(category::image, image_neighbness_type);
 
+# include <oln/core/abstract/internal/image_impl.hh>
+# include <oln/core/value_box.hh>
 
 
+namespace oln
+{
 
   /*! \namespace oln::abstract
   ** \brief oln::abstract namespace.
Index: oln/core/abstract/piter.hh
===================================================================
--- oln/core/abstract/piter.hh	(revision 130)
+++ oln/core/abstract/piter.hh	(working copy)
@@ -33,7 +33,7 @@
 # include <mlc/contract.hh>
 
 # include <oln/core/abstract/point.hh>
-# include <oln/core/properties.hh>
+# include <oln/core/typedefs.hh>
 
 
 
@@ -44,55 +44,58 @@
   for(; p.is_valid(); p.next())
 
 
+
+# define oln_pit_type_of(PiterType, Alias) \
+mlc_type_of(oln, oln::category::piter, PiterType, Alias)
+
+
+
 namespace oln {
 
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct piter;
+
+
+  namespace category
+  {
+    struct piter;
   }
 
-  // category
-  template <typename E>
-  struct set_category< abstract::piter<E> > { typedef category::piter ret; };
 
+  template <>
+  struct set_default_props < category::piter >
+  {
+    typedef mlc::undefined_type point_type;
+    typedef mlc::undefined_type size_type;
+  };
 
-  /// properties of any type in category::piter
 
-  template <typename type>
-  struct props_of < category::piter, type >
+  template <typename P>
+  struct get_props < category::piter, P >
   {
-    typedef mlc::true_type user_defined_;
-    
-    mlc_decl_prop(category::piter, size_type);
-    mlc_decl_prop(category::piter, point_type);
+    typedef oln_pit_type_of(P, point) point_type;
+    typedef oln_pit_type_of(P, size)  size_type;
 
     static void echo(std::ostream& ostr)
     {
-      ostr << "props_of( category::piter, "
-	   << typeid(type).name() << ") = {"
-	   << "  size_type = " << typeid(size_type).name()
-	   << "  point_type = " << typeid(point_type).name() << "  }" << std::endl;
+      ostr << "props_of( oln::category::piter, " << mlc_to_string(P) << " ) =" << std::endl
+	   << "\t point_type = " << mlc_to_string(point_type) << std::endl
+	   << "\t size_type  = " << mlc_to_string(size_type)  << std::endl
+	   << std::endl;
     }
-
   };
 
-  mlc_register_prop(category::piter, size_type); 
-  mlc_register_prop(category::piter, point_type); 
 
-
-
   namespace abstract {
 
     template <typename E>
-    struct piter : public mlc::any__best_speed<E>
+    struct piter : public mlc::any<E>
     {
 
       /// typedefs
 
       typedef piter<E> self_type;
 
-      typedef oln_type_of(E, size)  size_type;
-      typedef oln_type_of(E, point) point_type;
+      typedef oln_pit_type_of(E, size)  size_type;
+      typedef oln_pit_type_of(E, point) point_type;
 
 
       void start()
Index: oln/core/abstract/image_like_.hh
===================================================================
--- oln/core/abstract/image_like_.hh	(revision 130)
+++ oln/core/abstract/image_like_.hh	(working copy)
@@ -39,25 +39,15 @@
     template <typename I, typename E> struct image_like_;
   }
 
-  // category
-
-  template <typename I, typename E>
-  struct set_category< abstract::image_like_<I, E> > {
-    typedef category::image ret;
-  };
-
   // super type
 
   template <typename I, typename E>
-  struct set_super_type < abstract::image_like_<I, E> >
-  {
-    typedef abstract::image_by_delegation<I, E> ret;
-  };
+  struct set_super_type < abstract::image_like_<I, E> > { typedef abstract::image_by_delegation<I, E> ret; };
 
   // props
 
   template <typename I, typename E>
-  struct set_props < category::image, abstract::image_like_<I, E> > : public props_of<category::image>
+  struct set_props < category::image, abstract::image_like_<I, E> >
   {
     typedef oln_type_of(I, concrete) concrete_type;
   };
Index: oln/core/abstract/point.hh
===================================================================
--- oln/core/abstract/point.hh	(revision 130)
+++ oln/core/abstract/point.hh	(working copy)
@@ -33,7 +33,7 @@
 # include <mlc/cmp.hh>
 
 # include <oln/core/coord.hh>
-# include <oln/core/properties.hh>
+# include <oln/core/typedefs.hh>
 
 
 // fwd decl
@@ -43,47 +43,47 @@
 
 
 
-# define oln_point_type_from_2(P1, P2)   typename mlc::if_< typename mlc::eq< P2, oln::any_point >::ret, P1, P2 >::ret
+# define oln_point_type_from_2(P1, P2)   typename mlc::if_< mlc::eq< P2, oln::any_point >, P1, P2 >::ret
 
 
+# define oln_pt_type_of(PointType, Alias) \
+mlc_type_of(oln, oln::category::point, PointType, Alias)
 
+
+
 /*! \namespace oln
 ** \brief oln namespace.
 */
 namespace oln {
 
 
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct point;
+  namespace category
+  {
+    struct point;
   }
 
-  // category
-  template <typename E>
-  struct set_category< abstract::point<E> > { typedef category::point ret; };
 
+  template <>
+  struct set_default_props < category::point >
+  {
+    typedef mlc::undefined_type dpoint_type;
+  };
 
-  /// properties of any type in category::point
 
-  template <typename type>
-  struct props_of < category::point, type >
+  template <typename P>
+  struct get_props < category::point, P >
   {
-    typedef mlc::true_type user_defined_;
-    
-    mlc_decl_prop(category::point, dpoint_type);
+    typedef oln_pt_type_of(P, dpoint) dpoint_type;
 
     static void echo(std::ostream& ostr)
     {
-      ostr << "props_of( category::point, "
-	   << typeid(type).name() << ") = {"
-	   << "  dpoint_type = " << typeid(dpoint_type).name() << "  }" << std::endl;
+      ostr << "props_of( oln::category::point, " << mlc_to_string(P) << " ) =" << std::endl
+	   << "\t dpoint_type = " << mlc_to_string(dpoint_type) << std::endl
+	   << std::endl;
     }
-
   };
 
-  mlc_register_prop(category::point, dpoint_type); 
 
-
   /*! \namespace oln::abstract
   ** \brief oln::abstract namespace.
   */
@@ -97,7 +97,7 @@
     ** Parameter E is the exact type of point.
     */
     template <typename E>
-    struct point : public mlc::any__best_memory<E>
+    struct point : public mlc::any<E>
     {
 
       typedef E exact_type;
@@ -135,7 +135,7 @@
 
       // FIXME: doc...
 
-      typedef oln_type_of(E, dpoint) dpoint_type;
+      typedef oln_pt_type_of(E, dpoint) dpoint_type;
 
       const exact_type operator+(const dpoint_type& dp) const
       {
Index: oln/core/abstract/witer.hh
===================================================================
--- oln/core/abstract/witer.hh	(revision 130)
+++ oln/core/abstract/witer.hh	(working copy)
@@ -1,147 +0,0 @@
-// Copyright (C) 2001, 2003, 2005  EPITA Research and Development Laboratory
-//
-// This file is part of the Olena Library.  This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License version 2 as published by the
-// Free Software Foundation.
-//
-// This library 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 this library; see the file COPYING.  If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-//
-// As a special exception, you may use this file as part of a free
-// software library 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 OLENA_CORE_ABSTRACT_WITER_HH
-# define OLENA_CORE_ABSTRACT_WITER_HH
-
-# include <mlc/any.hh>
-# include <mlc/types.hh>
-# include <oln/core/coord.hh>
-# include <oln/core/properties.hh>
-
-# include <string>
-
-namespace oln {
-
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct witer;
-  }
-
-  // category
-  template <typename E>
-  struct set_category< abstract::witer<E> > { typedef category::witer ret; };
-
-  /// properties of any type in category::witer
-  //
-  template <typename type>
-  struct props_of < category::witer, type >
-  {
-    typedef mlc::true_type user_defined_;
-
-    mlc_decl_prop(category::witer, se_type);
-
-    static void echo(std::ostream& ostr)
-    {
-      ostr << "props_of( category::witer, "
-	   << typeid(type).name() << ") = {"
-           << "  se_type = " << typeid(se_type).name()
-           << "  }" << std::endl;
-    }
-  };
-
-  mlc_register_prop(category::witer, se_type);
-
-  namespace abstract {
-
-    template <typename E>
-    struct witer : public mlc::any__best_speed<E>
-    {
-
-      typedef witer<E> self_type;
-
-      typedef oln_type_of(E, se)  se_type;
-      typedef oln_type_of(se_type, dpoint)  dpoint_type;
-
-      void start()
-      {
-        this->exact().impl_start();
-      }
-
-      void next()
-      {
-        precondition(this->is_valid());
-        this->exact().impl_next();
-      }
-
-      bool is_valid() const
-      {
-        return this->exact().impl_is_valid();
-      }
-
-      operator dpoint_type() const
-      {
-        precondition(this->is_valid());
-        return this->se_[pos_];
-      }
-
-      void invalidate()
-      {
-        this->exact().impl_invalidate();
-        postcondition(! this->is_valid());
-      }
-
-      coord_t nth(unsigned i)
-      {
-	return this->se_[this->pos_].nth(i);
-      }
-
-    protected:
-
-      void impl_start()
-      {
-        pos_ = 0;
-      }
-
-      void impl_next()
-      {
-        ++pos_;
-      }
-
-      bool impl_is_valid() const
-      {
-        return pos_ != se_.card();
-      }
-
-      void impl_invalidate()
-      {
-        pos_ = se_.card();
-      }
-
-      witer(const se_type& se)
-        : se_(se), pos_(0)
-      {}
-
-      const se_type& se_;
-      unsigned pos_;
-    };
-
-  } // abstract
-
-} // oln
-
-#endif // OLENA_CORE_ABSTRACT_WITER_HH
Index: oln/core/abstract/image_operator.hh
===================================================================
--- oln/core/abstract/image_operator.hh	(revision 130)
+++ oln/core/abstract/image_operator.hh	(working copy)
@@ -39,14 +39,6 @@
     template <typename O, typename I1, typename I2, typename E> struct image_binary_operator;
   }
 
-  // category
-  template <typename O, typename E>
-  struct set_category< abstract::image_operator<O, E> > { typedef category::image ret; };
-  template <typename O, typename I, typename E>
-  struct set_category< abstract::image_unary_operator<O, I, E> > { typedef category::image ret; };
-  template <typename O, typename I1, typename I2, typename E>
-  struct set_category< abstract::image_binary_operator<O, I1, I2, E> > { typedef category::image ret; };
-
   // super types
   template <typename O, typename E>
   struct set_super_type< abstract::image_operator<O, E> > { typedef abstract::image_like_<O, E> ret; };
@@ -56,22 +48,7 @@
   struct set_super_type< abstract::image_binary_operator<O, I1, I2, E> > { typedef abstract::image_operator<O, E> ret; };
 
 
-  // FIXME: an extension of props; remove (test purpose!)
-  template <typename O, typename E>
-  struct set_props < category::image, abstract::image_operator<O, E> > : public props_of<category::image>
-  {
-    typedef float dummy_type;
-  };
-  template <typename O, typename E>
-  struct set_type_of < category::image,
-		       abstract::image_operator<O, E>,
-		       target::dummy_type >
-  {
-    typedef double ret;
-  };
-  // end of FIXME: remove (test purpose!)
 
-
   namespace abstract {
 
 
Index: oln/core/abstract/data_storage.hh
===================================================================
--- oln/core/abstract/data_storage.hh	(revision 130)
+++ oln/core/abstract/data_storage.hh	(working copy)
@@ -29,57 +29,61 @@
 # define OLENA_CORE_ABSTRACT_DATA_STORAGE_HH
 
 # include <mlc/any.hh>
+# include <mlc/to_string.hh>
+# include <oln/core/typedefs.hh>
 
-# include <oln/core/properties.hh>
 
+# define oln_ds_type_of(DataStorageType, Alias) \
+mlc_type_of(oln, oln::category::data_storage, DataStorageType, Alias)
 
+
+
 namespace oln {
 
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct data_storage;
+
+  namespace category
+  {
+    struct data_storage;
   }
 
-  // category
-  template <typename E>
-  struct set_category< abstract::data_storage<E> > { typedef category::data_storage ret; };
 
+  template <>
+  struct set_default_props < category::data_storage >
+  {
+    typedef mlc::undefined_type size_type;
+    typedef mlc::undefined_type point_type;
+    typedef mlc::undefined_type data_type;
+  };
 
-  template <typename type>
-  struct props_of < category::data_storage, type >
+
+  template <typename S>
+  struct get_props < category::data_storage, S >
   {
-    typedef mlc::true_type user_defined_;
+    typedef oln_ds_type_of(S, size)  size_type;
+    typedef oln_ds_type_of(S, point) point_type;
+    typedef oln_ds_type_of(S, data)  data_type;
 
-    mlc_decl_prop(category::data_storage, size_type);
-    mlc_decl_prop(category::data_storage, point_type);
-    mlc_decl_prop(category::data_storage, data_type);
-
     static void echo(std::ostream& ostr)
     {
-      ostr << "props_of( category::data_storage, "
-	   << typeid(type).name() << " ) = {"
-	   << "  size_type = " << typeid(size_type).name()
-	   << "  point_type = " << typeid(point_type).name()
-	   << "  data_type = " << typeid(data_type).name() << "  }" << std::endl;
+      ostr << "props_of( oln::category::data_storage, " << mlc_to_string(S) << " ) =" << std::endl
+	   << "\t size_type  = " << mlc_to_string(size_type)  << std::endl
+	   << "\t point_type = " << mlc_to_string(point_type) << std::endl
+	   << "\t data_type  = " << mlc_to_string(data_type)  << std::endl
+	   << std::endl;
     }
-
   };
 
-  mlc_register_prop(category::data_storage, size_type);
-  mlc_register_prop(category::data_storage, point_type);
-  mlc_register_prop(category::data_storage, data_type);
 
-
   namespace abstract {
 
     template <typename E>
-    struct data_storage : public mlc::any__best_speed<E>
+    struct data_storage : public mlc::any<E>
     {
       // typedefs
 
-      typedef oln_type_of(E, size) size_type;
-      typedef oln_type_of(E, point) point_type;
-      typedef oln_type_of(E, data) data_type;
+      typedef oln_ds_type_of(E, size) size_type;
+      typedef oln_ds_type_of(E, point) point_type;
+      typedef oln_ds_type_of(E, data) data_type;
 
       // abstract methods
 
Index: oln/core/abstract/dpoint.hh
===================================================================
--- oln/core/abstract/dpoint.hh	(revision 130)
+++ oln/core/abstract/dpoint.hh	(working copy)
@@ -28,8 +28,9 @@
 #ifndef OLENA_CORE_ABSTRACT_DPOINT_HH
 # define OLENA_CORE_ABSTRACT_DPOINT_HH
 
+# include <mlc/any.hh>
 # include <oln/core/coord.hh>
-# include <mlc/any.hh>
+# include <oln/core/typedefs.hh>
 
 
 /*! \namespace oln
@@ -51,7 +52,7 @@
     ** Parameter E is the exact type of dpoint.
     */
     template <typename E>
-    struct dpoint : public mlc::any__best_memory<E>
+    struct dpoint : public mlc::any<E>
     {
 
       /// Test equality of two dpoints.
Index: oln/core/abstract/entry.hh
===================================================================
--- oln/core/abstract/entry.hh	(revision 130)
+++ oln/core/abstract/entry.hh	(working copy)
@@ -1,72 +0,0 @@
-// Copyright (C) 2005 EPITA Research and Development Laboratory
-//
-// This file is part of the Olena Library.  This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License version 2 as published by the
-// Free Software Foundation.
-//
-// This library 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 this library; see the file COPYING.  If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-//
-// As a special exception, you may use this file as part of a free
-// software library 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 OLENA_CORE_ABSTRACT_ENTRY_HH
-# define OLENA_CORE_ABSTRACT_ENTRY_HH
-
-# include <oln/core/abstract/images.hh>
-
-
-
-
-namespace oln {
-
-
-  // fwd decl
-  namespace abstract {
-    template <typename E> struct image_entry;
-  }
-
-  // category
-  template <typename E>
-  struct set_category < abstract::image_entry<E> >
-  {
-    typedef category::image ret;
-  };
-
-  namespace abstract {
-
-    template <typename E>
-    struct image_entry :
-      // intrusive:
-      public oln_type_of_(E, image_constness) ::template instantiated_with<E>::ret,
-      public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret,
-      public oln_type_of_(E, image_neighbness) ::template instantiated_with<E>::ret,
-      // ...
-      public typeness::inheritance_switch<E>,
-      public valuedness::inheritance_switch<E>
-    {
-    protected:
-      image_entry() {}
-    };
-
-  }
-
-} // end of namespace oln
-
-
-#endif // ! OLENA_CORE_ABSTRACT_ENTRY_HH
Index: oln/core/abstract/regular_niter.hh
===================================================================
--- oln/core/abstract/regular_niter.hh	(revision 130)
+++ oln/core/abstract/regular_niter.hh	(working copy)
@@ -38,7 +38,6 @@
 # include <oln/core/gen/image_with_nbh.hh>
 # include <oln/core/abstract/point.hh>
 # include <oln/core/abstract/dpoint.hh>
-# include <oln/core/properties.hh>
 # include <oln/core/abstract/image.hh>
 # include <oln/core/abstract/neighborhood.hh>
 # include <oln/core/abstract/image_neighbness.hh>
@@ -46,26 +45,14 @@
 
 namespace oln {
 
-  // fwd decls
-
+  // fwd decl
   namespace abstract {
     template <typename E> struct regular_niter;
   }
 
-  // category
-
-  template <typename E>
-  struct set_category< abstract::regular_niter<E> > {
-    typedef category::niter ret;
-  };
-
   // super type
-
   template <typename E>
-  struct set_super_type < abstract::regular_niter<E> >
-  {
-    typedef abstract::niter<E> ret;
-  };
+  struct set_super_type < abstract::regular_niter<E> > { typedef abstract::niter<E> ret; };
 
 
   namespace abstract {
@@ -73,11 +60,8 @@
     template <typename E>
     struct regular_niter : public niter<E>
     {
-
-      /// typedefs
-      typedef oln_type_of(E, point) point_type;
+      typedef oln_type_of(E, point)  point_type;
       typedef oln_type_of(E, dpoint) dpoint_type;
-      typedef regular_niter<E> self_type;
 
       void impl_start()
       {
@@ -86,8 +70,7 @@
 
       void impl_next()
       {
-	precondition(this->is_valid());
-	dp_cur_ ++;
+	++dp_cur_;
       }
 
       void impl_center_at(const point_type& pt)
@@ -104,7 +87,6 @@
 
       const point_type impl_cast_point() const
       {
-	precondition(this->is_valid());
 	return *dp_cur_ + this->p_;
       }
 
@@ -122,17 +104,21 @@
 	  dp_.push_back(this->nbh_[i]);
       }
 
-      template <typename T>
-      regular_niter(const abstract::image_with_nbh<T>& ima) :
-	niter<E>(ima)
+      typedef niter<E> super_type;
+
+      template <typename I>
+      regular_niter(const abstract::image_with_nbh<I>& ima) :
+	super_type(ima)
       {
       }
 
-      typename std::vector<dpoint_type>::iterator dp_cur_;
       std::vector<dpoint_type> dp_;
+      typename std::vector<dpoint_type>::const_iterator dp_cur_;
     };
-  }
-}
 
+  } // end of namespace oln::abstract
 
+} // end of namespace oln
+
+
 #endif // ! OLENA_CORE_ABSTRACT_REGULAR_NITER_HH
Index: oln/core/abstract/image_entry.hh
===================================================================
--- oln/core/abstract/image_entry.hh	(revision 0)
+++ oln/core/abstract/image_entry.hh	(revision 0)
@@ -0,0 +1,70 @@
+// Copyright (C) 2005 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library 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 OLENA_CORE_ABSTRACT_IMAGE_ENTRY_HH
+# define OLENA_CORE_ABSTRACT_IMAGE_ENTRY_HH
+
+# include <oln/core/abstract/images.hh>
+
+
+
+
+namespace oln {
+
+  // fwd decl
+  namespace abstract {
+    template <typename E> struct image_entry;
+  }
+
+  // entry => no super type but a category
+
+  template <typename E>
+  struct set_category < abstract::image_entry<E> > { typedef category::image ret; };
+
+
+  namespace abstract {
+
+    template <typename E>
+    struct image_entry :
+      // intrusive:
+      public oln_type_of_(E, image_constness) ::template instantiated_with<E>::ret,
+      public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret,
+      public oln_type_of_(E, image_neighbness) ::template instantiated_with<E>::ret,
+      // ...
+      public typeness::inheritance_switch<E>,
+      public valuedness::inheritance_switch<E>
+    {
+    protected:
+      image_entry() {}
+    };
+
+  }
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_ABSTRACT_IMAGE_ENTRY_HH
Index: oln/core/abstract/images.hh
===================================================================
--- oln/core/abstract/images.hh	(revision 130)
+++ oln/core/abstract/images.hh	(working copy)
@@ -40,7 +40,7 @@
 
 
 // hierarchy entry
-# include <oln/core/abstract/entry.hh>
+# include <oln/core/abstract/image_entry.hh>
 
 
 
Index: oln/core/abstract/image_with_data.hh
===================================================================
--- oln/core/abstract/image_with_data.hh	(revision 130)
+++ oln/core/abstract/image_with_data.hh	(working copy)
@@ -30,7 +30,7 @@
 
 
 # include <mlc/tracked_ptr.hh>
-# include <oln/core/abstract/entry.hh>
+# include <oln/core/abstract/image_entry.hh>
 
 
 /*! \namespace oln
@@ -44,23 +44,13 @@
     template <typename E> class image_with_data;
   }
 
-  // category
-  template <typename E>
-  struct set_category < abstract::image_with_data<E> >
-  {
-    typedef category::image ret;
-  };
-
   // super_type
   template <typename E>
-  struct set_super_type < abstract::image_with_data<E> >
-  {
-    typedef abstract::image_entry<E> ret;
-  };
+  struct set_super_type < abstract::image_with_data<E> > { typedef abstract::image_entry<E> ret; };
 
   // props
   template <typename E>
-  struct set_props < category::image, abstract::image_with_data<E> > : public props_of<category::image>
+  struct set_props < category::image, abstract::image_with_data<E> >
   {
     // intrusive property:
     typedef is_a<abstract::readwrite_image> image_constness_type;
Index: oln/core/abstract/neighborhood.hh
===================================================================
--- oln/core/abstract/neighborhood.hh	(revision 130)
+++ oln/core/abstract/neighborhood.hh	(working copy)
@@ -28,56 +28,61 @@
 #ifndef OLENA_CORE_NEIGHBORHOOD_HH
 # define OLENA_CORE_NEIGHBORHOOD_HH
 
-# include <mlc/types.hh>
-# include <oln/core/properties.hh>
-# include <oln/core/coord.hh>
-# include <oln/core/abstract/dpoint.hh>
-# include <oln/core/accum.hh>
 # include <vector>
 # include <utility>
 # include <iostream>
 
+# include <oln/core/typedefs.hh>
+# include <oln/core/coord.hh>
+# include <oln/core/abstract/dpoint.hh>
+# include <oln/core/accum.hh>
+
+
+# define oln_nbh_type_of(NeighborhoodType, Alias)  \
+mlc_type_of(oln, oln::category::neighborhood, NeighborhoodType, Alias)
+
+
 namespace oln {
 
-  // fwd decl
-  namespace abstract {
-    template<class Exact>
+  namespace category
+  {
     struct neighborhood;
   }
 
-  // category
-  template <typename E>
-  struct set_category< abstract::neighborhood<E> >
+  /// Default properties of any neighborhood type.
+
+  template <>
+  struct set_default_props < category::neighborhood >
   {
-    typedef category::neighborhood ret;
+    typedef mlc::undefined_type dpoint_type;
+    typedef mlc::undefined_type size_type;
+    typedef mlc::undefined_type window_type;
   };
 
-  /// properties of any type in category::neighborhood
 
-  template <typename type>
-  struct props_of <category::neighborhood, type>
+  /// Retrieval of any image type properties (FIXME: say 'packing').
+
+  template <typename N>
+  struct get_props < category::neighborhood, N >
   {
-    typedef mlc::true_type user_defined_;
+    typedef oln_nbh_type_of(N, dpoint) dpoint_type;
+    typedef oln_nbh_type_of(N, size)   size_type;
+    typedef oln_nbh_type_of(N, window) window_type;
 
-    mlc_decl_prop(category::neighborhood, dpoint_type);
-    mlc_decl_prop(category::neighborhood, size_type);
-    mlc_decl_prop(category::neighborhood, window_type);
-
     static void echo(std::ostream& ostr)
     {
-      ostr << "props_of( category::neighborhood, "
-	   << typeid(type).name() << ") = {"
-	   << "  size_type = " << typeid(size_type).name() << "," << std::endl
-	   << "  dpoint_type = " << typeid(dpoint_type).name() << "  }" << std::endl;
+      ostr << "props_of( oln::category::neighborhood, " << mlc_to_string(N) << " ) =" << std::endl
+	   << "\t dpoint_type = " << mlc_to_string(dpoint_type) << std::endl
+	   << "\t size_type   = " << mlc_to_string(size_type)   << std::endl
+	   << "\t window_type = " << mlc_to_string(window_type) << std::endl
+	   << std::endl;
     }
 
   };
 
-  mlc_register_prop(category::neighborhood, dpoint_type);
-  mlc_register_prop(category::neighborhood, size_type);
-  mlc_register_prop(category::neighborhood, window_type);
 
 
+
   namespace abstract {
 
     /*!
@@ -92,7 +97,7 @@
 
     public:
 
-      typedef oln_type_of(E, dpoint) dpoint_type;
+      typedef oln_nbh_type_of(E, dpoint) dpoint_type;
 
       typedef E exact_type;
 
Index: oln/core/abstract/image_by_delegation.hh
===================================================================
--- oln/core/abstract/image_by_delegation.hh	(revision 130)
+++ oln/core/abstract/image_by_delegation.hh	(working copy)
@@ -29,8 +29,7 @@
 # define OLENA_CORE_ABSTRACT_IMAGE_BY_DELEGATION_HH
 
 # include <oln/core/box.hh>
-# include <oln/core/properties.hh>
-# include <oln/core/abstract/entry.hh>
+# include <oln/core/abstract/image_entry.hh>
 
 
 namespace oln {
@@ -41,17 +40,12 @@
     template <typename I, typename E> struct image_by_delegation;
   }
 
-  // category
+  // super type
 
   template <typename I, typename E>
-  struct set_category< abstract::image_by_delegation<I, E> > {
-    typedef category::image ret;
-  };
-
+  struct set_super_type < abstract::image_by_delegation<      I, E> > { typedef abstract::image_entry<E> ret; };
   template <typename I, typename E>
-  struct set_category< abstract::image_by_delegation<const I, E> > {
-    typedef category::image ret;
-  };
+  struct set_super_type < abstract::image_by_delegation<const I, E> > { typedef abstract::image_entry<E> ret; };
 
   // props
 
Index: oln/core/abstract/image_with_extension.hh
===================================================================
--- oln/core/abstract/image_with_extension.hh	(revision 130)
+++ oln/core/abstract/image_with_extension.hh	(working copy)
@@ -25,8 +25,8 @@
 // reasons why the executable file might be covered by the GNU General
 // Public License.
 
-#ifndef OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION__HH
-# define OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION__HH
+#ifndef OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION_HH
+# define OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION_HH
 
 # include <oln/core/abstract/image_by_delegation.hh>
 
@@ -36,28 +36,18 @@
 
   // fwd decl
   namespace abstract {
-    template <typename I, typename E> struct image_with_extension_;
+    template <typename I, typename E> struct image_with_extension;
   }
 
-  // category
-
-  template <typename I, typename E>
-  struct set_category< abstract::image_with_extension_<I, E> > {
-    typedef category::image ret;
-  };
-
   // super type
 
   template <typename I, typename E>
-  struct set_super_type < abstract::image_with_extension_<I, E> >
-  {
-    typedef abstract::image_by_delegation<I, E> ret;
-  };
+  struct set_super_type < abstract::image_with_extension<I, E> > { typedef abstract::image_by_delegation<I, E> ret; };
 
   // props
 
   template <typename I, typename E>
-  struct set_props < category::image, abstract::image_with_extension_<I, E> > : public props_of<category::image>
+  struct set_props < category::image, abstract::image_with_extension<I, E> >
   {
     typedef oln_type_of(I, concrete) concrete_type;
   };
@@ -65,20 +55,20 @@
 
   namespace abstract {
 
-    /// Mutable version of image_with_extension_.
+    /// Mutable version of image_with_extension.
 
     template <typename I, typename E>
-    struct image_with_extension_ : public image_by_delegation<I, E>
+    struct image_with_extension : public image_by_delegation<I, E>
     {
       typedef image_by_delegation<I, E> super_type;
 
     public:
 
-      image_with_extension_ ()
+      image_with_extension ()
       {
       }
 
-      image_with_extension_(abstract::image<I>& image) :
+      image_with_extension(const abstract::image<I>& image) :
 	super_type(image)
       {
       }
@@ -93,7 +83,7 @@
 	return this->image_.unbox();
       }
 
-      ~image_with_extension_ ()
+      ~image_with_extension ()
       {
 	// FIXME : This class must check all properties
 
@@ -115,4 +105,4 @@
 } // end of namespace oln
 
 
-#endif // ! OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION__HH
+#endif // ! OLENA_CORE_ABSTRACT_IMAGE_WITH_EXTENSION_HH
Index: oln/core/abstract/size.hh
===================================================================
--- oln/core/abstract/size.hh	(revision 130)
+++ oln/core/abstract/size.hh	(working copy)
@@ -31,6 +31,7 @@
 # include <mlc/any.hh>
 # include <mlc/if.hh>
 # include <mlc/cmp.hh>
+# include <oln/core/typedefs.hh>
 
 
 // fwd decl
Index: oln/core/abstract/internal/image_impl.hh
===================================================================
--- oln/core/abstract/internal/image_impl.hh	(revision 130)
+++ oln/core/abstract/internal/image_impl.hh	(working copy)
@@ -31,9 +31,7 @@
 # include <mlc/any.hh>
 # include <mlc/types.hh>
 
-# include <oln/core/properties.hh>
 
-
 namespace oln {
 
   namespace abstract {
Index: oln/core/1d/dpoint1d.hh
===================================================================
--- oln/core/1d/dpoint1d.hh	(revision 130)
+++ oln/core/1d/dpoint1d.hh	(working copy)
@@ -28,15 +28,23 @@
 #ifndef OLENA_CORE_1D_DPOINT1D_HH
 # define OLENA_CORE_1D_DPOINT1D_HH
 
-# include <ostream>
+# include <iostream>
+
 # include <oln/core/coord.hh>
 # include <oln/core/abstract/dpoint.hh>
 
 
 namespace oln {
 
+  // fwd decls
+  struct dpoint1d;
   struct point1d;
 
+  // super type
+  template <>
+  struct set_super_type < dpoint1d > { typedef abstract::dpoint< dpoint1d > ret; };
+
+
   struct dpoint1d : public abstract::dpoint < dpoint1d >
   {
     dpoint1d()
Index: oln/core/1d/array1d.hh
===================================================================
--- oln/core/1d/array1d.hh	(revision 130)
+++ oln/core/1d/array1d.hh	(working copy)
@@ -28,28 +28,23 @@
 #ifndef OLENA_CORE_1D_ARRAY1D_HH
 # define OLENA_CORE_1D_ARRAY1D_HH
 
-
 # include <oln/core/abstract/data_storage.hh>
 # include <oln/core/1d/size1d.hh>
 # include <oln/core/1d/point1d.hh>
 
+
 namespace oln {
 
-
   // fwd decl
   template <typename T> struct array1d;
 
-  // category
-  template <typename T> 
-  struct set_category< array1d<T> > { typedef category::data_storage ret; };
-
-  // super_type
-  template <typename T> 
-  struct set_super_type< array1d<T> > { typedef abstract::data_storage< array1d<T> > ret; };
+  // super type
+  template <typename T>
+  struct set_super_type < array1d<T> > { typedef abstract::data_storage< array1d<T> > ret; };
   
   // props
   template <typename T>
-  struct set_props < category::data_storage, array1d<T> > : public props_of<category::data_storage>
+  struct set_props < category::data_storage, array1d<T> >
   {
     typedef size1d  size_type;
     typedef point1d point_type;
@@ -57,6 +52,7 @@
   };
 
 
+
   template <typename T>
   class array1d : public abstract::data_storage< array1d<T> >
   {
Index: oln/core/1d/image1d.hh
===================================================================
--- oln/core/1d/image1d.hh	(revision 130)
+++ oln/core/1d/image1d.hh	(working copy)
@@ -28,10 +28,7 @@
 #ifndef OLENA_CORE_1D_IMAGE1D_HH
 # define OLENA_CORE_1D_IMAGE1D_HH
 
-# include <mlc/traits.hh>
-
 # include <oln/core/abstract/image_with_data.hh>
-# include <oln/core/abstract/image_like_.hh>
 # include <oln/core/1d/array1d.hh>
 
 
@@ -42,26 +39,18 @@
 namespace oln {
 
 
-
   // fwd decls
   struct fwd_piter1d;
   template <typename T> class image1d;
 
-  // category
+  // super type
   template <typename T>
-  struct set_category< image1d<T> > { typedef category::image ret; };
+  struct set_super_type < image1d<T> > { typedef abstract::image_with_data< image1d<T> > ret; };
 
-  // super
+  // props
   template <typename T>
-  struct set_super_type < image1d<T> >
+  struct set_props < category::image, image1d<T> >
   {
-    typedef abstract::image_with_data< image1d<T> > ret;
-  };
-
-
-  template <typename T>
-  struct set_props < category::image, image1d<T> > : public props_of<category::image>
-  {
     // intrusive property:
     typedef is_a<abstract::image1d> image_dimension_type;
     // FIXME: should be generalized
@@ -78,7 +67,7 @@
     // please note that value_storage_type means data_type
     // since image1d is an image_with_data
     typedef T value_storage_type;
-//     typedef mlc_encoding_type(T) value_storage_type;
+    // FIXME: above, that should be mlc_encoding_type(T)
 
     // please note that value_container_type means
     // data_container_type (or value_storage_container_type)
Index: oln/core/1d/fwd_piter1d.hh
===================================================================
--- oln/core/1d/fwd_piter1d.hh	(revision 130)
+++ oln/core/1d/fwd_piter1d.hh	(working copy)
@@ -29,7 +29,6 @@
 # define OLENA_CORE_1D_FWD_PITER1D_HH
 
 # include <mlc/contract.hh>
-
 # include <oln/core/abstract/piter.hh>
 # include <oln/core/1d/point1d.hh>
 # include <oln/core/1d/size1d.hh>
@@ -41,14 +40,13 @@
   // fwd decl
   struct fwd_piter1d;
 
-  // category
+  // super type
   template <>
-  struct set_category<fwd_piter1d> { typedef category::piter ret; };
+  struct set_super_type < fwd_piter1d > { typedef abstract::piter< fwd_piter1d > ret; };
 
-
   // props
   template <>
-  struct set_props < category::piter, fwd_piter1d > : public props_of<category::piter>
+  struct set_props < category::piter, fwd_piter1d >
   {
     typedef point1d point_type;
     typedef size1d  size_type;
@@ -64,14 +62,12 @@
     fwd_piter1d(const size1d& size) :
       super_type(size)
     {
-      this->exact_ptr = this;
       this->invalidate();
     }
 
-# if defined __GNUC__ && __GNUC__ >= 3
     friend class abstract::piter< fwd_piter1d >;
+
   protected:
-# endif
 
     void impl_start()
     {
Index: oln/core/1d/point1d.hh
===================================================================
--- oln/core/1d/point1d.hh	(revision 130)
+++ oln/core/1d/point1d.hh	(working copy)
@@ -28,33 +28,25 @@
 #ifndef OLENA_CORE_1D_POINT1D_HH
 # define OLENA_CORE_1D_POINT1D_HH
 
-# include <ostream>
-
+# include <iostream>
 # include <oln/core/abstract/point.hh>
 # include <oln/core/coord.hh>
-# include <oln/core/properties.hh>
 
-// FIXME: doc
 
-// FIXME: test that coords are defined
 
 namespace oln {
 
-
+  // fwd decls
   struct point1d;
   struct dpoint1d;
 
-  // category
+  // super type
   template <>
-  struct set_category< point1d > { typedef category::point ret; };
+  struct set_super_type < point1d > { typedef abstract::point< point1d > ret; };
 
-  // super_type
-  template <>
-  struct set_super_type< point1d > { typedef abstract::point< point1d > ret; };
-
   // props
   template <>
-  struct set_props < category::point, point1d > : public props_of<category::point>
+  struct set_props < category::point, point1d >
   {
     typedef dpoint1d dpoint_type;
   };
@@ -89,10 +81,9 @@
     const coord_t index() const { return index_; }
     coord_t& index() { return index_; }
 
-# if defined __GNUC__ && __GNUC__ >= 3
     friend class abstract::point< point1d >;
+
   protected:
-# endif
 
     const point1d impl_plus(const dpoint1d& rhs) const;
 
Index: oln/core/1d/size1d.hh
===================================================================
--- oln/core/1d/size1d.hh	(revision 130)
+++ oln/core/1d/size1d.hh	(working copy)
@@ -35,7 +35,14 @@
 
 namespace oln {
 
+  // fwd decl
+  struct size1d;
 
+  // super type
+  template <>
+  struct set_super_type < size1d > { typedef abstract::size< size1d > ret; };
+
+
   struct size1d : public abstract::size< size1d >
   {
     size1d()
Index: oln/core/2d/dpoint2d.hh
===================================================================
--- oln/core/2d/dpoint2d.hh	(revision 130)
+++ oln/core/2d/dpoint2d.hh	(working copy)
@@ -35,8 +35,15 @@
 
 namespace oln {
 
+  // fwd decls
+  struct dpoint2d;
   struct point2d;
 
+  // super type
+  template <>
+  struct set_super_type < dpoint2d > { typedef abstract::dpoint< dpoint2d > ret; };
+
+
   struct dpoint2d : public abstract::dpoint < dpoint2d >
   {
     dpoint2d()
Index: oln/core/2d/array2d.hh
===================================================================
--- oln/core/2d/array2d.hh	(revision 130)
+++ oln/core/2d/array2d.hh	(working copy)
@@ -38,17 +38,9 @@
   // fwd decl
   template <typename T> struct array2d;
 
-  // category
-  template <typename T>
-  struct set_category< array2d<T> > { typedef category::data_storage ret; };
-
-  // super_type
-  template <typename T>
-  struct set_super_type< array2d<T> > { typedef abstract::data_storage< array2d<T> > ret; };
-
   // props
   template <typename T>
-  struct set_props < category::data_storage, array2d<T> > : public props_of<category::data_storage>
+  struct set_props < category::data_storage, array2d<T> >
   {
     typedef size2d  size_type;
     typedef point2d point_type;
Index: oln/core/2d/image2d.hh
===================================================================
--- oln/core/2d/image2d.hh	(revision 130)
+++ oln/core/2d/image2d.hh	(working copy)
@@ -28,8 +28,6 @@
 #ifndef OLENA_CORE_IMAGE2D_HH
 # define OLENA_CORE_IMAGE2D_HH
 
-# include <mlc/traits.hh>
-
 # include <oln/core/abstract/image_with_data.hh>
 # include <oln/core/abstract/image_like_.hh>
 # include <oln/core/2d/array2d.hh>
@@ -55,20 +53,13 @@
   struct bkd_piter2d;
   template <typename T> class image2d;
 
-  // category
-  template <typename T>
-  struct set_category< image2d<T> > { typedef category::image ret; };
-
   // super
   template <typename T>
-  struct set_super_type < image2d<T> >
-  {
-    typedef abstract::image_with_data< image2d<T> > ret;
-  };
+  struct set_super_type < image2d<T> > { typedef abstract::image_with_data< image2d<T> > ret; };
 
-
+  // props
   template <typename T>
-  struct set_props < category::image, image2d<T> > : public props_of<category::image>
+  struct set_props < category::image, image2d<T> >
   {
     // intrusive property:
     typedef is_a<abstract::image2d> image_dimension_type;
Index: oln/core/2d/fwd_regular_niter2d.hh
===================================================================
--- oln/core/2d/fwd_regular_niter2d.hh	(revision 130)
+++ oln/core/2d/fwd_regular_niter2d.hh	(working copy)
@@ -38,7 +38,6 @@
 # include <oln/core/gen/image_with_nbh.hh>
 # include <oln/core/abstract/point.hh>
 # include <oln/core/abstract/dpoint.hh>
-# include <oln/core/properties.hh>
 # include <oln/core/abstract/image.hh>
 # include <oln/core/abstract/neighborhood.hh>
 # include <oln/core/abstract/image_neighbness.hh>
Index: oln/core/2d/bkd_piter2d.hh
===================================================================
--- oln/core/2d/bkd_piter2d.hh	(revision 130)
+++ oln/core/2d/bkd_piter2d.hh	(working copy)
@@ -29,7 +29,6 @@
 # define OLENA_CORE_2D_BKD_PITER2D_HH
 
 # include <mlc/contract.hh>
-
 # include <oln/core/abstract/piter.hh>
 # include <oln/core/2d/point2d.hh>
 # include <oln/core/2d/size2d.hh>
@@ -40,14 +39,13 @@
   // fwd decl
   struct bkd_piter2d;
 
-  // category
+  // super type
   template <>
-  struct set_category<bkd_piter2d> { typedef category::piter ret; };
+  struct set_super_type < bkd_piter2d > { typedef abstract::piter< bkd_piter2d > ret; };
 
-
   // props
   template <>
-  struct set_props < category::piter, bkd_piter2d > : public props_of<category::piter>
+  struct set_props < category::piter, bkd_piter2d >
   {
     typedef point2d point_type;
     typedef size2d  size_type;
@@ -58,19 +56,17 @@
   struct bkd_piter2d : public abstract::piter< bkd_piter2d >
   {
 
-    typedef abstract::piter<bkd_piter2d> super_type;
+    typedef abstract::piter< bkd_piter2d > super_type;
 
     bkd_piter2d(const size2d& size) :
       super_type(size)
     {
-      this->exact_ptr = this;
       this->invalidate();
     }
 
-# if defined __GNUC__ && __GNUC__ >= 3
-    friend class abstract::piter< bkd_piter2d >;
+    friend class abstract::piter< bkd_piter2d >; // FIXME: replace by super_type (?)
+
   protected:
-# endif
 
     void impl_start()
     {
Index: oln/core/2d/fwd_piter2d.hh
===================================================================
--- oln/core/2d/fwd_piter2d.hh	(revision 130)
+++ oln/core/2d/fwd_piter2d.hh	(working copy)
@@ -29,7 +29,6 @@
 # define OLENA_CORE_2D_FWD_PITER2D_HH
 
 # include <mlc/contract.hh>
-
 # include <oln/core/abstract/piter.hh>
 # include <oln/core/2d/point2d.hh>
 # include <oln/core/2d/size2d.hh>
@@ -40,14 +39,13 @@
   // fwd decl
   struct fwd_piter2d;
 
-  // category
+  // super type
   template <>
-  struct set_category<fwd_piter2d> { typedef category::piter ret; };
+  struct set_super_type < fwd_piter2d > { typedef abstract::piter< fwd_piter2d > ret; };
 
-
   // props
   template <>
-  struct set_props < category::piter, fwd_piter2d > : public props_of<category::piter>
+  struct set_props < category::piter, fwd_piter2d >
   {
     typedef point2d point_type;
     typedef size2d  size_type;
@@ -63,14 +61,12 @@
     fwd_piter2d(const size2d& size) :
       super_type(size)
     {
-      this->exact_ptr = this;
       this->invalidate();
     }
 
-# if defined __GNUC__ && __GNUC__ >= 3
     friend class abstract::piter< fwd_piter2d >;
+
   protected:
-# endif
 
     void impl_start()
     {
Index: oln/core/2d/fwd_qiter2d.hh
===================================================================
--- oln/core/2d/fwd_qiter2d.hh	(revision 0)
+++ oln/core/2d/fwd_qiter2d.hh	(revision 0)
@@ -0,0 +1,105 @@
+// Copyright (C) 2001, 2003, 2005  EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library.  This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING.  If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library 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 OLENA_CORE_FWD_QITER2D_HH
+# define OLENA_CORE_FWD_QITER2D_HH
+
+# include <string>
+
+# include <oln/core/abstract/qiter.hh>
+# include <oln/core/2d/dpoint2d.hh>
+# include <oln/core/2d/window2d.hh>
+
+
+namespace oln {
+
+  // fwd decl
+  struct fwd_qiter2d;
+
+  // category
+  template <>
+  struct set_super_type< fwd_qiter2d > { typedef abstract::qiter< fwd_qiter2d > ret; };
+
+  // props
+  template <>
+  struct set_props < category::qiter, fwd_qiter2d >
+  {
+    typedef dpoint2d dpoint_type; // FIXME: !!!
+    typedef window2d window_type; // FIXME: !!!
+  };
+
+
+  struct fwd_qiter2d : public abstract::qiter< fwd_qiter2d >
+  {
+    typedef abstract::qiter<fwd_qiter2d> super_type;
+
+    fwd_qiter2d(const window2d& se) :
+      se_(se),
+      pos_(0)
+    {
+      this->invalidate();
+    }
+
+    coord_t impl_nth(unsigned i)
+    {
+      return se_[pos_].nth(i);
+    }
+
+    dpoint2d impl_cast_dpoint() const
+    {
+      precondition(this->is_valid());
+      return se_[pos_];
+    }
+
+    void impl_start()
+    {
+      pos_ = 0;
+    }
+
+    void impl_next()
+    {
+      ++pos_;
+    }
+
+    bool impl_is_valid() const
+    {
+      return pos_ != se_.card();
+    }
+
+    void impl_invalidate()
+    {
+      pos_ = se_.card();
+    }
+
+    const window2d& se_;
+    unsigned pos_;
+
+  };
+
+} // end of namespace oln
+
+#endif // OLENA_CORE_FWD_QITER2D_HH
Index: oln/core/2d/neighborhood2d.hh
===================================================================
--- oln/core/2d/neighborhood2d.hh	(revision 130)
+++ oln/core/2d/neighborhood2d.hh	(working copy)
@@ -28,70 +28,68 @@
 #ifndef OLENA_CORE_NEIGHBORHOOD2D_HH
 # define OLENA_CORE_NEIGHBORHOOD2D_HH
 
+# include <oln/core/coord.hh>
+# include <oln/core/abstract/neighborhood.hh>
 # include <oln/core/2d/dpoint2d.hh>
 # include <oln/core/2d/size2d.hh>
 # include <oln/core/2d/window2d.hh>
-# include <oln/core/coord.hh>
-# include <oln/core/abstract/neighborhood.hh>
 
+
 namespace oln {
 
   class neighborhood2d; // forward declaration
 
-  // category
-  template <>
-  struct set_category< neighborhood2d >
-  { typedef category::neighborhood ret; };
-
   // super_type
   template <>
-  struct set_super_type< neighborhood2d >
-  {
-    typedef abstract::neighborhood< neighborhood2d > ret;
-  };
+  struct set_super_type< neighborhood2d > { typedef abstract::neighborhood< neighborhood2d > ret; };
 
   template <>
   struct set_props< category::neighborhood, neighborhood2d >
-  : public props_of<category::neighborhood>
   {
-    typedef dpoint2d    dpoint_type;
-    typedef size2d      size_type;
-    typedef window2d    window_type;
+    typedef dpoint2d dpoint_type;
+    typedef size2d   size_type;
+    typedef window2d window_type;
   };
 
-  class neighborhood2d : public abstract::neighborhood<neighborhood2d>
+
+  class neighborhood2d : public abstract::neighborhood< neighborhood2d >
   {
 
   public:
 
-    typedef abstract::neighborhood<neighborhood2d>      super_type;
+    typedef abstract::neighborhood< neighborhood2d > super_type;
 
     /*!
     ** \brief Construct a neighborhood of 2 dimensions.
     */
-    neighborhood2d() : super_type()
-    {}
+    neighborhood2d() :
+      super_type()
+    {
+    }
 
     /*!
     ** \brief Construct a neighborhood of 2 dimensions.
     ** \arg size The number of element.
     */
-    neighborhood2d(unsigned size) : super_type(size)
-    {}
+    neighborhood2d(unsigned size) :
+      super_type(size)
+    {
+    }
 
     /*!
     ** \brief Construct a neighborhood of 2 dimensions from several points.
     ** \arg n The number of element.
     ** \arg crd The coordinates of the elements
     */
-    neighborhood2d(unsigned n, const coord_t crd[]) : super_type(n)
+    neighborhood2d(unsigned n, const coord_t crd[]) :
+      super_type(n)
     {
       for (unsigned i = 0; i < 2 * n; i += 2)
-        this->add(dpoint_type(crd[i], crd[i+1]));
+        this->add(dpoint2d(crd[i], crd[i+1]));
     }
 
     neighborhood2d&
-    add(const dpoint_type& dp)
+    add(const dpoint2d& dp)
     {
       return this->exact().impl_add(dp);
     }
@@ -99,7 +97,7 @@
     neighborhood2d&
     add(coord_t row, coord_t col)
     {
-      dpoint_type dp(row, col);
+      dpoint2d dp(row, col);
       return add(dp);
     }
 
@@ -112,7 +110,7 @@
     }
 
     coord_t
-    impl_delta_update(const dpoint_type& dp)
+    impl_delta_update(const dpoint2d& dp)
     {
       delta_(abs(dp.row()));
       delta_(abs(dp.col()));
@@ -121,6 +119,7 @@
 
   };
 
+
   inline const neighborhood2d&
   neighb_c4()
   {
Index: oln/core/2d/window2d.hh
===================================================================
--- oln/core/2d/window2d.hh	(revision 130)
+++ oln/core/2d/window2d.hh	(working copy)
@@ -28,42 +28,37 @@
 #ifndef OLENA_CORE_WINDOW2D_HH
 # define OLENA_CORE_WINDOW2D_HH
 
+# include <oln/core/abstract/window.hh>
 # include <oln/core/2d/dpoint2d.hh>
 # include <oln/core/2d/size2d.hh>
 # include <oln/core/coord.hh>
-# include <oln/core/abstract/struct_elt.hh>
 
+
 namespace oln {
 
-  class window2d; // forward declaration
-  class fwd_witer2d;
+  // fwd decls
+  class window2d;
+  class fwd_qiter2d;
 
-  // category
-  template <>
-  struct set_category< window2d > { typedef category::struct_elt ret; };
-
   // super_type
-  template <>
-  struct set_super_type< window2d >
-  {
-    typedef abstract::struct_elt< window2d > ret;
-  };
+  template <> struct set_super_type< window2d > { typedef abstract::window< window2d > ret; };
 
+  // props
   template <>
-  struct set_props< category::struct_elt, window2d > 
-  : public props_of<category::struct_elt>
+  struct set_props< category::window, window2d > 
   {
     typedef dpoint2d    dpoint_type;
     typedef size2d      size_type;
-    typedef fwd_witer2d fwd_witer_type;
+    typedef fwd_qiter2d fwd_qiter_type;
   };
 
-  class window2d : public abstract::struct_elt<window2d>
+
+  class window2d : public abstract::window< window2d >
   {
 
   public:
    
-    typedef abstract::struct_elt<window2d>      super_type;
+    typedef abstract::window< window2d > super_type;
 
     /*!
     ** \brief Construct a window of 2 dimensions.
Index: oln/core/2d/point2d.hh
===================================================================
--- oln/core/2d/point2d.hh	(revision 130)
+++ oln/core/2d/point2d.hh	(working copy)
@@ -30,7 +30,6 @@
 
 # include <iostream>
 
-# include <oln/core/properties.hh>
 # include <oln/core/abstract/point.hh>
 # include <oln/core/coord.hh>
 
@@ -39,20 +38,17 @@
 
 namespace oln {
 
+  // fwd decls
   struct point2d;
   struct dpoint2d;
 
-  // category
+  // super type
   template <>
-  struct set_category< point2d > { typedef category::point ret; };
+  struct set_super_type < point2d > { typedef abstract::point< point2d > ret; };
 
-  // super_type
-  template <>
-  struct set_super_type< point2d > { typedef abstract::point< point2d > ret; };
-
   // props
   template <>
-  struct set_props < category::point, point2d > : public props_of<category::point>
+  struct set_props < category::point, point2d >
   {
     typedef dpoint2d dpoint_type;
   };
@@ -93,10 +89,9 @@
     coord_t& row() { return row_; }
     coord_t& col() { return col_; }
 
-# if defined __GNUC__ && __GNUC__ >= 3
     friend class abstract::point< point2d >;
+
   protected:
-# endif
 
     const point2d impl_plus(const dpoint2d& rhs) const;
 
Index: oln/core/2d/fwd_witer2d.hh
===================================================================
--- oln/core/2d/fwd_witer2d.hh	(revision 130)
+++ oln/core/2d/fwd_witer2d.hh	(working copy)
@@ -1,68 +0,0 @@
-// Copyright (C) 2001, 2003, 2005  EPITA Research and Development Laboratory
-//
-// This file is part of the Olena Library.  This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License version 2 as published by the
-// Free Software Foundation.
-//
-// This library 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 this library; see the file COPYING.  If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-//
-// As a special exception, you may use this file as part of a free
-// software library 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 OLENA_CORE_FWD_WITER2D_HH
-# define OLENA_CORE_FWD_WITER2D_HH
-
-# include <oln/core/abstract/witer.hh>
-# include <oln/core/2d/window2d.hh>
-
-# include <string>
-
-namespace oln {
-
-  // fwd decl
-  struct fwd_witer2d;
-
-  // category
-  template <>
-  struct set_category<fwd_witer2d> { typedef category::witer ret; };
-
-  // props
-  template <>
-  struct set_props < category::witer, fwd_witer2d > : public props_of<category::witer>
-  {
-    typedef window2d se_type;
-  };
-
-  struct fwd_witer2d : public abstract::witer< fwd_witer2d >
-  {
-
-    typedef abstract::witer<fwd_witer2d> super_type;
-
-    fwd_witer2d(const window2d& se) :
-        super_type(se)
-    {
-      this->exact_ptr = this;
-      this->invalidate();
-    }
-
-  };
-
-} // oln
-
-#endif // OLENA_CORE_FWD_WITER2D_HH
Index: oln/core/2d/size2d.hh
===================================================================
--- oln/core/2d/size2d.hh	(revision 130)
+++ oln/core/2d/size2d.hh	(working copy)
@@ -35,7 +35,15 @@
 
 namespace oln {
 
+  // fwd decl
+  struct size2d;
 
+  // super type
+  template <>
+  struct set_super_type < size2d > { typedef abstract::size< size2d > ret; };
+
+
+
   struct size2d : public abstract::size< size2d >
   {
     size2d()
Index: oln/core/3d/array3d.hh
===================================================================
--- oln/core/3d/array3d.hh	(revision 130)
+++ oln/core/3d/array3d.hh	(working copy)
@@ -39,17 +39,13 @@
   // fwd decl
   template <typename T> struct array3d;
 
-  // category
-  template <typename T> 
-  struct set_category< array3d<T> > { typedef category::data_storage ret; };
-
   // super_type
   template <typename T> 
   struct set_super_type< array3d<T> > { typedef abstract::data_storage< array3d<T> > ret; };
   
   // props
   template <typename T>
-  struct set_props < category::data_storage, array3d<T> > : public props_of<category::data_storage>
+  struct set_props < category::data_storage, array3d<T> >
   {
     typedef size3d  size_type;
     typedef point3d point_type;
Index: oln/core/3d/image3d.hh
===================================================================
--- oln/core/3d/image3d.hh	(revision 130)
+++ oln/core/3d/image3d.hh	(working copy)
@@ -46,20 +46,13 @@
   struct fwd_piter3d;
   template <typename T> class image3d;
 
-  // category
-  template <typename T>
-  struct set_category< image3d<T> > { typedef category::image ret; };
-
   // super
   template <typename T>
-  struct set_super_type < image3d<T> >
-  {
-    typedef abstract::image_with_data< image3d<T> > ret;
-  };
+  struct set_super_type < image3d<T> > { typedef abstract::image_with_data< image3d<T> > ret; };
 
 
   template <typename T>
-  struct set_props < category::image, image3d<T> > : public props_of<category::image>
+  struct set_props < category::image, image3d<T> >
   {
     // intrusive property:
     typedef is_a<abstract::image3d> image_dimension_type;
Index: oln/core/3d/fwd_piter3d.hh
===================================================================
--- oln/core/3d/fwd_piter3d.hh	(revision 130)
+++ oln/core/3d/fwd_piter3d.hh	(working copy)
@@ -40,14 +40,9 @@
   // fwd decl
   struct fwd_piter3d;
 
-  // category
-  template <>
-  struct set_category<fwd_piter3d> { typedef category::piter ret; };
-
-
   // props
   template <>
-  struct set_props < category::piter, fwd_piter3d > : public props_of<category::piter>
+  struct set_props < category::piter, fwd_piter3d >
   {
     typedef point3d point_type;
     typedef size3d  size_type;
@@ -58,19 +53,17 @@
   struct fwd_piter3d : public abstract::piter< fwd_piter3d >
   {
 
-    typedef abstract::piter<fwd_piter3d> super_type;
+    typedef abstract::piter< fwd_piter3d > super_type;
 
     fwd_piter3d(const size3d& size) :
       super_type(size)
     {
-      this->exact_ptr = this;
       this->invalidate();
     }
 
-# if defined __GNUC__ && __GNUC__ >= 3
     friend class abstract::piter< fwd_piter3d >;
+
   protected:
-# endif
 
     void impl_start()
     {
Index: oln/core/3d/point3d.hh
===================================================================
--- oln/core/3d/point3d.hh	(revision 130)
+++ oln/core/3d/point3d.hh	(working copy)
@@ -28,28 +28,24 @@
 #ifndef OLENA_CORE_3D_POINT3D_HH
 # define OLENA_CORE_3D_POINT3D_HH
 
-# include <ostream>
+# include <iostream>
 
 # include <oln/core/abstract/point.hh>
 # include <oln/core/coord.hh>
 
 namespace oln {
 
-
+  // fwd decls
   struct point3d;
   struct dpoint3d;
 
-  // category
-  template <>
-  struct set_category< point3d > { typedef category::point ret; };
-
   // super_type
   template <>
   struct set_super_type< point3d > { typedef abstract::point< point3d > ret; };
 
   // props
   template <>
-  struct set_props < category::point, point3d > : public props_of<category::point>
+  struct set_props < category::point, point3d >
   {
     typedef dpoint3d dpoint_type;
   };
Index: oln/core/gen/image_with_nbh.hh
===================================================================
--- oln/core/gen/image_with_nbh.hh	(revision 130)
+++ oln/core/gen/image_with_nbh.hh	(working copy)
@@ -29,78 +29,61 @@
 # define OLENA_CORE_GEN_IMAGE_WITH_NBH_HH
 
 # include <oln/core/abstract/image_with_extension.hh>
-# include <oln/core/abstract/image.hh>
 # include <oln/core/abstract/neighborhood.hh>
-# include <oln/core/properties.hh>
 
 namespace oln {
 
-  // fwd decls
+  // fwd decl
+  template <typename I, typename N> struct image_with_nbh;
 
-  namespace internal {
-    template <typename I, typename N> struct image_with_nbh;
-  }
-
-  // category
-
-  template <typename I, typename N>
-  struct set_category< internal::image_with_nbh<I, N> > {
-    typedef category::image ret;
-  };
-
   // super type
-
   template <typename I, typename N>
-  struct set_super_type < internal::image_with_nbh<I, N> >
+  struct set_super_type < image_with_nbh<I, N> >
   {
-    typedef abstract::image_with_extension_ < I, internal::image_with_nbh<I, N> > ret;
+    typedef abstract::image_with_extension< I, image_with_nbh<I, N> > ret;
   };
 
   template <typename I, typename N>
-  struct set_props < category::image, internal::image_with_nbh<I, N> > : public props_of<category::image>
+  struct set_props < category::image, image_with_nbh<I, N> >
   {
     typedef is_a<abstract::image_with_nbh> image_neighbness_type;
     typedef N neighb_type;
   };
 
-  namespace internal
+  template <typename I, typename N>
+  struct image_with_nbh : public abstract::image_with_extension < I, image_with_nbh<I, N> >
   {
+    typedef image_with_nbh<I, N> self_type;
+    typedef abstract::image_with_extension < I, self_type > super_type;
 
-    template <typename I, typename N>
-    struct image_with_nbh : public oln::abstract::image_with_extension_ < I, image_with_nbh<I, N> >
+  public:
+
+    image_with_nbh(const abstract::image<I>& image,
+		   const abstract::neighborhood<N>& nbh) :
+      super_type(image),
+      nbh_(nbh.exact())
     {
-      typedef image_with_nbh<I, N> self_type;
-      typedef oln::abstract::image_with_extension_ < I, self_type > super_type;
+    }
 
-    public:
+    const N& impl_nbh_get() const
+    {
+      return nbh_;
+    }
 
-      image_with_nbh(abstract::image<I>& rhs,
-		     abstract::neighborhood<N>& nbh) :
-	super_type(rhs), nbh_(nbh.exact())
-      {
-      }
+  protected:
 
-      const N& impl_nbh_get() const
-      {
-	return nbh_;
-      }
+    N& nbh_;
+  };
 
-    protected:
-      N& nbh_;
-    };
 
-  } // end of namespace oln::internal
-
-
-
   /// the 'image_with_nbh' method for images
 
   template <typename I, typename N>
-  internal::image_with_nbh<I, N>
-  join(abstract::image<I>& ima,
-       abstract::neighborhood<N>& nbh)
+  image_with_nbh<I, N>
+  join(const abstract::image<I>& image,
+       const abstract::neighborhood<N>& nbh)
   {
-    internal::image_with_nbh<I, N> tmp(ima, nbh);
+    image_with_nbh<I, N> tmp(image, nbh);
     return tmp;
   }
 
Index: oln/basics.hh
===================================================================
--- oln/basics.hh	(revision 130)
+++ oln/basics.hh	(working copy)
@@ -50,7 +50,6 @@
 // oln::
 
 # include <oln/core/coord.hh>
-# include <oln/core/properties.hh>
 # include <oln/core/value_box.hh>
 # include <oln/core/box.hh>
 
@@ -63,14 +62,13 @@
 
 # include <oln/core/pw/all.hh>
 
-# include <oln/core/abstract/piter.hh>
-# include <oln/core/abstract/witer.hh>
-// # include <oln/core/abstract/niter.hh>
 
-# include <oln/core/abstract/struct_elt.hh>
+# include <oln/core/abstract/window.hh>
 # include <oln/core/abstract/neighborhood.hh>
 
+# include <oln/core/abstract/piter.hh>
+# include <oln/core/abstract/qiter.hh>
+# include <oln/core/abstract/niter.hh>
 
 
-
 #endif // ! OLENA_BASICS_HH
Index: oln/morpho/reconstruction.hh
===================================================================
--- oln/morpho/reconstruction.hh	(revision 130)
+++ oln/morpho/reconstruction.hh	(working copy)
@@ -37,7 +37,6 @@
 
 # include <oln/core/abstract/image_operator.hh>
 # include <oln/core/abstract/neighborhood.hh>
-# include <oln/core/properties.hh>
 
 # include <oln/level/compare.hh>
 
@@ -267,7 +266,7 @@
 	  bool exist_init()
 	  {
 	    typedef oln_type_of(N, window) se_type;
-	    oln_type_of(se_type, fwd_witer) dp(se_minus);
+	    oln_type_of(se_type, fwd_qiter) dp(se_minus);
 	    for_all (dp)
 	      {
 		q = (oln_type_of(se_type, dpoint))dp +
@@ -324,7 +323,7 @@
 		fifo.pop();
 		typedef oln_type_of(N, window) window_type;
 		window_type w = convert::nbh_to_se(this->nbh);
-		oln_type_of(window_type, fwd_witer) dp(w);
+		oln_type_of(window_type, fwd_qiter) dp(w);
 
 		for_all (dp)
 		  {
Index: oln/morpho/splitse.hh
===================================================================
--- oln/morpho/splitse.hh	(revision 130)
+++ oln/morpho/splitse.hh	(working copy)
@@ -78,7 +78,7 @@
     E
     get_plus_se_only(const abstract::struct_elt<E>& se)
     {
-      oln_type_of(E, fwd_witer) dp(se.exact());
+      oln_type_of(E, fwd_qiter) dp(se.exact());
       E out;
 
       for_all (dp)
@@ -112,7 +112,7 @@
     E
     get_plus_se_p(const abstract::struct_elt<E>& se)
     {
-      oln_type_of(E, fwd_witer) dp(se.exact());
+      oln_type_of(E, fwd_qiter) dp(se.exact());
       E out;
 
       for_all (dp)
@@ -148,7 +148,7 @@
     E
     get_minus_se_only(const abstract::struct_elt<E>& se)
     {
-      oln_type_of(E, fwd_witer) dp(se.exact());
+      oln_type_of(E, fwd_qiter) dp(se.exact());
       E out;
 
       for_all (dp)
@@ -182,7 +182,7 @@
     E
     get_minus_se_p(const abstract::struct_elt<E>& se)
     {
-      oln_type_of(E, fwd_witer) dp(se.exact());
+      oln_type_of(E, fwd_qiter) dp(se.exact());
       E out;
 
       for_all (dp)
Index: oln/morpho/stat.hh
===================================================================
--- oln/morpho/stat.hh	(revision 130)
+++ oln/morpho/stat.hh	(working copy)
@@ -68,7 +68,7 @@
           // FIXME: test dim I == dim
 	  mlc::eq<oln_type_of(I, size), oln_type_of(E, size)>::ensure();
 
-          oln_type_of(E, fwd_witer) dp(se);
+          oln_type_of(E, fwd_qiter) dp(se);
 	  dp.start();
 	  V val = input[p + dp];
           for_all_remaining (dp)
@@ -94,7 +94,7 @@
           // FIXME: test dim I == dim E
 	  mlc::eq<oln_type_of(I, size), oln_type_of(E, size)>::ensure();
 
-	  oln_type_of(E, fwd_witer) dp(se);
+	  oln_type_of(E, fwd_qiter) dp(se);
 	  dp.start();
 	  V val = input[p + dp];
 	  for_all_remaining (dp)
@@ -115,7 +115,7 @@
 	max(const I& input, const oln_type_of(I, point)& p, const E& se)
 	{
 	  mlc::eq<oln_type_of(I, size), oln_type_of(E, size)>::ensure();
-	  oln_type_of(E, fwd_witer) dp(se);
+	  oln_type_of(E, fwd_qiter) dp(se);
 	  for_all (dp)
 	    if (input.hold(p + dp))
 	      if (input[p + dp] == true)
@@ -127,7 +127,7 @@
 	min(const I& input, const oln_type_of(I, point)& p, const E& se)
 	{
 	  mlc::eq<oln_type_of(I, size), oln_type_of(E, size)>::ensure();
-	  oln_type_of(E, fwd_witer) dp(se);
+	  oln_type_of(E, fwd_qiter) dp(se);
 	  for_all (dp)
 	    if (input.hold(p + dp))
 	      if (input[p + dp] == false)
Index: oln/arith/ops.hh
===================================================================
--- oln/arith/ops.hh	(revision 130)
+++ oln/arith/ops.hh	(working copy)
@@ -60,7 +60,7 @@
 /// Operator - (unary) on image.
 
 template <typename R>
-oln::image_from_pw< oln::pw::minus< oln::pw::literal< oln_pw_value_type(R) >,
+oln::image_from_pw< oln::pw::minus< oln::pw::literal< oln_pw_type_of(R, value) >,
 				    oln::pw::image<R> > >
 operator - (const oln::abstract::image<R>& rhs)
 {
Index: oln/arith/min.hh
===================================================================
--- oln/arith/min.hh	(revision 130)
+++ oln/arith/min.hh	(working copy)
@@ -43,13 +43,6 @@
 
   }
 
-  // category
-  template <typename I>
-  struct set_category< arith::impl::min_type<I> >
-  {
-    typedef category::image ret;
-  };
-
   // super_type
   template <typename I>
   struct set_super_type< arith::impl::min_type<I> >
Index: oln/arith/max.hh
===================================================================
--- oln/arith/max.hh	(revision 130)
+++ oln/arith/max.hh	(working copy)
@@ -43,13 +43,6 @@
 
   }
 
-  // category
-  template <typename I>
-  struct set_category< arith::impl::max_type<I> >
-  {
-    typedef category::image ret;
-  };
-
   // super_type
   template <typename I>
   struct set_super_type< arith::impl::max_type<I> >
Index: oln/io/read_image.hh
===================================================================
--- oln/io/read_image.hh	(revision 130)
+++ oln/io/read_image.hh	(working copy)
@@ -35,7 +35,6 @@
 
 # include <ntg/core/macros.hh>
 
-# include <oln/core/properties.hh>
 # include <oln/io/read_image_2d_pnm.hh>
 # include <oln/io/utils.hh>
 # include <oln/io/gz_stream.hh>
