2005-07-04 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
Add 'rawness' characteristic (ability to reference data at p)
to images. Add corresponding attribute access object mechanism.
* oln/funobj/decl_attr.hh: New file.
* oln/funobj/abstract/accessor.hh: New file.
* oln/core/abstract/image_rawness.hh: New file.
* oln/core/gen/mfun.hh: New file.
* oln/core/gen/attr.hh: New file.
* oln/makefile.src: Update.
* oln/core/typedefs.hh: Update.
* oln/core/abstract/image.hh: Update.
* oln/core/abstract/image_entry.hh: Update.
* oln/core/pw/image.hh: Update.
* oln/funobj/abstract/unary.hh:
(munary::operator()): Make it more general.
* oln/core/abstract/image_neighbness.hh (impl_nbh_get()): Move
from class body to default impl.
* oln/core/abstract/data_storage.hh (at): New methods.
* oln/core/abstract/image_with_data.hh (impl_at): Likewise.
* oln/core/abstract/image_by_delegation.hh
(set_props): Add image_constness_type.
(ctors): Accept a box as input.
* oln/core/2d/array2d.hh (impl_at): New methods.
(impl_set, impl_get): Add fixme.
* oln/core/pw/unary_op.hh (ctor): Relax static check.
* oln/core/gen/image_with_nbh.hh: Add fixme.
* oln/core/gen/internal/value_box.hh: Add fixme.
* oln/morpho/dilation.hh (local): Add include.
* oln/morpho/erosion.hh (local): Add include.
(impl::erosion_): Add fixme.
* oln/morpho/thick_gradient.hh (gradient_beucher): Rename as...
(thick_gradient_beucher): ...This.
Index: ChangeLog
===================================================================
--- ChangeLog (revision 225)
+++ ChangeLog (working copy)
@@ -1,3 +1,15 @@
+2005-07-04 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
+
+ Add 'rawness' characteristic (ability to reference data at p)
+ to images. Add corresponding attribute access object mechanism.
+
+ * oln/funobj/decl_attr.hh: New file.
+ * oln/funobj/abstract/accessor.hh: New file.
+ * oln/core/abstract/image_rawness.hh: New file.
+ * oln/core/gen/mfun.hh: New file.
+ * oln/core/gen/attr.hh: New file.
+
+
2005-06-27 Christophe Berger <christophe(a)lrde.epita.fr>
* oln/appli/astro/tree_coherance_checks.hh: Remove.
Index: oln/funobj/decl_attr.hh
===================================================================
--- oln/funobj/decl_attr.hh (revision 0)
+++ oln/funobj/decl_attr.hh (revision 0)
@@ -0,0 +1,174 @@
+// 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_FUNOBJ_DECL_ATTR_HH
+# define OLENA_CORE_FUNOBJ_DECL_ATTR_HH
+
+# include <mlc/is_a.hh>
+# include <oln/funobj/abstract/accessor.hh>
+# include <oln/funobj/abstract/unary.hh>
+# include <oln/core/gen/attr.hh>
+
+
+/// Macro oln_decl_attr.
+
+# define oln_decl_attr(ATTR) \
+ \
+namespace oln \
+{ \
+ \
+ namespace a_ { \
+ \
+ struct ATTR : public f_::abstract::accessor< ATTR > \
+ { \
+ template <typename T> \
+ struct type \
+ { \
+ typedef typename T::ATTR##_type ret; \
+ }; \
+ template <typename T> \
+ typename T::ATTR##_type& operator()(T& t) const \
+ { \
+ return t.ATTR; \
+ } \
+ template <typename T> \
+ const typename T::ATTR##_type& operator()(const T& t) const \
+ { \
+ return t.ATTR; \
+ } \
+ }; \
+ \
+ } \
+ \
+ template <typename I> \
+ attr<a_::ATTR, I> a_##ATTR(abstract::image<I>& input) \
+ { \
+ mlc_is_a(I, abstract::raw_image)::ensure(); \
+ attr<a_::ATTR, I> tmp(input); \
+ return tmp; \
+ } \
+ \
+ template <typename I> \
+ attr<a_::ATTR, const I> a_##ATTR(const abstract::image<I>& input) \
+ { \
+ mlc_is_a(I, abstract::raw_image)::ensure(); \
+ attr<a_::ATTR, const I> tmp(input); \
+ return tmp; \
+ } \
+ \
+} \
+struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n
+
+
+
+
+// Dummy code for testing purpose.
+
+namespace oln
+{
+
+ namespace a_ {
+
+ struct dummy : public f_::abstract::accessor< dummy >
+ {
+ template <typename T>
+ struct type
+ {
+ typedef typename T::dummy_type ret;
+ };
+ template <typename T>
+ typename T::dummy_type& operator()(T& t) const
+ {
+ return t.dummy;
+ }
+ template <typename T>
+ const typename T::dummy_type& operator()(const T& t) const
+ {
+ return t.dummy;
+ }
+ };
+
+ } // end of namespace oln::a_
+
+
+ template <typename I>
+ attr<a_::dummy, I> a_dummy(abstract::image<I>& input)
+ {
+ mlc_is_a(I, abstract::raw_image)::ensure();
+ attr<a_::dummy, I> tmp(input);
+ return tmp;
+ }
+
+ template <typename I>
+ attr<a_::dummy, const I> a_dummy(const abstract::image<I>& input)
+ {
+ mlc_is_a(I, abstract::raw_image)::ensure();
+ attr<a_::dummy, const I> tmp(input);
+ return tmp;
+ }
+
+
+ // f_::a_dummy_<T> as a pure function
+
+ namespace f_ {
+ template <typename T> struct a_dummy_;
+ }
+
+ template <typename T>
+ struct set_super_type < f_::a_dummy_<T> > { typedef f_::abstract::unary<
f_::a_dummy_<T> > ret; };
+
+ template <typename T>
+ struct set_props < category::fun1, f_::a_dummy_<T> >
+ {
+ typedef typename T::dummy_type res_type;
+ typedef T arg_type;
+ };
+
+ namespace f_ {
+
+ template <typename T>
+ struct a_dummy_ : public oln_super_of_(f_::a_dummy_<T>)
+ {
+ const typename T::dummy_type impl_unop(const T& t) const
+ {
+ return t.dummy;
+ }
+ };
+
+ } // end of namespace oln::f_
+
+ // f_dummy as a pure meta function
+
+ typedef f_::unary_meta<f_::a_dummy_> fa_dummy_type;
+ static fa_dummy_type fa_dummy;
+
+
+} // end of namespace oln
+
+
+
+#endif // ! OLENA_CORE_FUNOBJ_DECL_ATTR_HH
Index: oln/funobj/abstract/accessor.hh
===================================================================
--- oln/funobj/abstract/accessor.hh (revision 0)
+++ oln/funobj/abstract/accessor.hh (revision 0)
@@ -0,0 +1,56 @@
+// Copyright (C) 2001, 2004, 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_FUNOBJ_ACCESSOR_HH
+# define OLENA_CORE_FUNOBJ_ACCESSOR_HH
+
+# include <mlc/any.hh>
+
+
+namespace oln {
+
+ namespace f_ {
+
+ namespace abstract {
+
+ /// Accessor.
+
+ template <typename A>
+ struct accessor : public mlc::any<A>
+ {
+ protected:
+ accessor() {}
+ };
+
+ } // end of namespace oln::f_::abstract
+
+ } // end of namespace oln::f_
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_FUNOBJ_ACCESSOR_HH
Index: oln/funobj/abstract/unary.hh
===================================================================
--- oln/funobj/abstract/unary.hh (revision 225)
+++ oln/funobj/abstract/unary.hh (working copy)
@@ -30,10 +30,19 @@
# include <mlc/any.hh>
# include <mlc/contract.hh>
+# include <mlc/if.hh>
+# include <mlc/is_a.hh>
# include <ntg/all.hh>
# include <oln/core/abstract/image.hh>
+# include <oln/core/gen/internal/value_box.hh>
+# include <oln/core/pw/abstract/function.hh>
+// FIXME: break cycling dependance due to...
+// FIXME: ...the recursive classes oln::pw::unary_op and oln::f_::abstract::munary
+// # include <oln/core/pw/unary_op.hh>
+
+
// Macros.
# define oln_fun1_type_of(Fun1Type, Alias) \
@@ -112,23 +121,116 @@
}
};
+
// munary
+ namespace internal {
+
+ // FIXME: move to internal/?
+
+ struct arg_is_a_value_box;
+ struct arg_is_a_point_wise_function;
+ struct arg_is_an_image;
+ struct arg_is_a_value;
+
+ template <typename E, typename Arg, typename arg_kind>
+ struct munary_on;
+
+ // on a value box
+ template <typename E, typename I>
+ struct munary_on <E, oln::value_box<I>, arg_is_a_value_box>
+ {
+ typedef typename munary_result<E, oln_type_of(I, value)>::ret ret;
+ static const ret exec(const E& target, const oln::value_box<I>& arg)
+ {
+ return target.impl_unop(arg.value());
+ }
+ };
+
+ // on a point-wise function
+// template <typename E, typename F>
+// struct munary_on <E, oln::pw::abstract::function<F>,
arg_is_a_point_wise_function>
+// {
+// typedef oln::pw::unary_op<E,F> ret;
+// static const ret exec(const E& target, const
oln::pw::abstract::function<F>& arg)
+// {
+// oln::pw::unary_op<E,F> tmp(arg);
+// return tmp;
+// }
+// };
+
+ // on a (regular) value
+ template <typename E, typename T>
+ struct munary_on <E, T, arg_is_a_value>
+ {
+ typedef typename munary_result<E, T>::ret ret;
+ static const ret exec(const E& target, const T& arg)
+ {
+ return target.impl_unop(arg);
+ }
+ };
+
+ // on an image
+ template <typename E, typename I>
+ struct munary_on <E, oln::abstract::image<I>, arg_is_an_image>
+ {
+ // FIXME: fake code here
+ typedef int ret;
+ static const ret exec(const E& target, const oln::abstract::image<I>&
arg)
+ {
+ return 0;
+ }
+ };
+
+ template <typename E, typename Arg>
+ struct munary_helper
+ {
+ // arg_kind
+ typedef typename
+ mlc::if_< mlc_is_a(Arg, oln::value_box),
+ arg_is_a_value_box, typename
+ mlc::if_< mlc_is_a(Arg, oln::pw::abstract::function),
+ arg_is_a_point_wise_function, typename
+ mlc::if_< mlc_is_a(Arg, oln::abstract::image),
+ arg_is_an_image,
+ arg_is_a_value
+ >::ret
+ >::ret
+ >::ret
+ arg_kind;
+ // ret
+ typedef typename munary_on<E, Arg, arg_kind>::ret ret;
+ // exec
+ static const ret exec(const E& target, const Arg& arg)
+ {
+ return munary_on<E, Arg, arg_kind>::exec(target, arg);
+ }
+ };
+
+ } // end of namespace oln::f_::abstract::internal
+
+
template <typename E>
struct munary : public mlc::any<E>
{
template <typename T>
- const typename munary_result<E,T>::ret
+ struct helper : public internal::munary_helper<E,T>
+ {
+ // using internal::munary_helper<E,T>::ret;
+ // using internal::munary_helper<E,T>::exec;
+ };
+ template <typename T>
+ const typename helper<T>::ret
operator()(const T& arg) const
{
- return this->exact().impl_unop(arg);
+ return helper<T>::exec(this->exact(), arg);
}
protected:
munary() {}
};
- } // end of namespace oln::abstract
+ } // end of namespace oln::f_::abstract
@@ -157,6 +259,7 @@
static F<T> f;
return f(arg);
}
+
};
Index: oln/core/typedefs.hh
===================================================================
--- oln/core/typedefs.hh (revision 225)
+++ oln/core/typedefs.hh (working copy)
@@ -101,6 +101,7 @@
mlc_decl_typedef(image_dimension_type);
mlc_decl_typedef(image_typeness_type);
mlc_decl_typedef(image_valuedness_type);
+ mlc_decl_typedef(image_rawness_type);
// extension in image_operators
mlc_decl_typedef(output_type);
Index: oln/core/abstract/image.hh
===================================================================
--- oln/core/abstract/image.hh (revision 225)
+++ oln/core/abstract/image.hh (working copy)
@@ -48,9 +48,9 @@
{
template <typename I> class image_without_nbh;
template <typename I> class readonly_image;
+ template <typename I> class raw_image;
}
-
namespace category
{
struct image;
@@ -81,6 +81,7 @@
typedef is_a<abstract::image_without_nbh> image_neighbness_type;
typedef is_a<abstract::readonly_image> image_constness_type;
+ typedef mlc::undefined_type image_rawness_type;
typedef mlc::undefined_type image_dimension_type;
//...
@@ -112,6 +113,7 @@
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_rawness) image_rawness_type;
typedef oln_type_of(I, image_dimension) image_dimension_type;
//...
@@ -139,6 +141,7 @@
<< "\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_rawness_type = " <<
mlc_to_string(image_rawness_type) << std::endl
<< "\t image_dimension_type = " <<
mlc_to_string(image_dimension_type) << std::endl
<< "}" << std::endl;
@@ -162,6 +165,7 @@
mlc::is_ok< image_neighbness_type >::ensure();
mlc::is_ok< image_constness_type >::ensure();
+ mlc::is_ok< image_rawness_type >::ensure();
mlc::is_ok< image_dimension_type >::ensure();
}
};
Index: oln/core/abstract/image_rawness.hh
===================================================================
--- oln/core/abstract/image_rawness.hh (revision 0)
+++ oln/core/abstract/image_rawness.hh (revision 0)
@@ -0,0 +1,137 @@
+// 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_RAWNESS_HH
+# define OLENA_CORE_ABSTRACT_IMAGE_RAWNESS_HH
+
+# include <oln/core/abstract/image.hh>
+
+
+// image
+//
+// ^
+// |
+// ---------------
+// | |
+//
+// raw_image ...
+
+
+
+/*! \namespace oln
+** \brief oln namespace.
+*/
+namespace oln {
+
+
+ /*! \namespace oln::abstract
+ ** \brief oln::abstract namespace.
+ */
+ namespace abstract {
+
+
+
+
+ /*! \class abstract::raw_image<E>
+ **
+ ** Class of images whose data are read-only.
+ */
+
+
+ template <typename E>
+ struct raw_image : public virtual image<E>,
+ public internal::get_image_impl < raw_image<E>, E >
+ {
+ public:
+
+ typedef oln_type_of(E, point) point_type;
+ typedef oln_type_of(E, value_storage) value_storage_type;
+
+ value_storage_type& at(const point_type& p)
+ {
+# ifdef OLNTRACE
+ inc_ncalls("set", *this);
+# endif // ! OLNTRACE
+ return this->exact().impl_at(p);
+ }
+
+ const value_storage_type& at(const point_type& p) const
+ {
+# ifdef OLNTRACE
+ inc_ncalls("get", *this);
+# endif // ! OLNTRACE
+ return this->exact().impl_at(p);
+ }
+
+ protected:
+
+ /*! \brief Constructor (protected, empty).
+ */
+ raw_image() {}
+ };
+
+
+ template <typename E>
+ struct not_raw_image : public virtual image<E>
+ {
+ protected:
+ not_raw_image() {}
+ };
+
+
+
+ namespace internal {
+
+ template <typename E>
+ struct set_image_impl < raw_image<E>, E> : public virtual
image_impl<E>
+ {
+ /// typedefs
+ typedef typename image_impl<E>::D D;
+ typedef oln_type_of(D, point) point_type;
+ typedef oln_type_of(D, value_storage) value_storage_type;
+
+ value_storage_type& at(const point_type& p)
+ {
+ return this->delegate().at(p);
+ }
+
+ const value_storage_type& at(const point_type& p) const
+ {
+ return this->delegate().at(p);
+ }
+ };
+
+ } // end of namespace oln::abstract::internal
+
+
+
+ } // end of namespace oln::abstract
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_ABSTRACT_IMAGE_RAWNESS_HH
Index: oln/core/abstract/image_neighbness.hh
===================================================================
--- oln/core/abstract/image_neighbness.hh (revision 225)
+++ oln/core/abstract/image_neighbness.hh (working copy)
@@ -42,30 +42,25 @@
template <typename E>
- struct image_with_nbh : public virtual image<E>
+ struct image_with_nbh : public virtual image<E>,
+ public internal::get_image_impl < image_with_nbh<E>, E >
{
public:
typedef oln_type_of(E, neighb) neighb_type;
- const neighb_type& nbh_get() const // FIXME: rename (?)
+ const neighb_type& nbh_get() const // FIXME: rename
{
return this->exact().impl_nbh_get();
}
- //FIXME: is it the right way ?
- const neighb_type& impl_nbh_get() const
- {
- return this->exact().delegate().nbh_get();
- }
-
protected:
image_with_nbh() {}
~image_with_nbh()
{
-// mlc_check_method_impl(E, const neighb_type&, nbh_get, , const);
+// mlc_check_method_impl(E, const neighb_type&, nbh, , const);
}
};
@@ -78,6 +73,24 @@
};
+
+ namespace internal {
+
+ template <typename E>
+ struct set_image_impl < image_with_nbh<E>, E> : public virtual
image_impl<E>
+ {
+ typedef typename image_impl<E>::D D;
+ typedef oln_type_of(D, neighb) neighb_type;
+
+ const neighb_type& impl_nbh_get() const
+ {
+ return this->exact().delegate().nbh_get();
+ }
+ };
+
+ } // end of namespace oln::abstract::internal
+
+
} // end of namespace oln::abstract
} // end of namespace oln
Index: oln/core/abstract/data_storage.hh
===================================================================
--- oln/core/abstract/data_storage.hh (revision 225)
+++ oln/core/abstract/data_storage.hh (working copy)
@@ -140,7 +140,7 @@
return this->exact().impl_hold(p);
}
- const data_type get(const point_type& p) const
+ const data_type get(const point_type& p) const // FIXME: remove (obsolete)
{
precondition(this->has_data());
precondition(this->hold_large(p));
@@ -150,7 +150,7 @@
return this->exact().impl_get(p);
}
- void set(const point_type& p, const data_type& v)
+ void set(const point_type& p, const data_type& v) // FIXME: remove
(obsolete)
{
precondition(this->has_data());
precondition(this->hold_large(p));
@@ -160,15 +160,26 @@
this->exact().impl_set(p, v);
}
+ const data_type& at(const point_type& p) const
+ {
+ precondition(this->has_data());
+ precondition(this->hold_large(p));
+# ifdef OLNTRACE
+ inc_ncalls("data_get", *this);
+# endif // ! OLNTRACE
+ return this->exact().impl_at(p);
+ }
- // FIXME: commented below cause unused...
-// void set_data(const data_type& v)
-// {
-// precondition(this->has_data());
-// this->exact().impl_set_data(v);
-// }
+ data_type& at(const point_type& p)
+ {
+ precondition(this->has_data());
+ precondition(this->hold_large(p));
+# ifdef OLNTRACE
+ inc_ncalls("data_set", *this);
+# endif // ! OLNTRACE
+ return this->exact().impl_at(p);
+ }
-
// polymorphic method with default
bool hold_large(const point_type& p) const
@@ -198,7 +209,8 @@
mlc_check_method_impl(E, unsigned long, npoints, ,
const);
mlc_check_method_impl(E, bool, hold, const point_type&, const);
mlc_check_method_impl(E, const data_type, get, const point_type&, const);
- mlc_check_method_impl(E, void, set_data, const data_type&, );
+ mlc_check_method_impl(E, const data_type&, at, const point_type&,
const);
+ mlc_check_method_impl(E, data_type&, at, const point_type&,
);
mlc_check_method_impl(E, bool, hold_large, const point_type&, const);
mlc_check_method_impl_2(E, void, resize_border, size_t, bool, );
mlc_check_method_impl_2(E, void, set, const point_type&, const
data_type&, );
Index: oln/core/abstract/image_entry.hh
===================================================================
--- oln/core/abstract/image_entry.hh (revision 225)
+++ oln/core/abstract/image_entry.hh (working copy)
@@ -33,6 +33,7 @@
# include <oln/core/abstract/image_neighbness.hh>
# include <oln/core/abstract/image_typeness.hh>
# include <oln/core/abstract/image_valuedness.hh>
+# include <oln/core/abstract/image_rawness.hh>
@@ -58,6 +59,7 @@
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 oln_type_of_(E, image_rawness) ::template instantiated_with<E>::ret,
// ...
public typeness::inheritance_switch<E>,
public valuedness::inheritance_switch<E>
Index: oln/core/abstract/image_with_data.hh
===================================================================
--- oln/core/abstract/image_with_data.hh (revision 225)
+++ oln/core/abstract/image_with_data.hh (working copy)
@@ -55,6 +55,7 @@
{
// intrusive property:
typedef is_a<abstract::readwrite_image> image_constness_type;
+ typedef is_a<abstract::raw_image> image_rawness_type;
typedef E concrete_type;
};
@@ -84,6 +85,7 @@
typedef oln_type_of(E, size) size_type;
typedef oln_type_of(E, point) point_type;
typedef oln_type_of(E, value) value_type;
+ typedef oln_type_of(E, value_storage) value_storage_type;
typedef oln_type_of(E, storage) storage_type;
@@ -190,6 +192,15 @@
(const_cast<storage_type&>(*this->data_)).resize_border(new_border,
copy_border);
}
+ value_storage_type& impl_at(const point_type& p)
+ {
+ return this->data_->at(p);
+ }
+
+ const value_storage_type& impl_at(const point_type& p) const
+ {
+ return this->data_->at(p);
+ }
protected:
Index: oln/core/abstract/image_by_delegation.hh
===================================================================
--- oln/core/abstract/image_by_delegation.hh (revision 225)
+++ oln/core/abstract/image_by_delegation.hh (working copy)
@@ -54,6 +54,7 @@
: public get_props< category::image, I >
{
typedef I delegated_type;
+ // FIXME: what about storage_type?
};
template <typename I, typename E>
@@ -61,6 +62,8 @@
: public get_props< category::image, I >
{
typedef I delegated_type;
+ typedef is_a<abstract::readonly_image> image_constness_type;
+ // FIXME: what about storage_type?
};
@@ -80,12 +83,20 @@
this->exact_ptr = (E*)(void*)(this);
}
+ // FIXME: this ctor should be removed.
image_by_delegation(abstract::image<I>& image) :
image_(image.exact())
{
this->exact_ptr = (E*)(void*)(this);
}
+ /// Ctor with an image (in a box).
+ image_by_delegation(box<I> image) :
+ image_(image)
+ {
+ this->exact_ptr = (E*)(void*)(this);
+ }
+
image_by_delegation(const image_by_delegation& rhs) :
image_(rhs.image_)
{
@@ -122,12 +133,20 @@
this->exact_ptr = (E*)(void*)(this);
}
+ // FIXME: this ctor should be removed.
image_by_delegation(const abstract::image<I>& ima) :
image_(ima.exact())
{
this->exact_ptr = (E*)(void*)(this);
}
+ /// Ctor with an image (in a box).
+ image_by_delegation(box<const I> image) :
+ image_(image)
+ {
+ this->exact_ptr = (E*)(void*)(this);
+ }
+
image_by_delegation(const image_by_delegation& rhs) :
image_(rhs.image())
{
Index: oln/core/2d/array2d.hh
===================================================================
--- oln/core/2d/array2d.hh (revision 225)
+++ oln/core/2d/array2d.hh (working copy)
@@ -201,18 +201,30 @@
p.col() < size_.ncols() + size_.border();
}
- const T impl_get(const point2d& p) const
+ const T impl_get(const point2d& p) const // FIXME: remove (obsolete)
{
invariant_();
return array_[p.row()][p.col()];
}
- void impl_set(const point2d& p, const T& v)
+ void impl_set(const point2d& p, const T& v) // FIXME: remove (obsolete)
{
invariant_();
array_[p.row()][p.col()] = v;
}
+ const T& impl_at(const point2d& p) const
+ {
+ invariant_();
+ return array_[p.row()][p.col()];
+ }
+
+ T& impl_at(const point2d& p)
+ {
+ invariant_();
+ return array_[p.row()][p.col()];
+ }
+
// FIXME: should be impl_ here; and call should be defined in storage_type
template <typename T2, typename A, typename V>
void call(const point2d& p,
Index: oln/core/pw/image.hh
===================================================================
--- oln/core/pw/image.hh (revision 225)
+++ oln/core/pw/image.hh (working copy)
@@ -61,6 +61,8 @@
// FIXME: EXTREMELY AWFUL!!! we do not know if it is 2d...
typedef is_a<abstract::image2d> image_dimension_type;
+ typedef is_a<abstract::readonly_image> image_constness_type;
+ typedef is_a<abstract::not_raw_image> image_rawness_type;
typedef grid2d grid_type;
typedef fwd_piter2d piter_type;
Index: oln/core/pw/unary_op.hh
===================================================================
--- oln/core/pw/unary_op.hh (revision 225)
+++ oln/core/pw/unary_op.hh (working copy)
@@ -68,7 +68,8 @@
super_type(arg),
fun()
{
- mlc_is_a(F, f_::unary_meta)::ensure();
+ mlc_is_a(F, f_::abstract::munary)::ensure();
+// mlc_is_a(F, f_::unary_meta)::ensure();
}
typedef oln_pw_type_of(self_type, point) point_type;
Index: oln/core/gen/image_with_nbh.hh
===================================================================
--- oln/core/gen/image_with_nbh.hh (revision 225)
+++ oln/core/gen/image_with_nbh.hh (working copy)
@@ -149,6 +149,9 @@
return tmp;
}
+ // FIXME: add the 'const' version...
+
+
} // end of namespace oln
Index: oln/core/gen/mfun.hh
===================================================================
--- oln/core/gen/mfun.hh (revision 0)
+++ oln/core/gen/mfun.hh (revision 0)
@@ -0,0 +1,122 @@
+// 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_GEN_MFUN_HH
+# define OLENA_CORE_GEN_MFUN_HH
+
+# include <oln/core/abstract/image_by_delegation.hh>
+# include <oln/core/ch_value_type.hh>
+# include <oln/funobj/abstract/unary.hh>
+# include <oln/utils/record.hh>
+
+
+
+namespace oln {
+
+ // fwd decl
+ template <typename F, typename I> struct mfun;
+
+ // super type
+ template <typename F, typename I>
+ struct set_super_type < mfun<F, I> >
+ {
+ typedef abstract::image_by_delegation< const I, mfun<F, I> > ret;
+ };
+
+ // set props
+ template <typename F, typename I>
+ struct set_props < category::image, mfun<F, I> >
+ {
+ typedef is_a<abstract::not_raw_image> image_rawness_type;
+
+ typedef oln_type_of(I, value) I_value_type;
+ typedef typename f_::munary_result<F, I_value_type>::ret value_type;
+ typedef oln_ch_concrete_type(I, value_type) concrete_type;
+
+ typedef mlc::no_type value_storage_type;
+ typedef mlc::no_type storage_type; // FIXME: senseless?
+ };
+
+
+ template <typename F, typename I>
+ struct mfun : public abstract::image_by_delegation < const I, mfun<F, I> >
+ {
+ typedef mfun<F, I> self_type;
+ typedef abstract::image_by_delegation < const I, self_type > super_type;
+
+ typedef oln_type_of(self_type, point) point_type;
+ typedef oln_type_of(self_type, value) value_type;
+
+ public:
+
+ mfun()
+ {
+ }
+
+ mfun(box<const I> image) :
+ super_type(image)
+ {
+ }
+
+ mfun(box<const I> image, F f) :
+ super_type(image),
+ f(f)
+ {
+ }
+
+ mfun(box<const I> image, const std::string& name) :
+ super_type(image)
+ {
+ registering(*this, name);
+ }
+
+ mfun(box<const I> image, F f, const std::string& name) :
+ super_type(image),
+ f(f)
+ {
+ registering(*this, name);
+ }
+
+ // get
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return f(this->delegate().get(p));
+ }
+
+ // FIXME: what about the methods "call(*)"?
+
+ protected:
+
+ F f;
+ };
+
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_GEN_MFUN_HH
Index: oln/core/gen/attr.hh
===================================================================
--- oln/core/gen/attr.hh (revision 0)
+++ oln/core/gen/attr.hh (revision 0)
@@ -0,0 +1,125 @@
+// 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_GEN_ATTR_HH
+# define OLENA_CORE_GEN_ATTR_HH
+
+# include <oln/core/abstract/image_by_delegation.hh>
+# include <oln/core/ch_value_type.hh>
+# include <oln/utils/record.hh>
+
+
+namespace oln {
+
+ // fwd decl
+ template <typename A, typename I> struct attr;
+
+ // super type
+ template <typename A, typename I>
+ struct set_super_type < attr<A, I> >
+ {
+ typedef abstract::image_by_delegation< I, attr<A, I> > ret;
+ };
+
+ // set props
+ template <typename A, typename I>
+ struct set_props < category::image, attr<A, I> >
+ {
+ typedef oln_type_of(I, value_storage) I_value_storage;
+
+ typedef typename A::template type<I_value_storage>::ret value_type;
+ typedef value_type value_storage_type;
+ typedef oln_ch_concrete_type(I, value_type) concrete_type;
+
+ typedef mlc::no_type storage_type; // FIXME: senseless?
+ };
+
+
+ template <typename A, typename I>
+ struct attr : public abstract::image_by_delegation < I, attr<A, I> >
+ {
+ typedef attr<A, I> self_type;
+ typedef abstract::image_by_delegation < I, self_type > super_type;
+
+ typedef oln_type_of(self_type, point) point_type;
+ typedef oln_type_of(self_type, value) value_type;
+ typedef oln_type_of(self_type, value_storage) value_storage_type;
+
+ public:
+
+ attr()
+ {
+ }
+
+ attr(box<I> image) :
+ super_type(image)
+ {
+ mlc_is_a(I, abstract::raw_image)::ensure();
+ }
+
+ attr(box<I> image, const std::string& name) :
+ super_type(image)
+ {
+ registering(*this, name);
+ }
+
+ // .at(p)
+
+ value_storage_type& impl_at(const point_type& p)
+ {
+ return a_of(this->delegate().at(p));
+ }
+
+ const value_storage_type& impl_at(const point_type& p) const
+ {
+ return a_of(this->delegate().at(p));
+ }
+
+ // get/set
+
+ void impl_set(const point_type& p, const value_type& v)
+ {
+ a_of(this->delegate().at(p)) = v;
+ }
+
+ const value_type impl_get(const point_type& p) const
+ {
+ return a_of(this->delegate().get(p));
+ }
+
+ // FIXME: what about the methods "call(*)"?
+
+ protected:
+
+ A a_of;
+ };
+
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CORE_GEN_ATTR_HH
Index: oln/core/gen/internal/value_box.hh
===================================================================
--- oln/core/gen/internal/value_box.hh (revision 225)
+++ oln/core/gen/internal/value_box.hh (working copy)
@@ -33,6 +33,7 @@
# include <oln/core/abstract/image.hh>
+// FIXME: not coherent cause in internal/ but not internal::
/*! \namespace oln
Index: oln/makefile.src
===================================================================
--- oln/makefile.src (revision 225)
+++ oln/makefile.src (working copy)
@@ -79,6 +79,7 @@
core/abstract/image_like_.hh \
core/abstract/image_neighbness.hh \
core/abstract/image_operator.hh \
+ core/abstract/image_rawness.hh \
core/abstract/image_typeness.hh \
core/abstract/image_valuedness.hh \
core/abstract/image_with_data.hh \
@@ -105,9 +106,11 @@
core/compose.hh \
core/coord.hh \
\
+ core/gen/attr.hh \
core/gen/identity.hh \
core/gen/image_with_nbh.hh \
core/gen/internal/value_box.hh \
+ core/gen/mfun.hh \
core/gen/regular_bkd_niter.hh \
core/gen/regular_bkd_qiter.hh \
core/gen/regular_fwd_niter.hh \
@@ -138,11 +141,13 @@
fancy/iota.hh \
fancy/print.hh \
\
+ funobj/abstract/accessor.hh \
funobj/abstract/binary.hh \
funobj/abstract/unary.hh \
funobj/accum.hh \
funobj/arith.hh \
funobj/cmp.hh \
+ funobj/decl_attr.hh \
funobj/infsup.hh \
funobj/invert.hh \
funobj/logic.hh \
Index: oln/morpho/dilation.hh
===================================================================
--- oln/morpho/dilation.hh (revision 225)
+++ oln/morpho/dilation.hh (working copy)
@@ -32,6 +32,7 @@
# include <oln/utils/record.hh>
# include <oln/basics.hh>
+# include <oln/morpho/local.hh>
# include <oln/core/2d/window2d.hh>
Index: oln/morpho/erosion.hh
===================================================================
--- oln/morpho/erosion.hh (revision 225)
+++ oln/morpho/erosion.hh (working copy)
@@ -32,6 +32,7 @@
# include <oln/utils/record.hh>
# include <oln/basics.hh>
+# include <oln/morpho/local.hh>
# include <oln/core/2d/window2d.hh>
@@ -62,6 +63,8 @@
registering(input, "input");
oln_type_of(I, concrete) output(input.size(), "output");
+ // FIXME: the use of .info() instead of .size() above would allow to create
+ // output with the proper neighborhood if input is an image_with_nbh...
oln_type_of(I, fwd_piter) p(input.size());
for_all_p (p)
Index: oln/morpho/thick_gradient.hh
===================================================================
--- oln/morpho/thick_gradient.hh (revision 225)
+++ oln/morpho/thick_gradient.hh (working copy)
@@ -30,8 +30,6 @@
# include <oln/morpho/dilation.hh>
# include <oln/morpho/erosion.hh>
-# include <oln/morpho/elementary_dilation.hh>
-# include <oln/morpho/elementary_erosion.hh>
# include <oln/morpho/temp.hh>
@@ -43,8 +41,8 @@
/// Beucher thick gradient.
template<typename I, typename W>
- oln_type_of(I, concrete) gradient_beucher(const abstract::image<I>& input,
- const abstract::window<W>& win)
+ oln_type_of(I, concrete) thick_gradient_beucher(const abstract::image<I>&
input,
+ const abstract::window<W>& win)
{
mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();