- Olena-patches

687: Fix the distribution (Metalic).
by Roland Levillain 27 Oct '06

27 Oct '06

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix the distribution. * mlc/basic.hh: Fix dates in copyright notice. * mlc/Makefile.am (nobase_mlc_HEADERS): Add basic.hh. Makefile.am | 1 + basic.hh | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) Index: mlc/basic.hh --- mlc/basic.hh (revision 686) +++ mlc/basic.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 EPITA Research and Development Laboratory +// Copyright (C) 2006 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 Index: mlc/Makefile.am --- mlc/Makefile.am (revision 686) +++ mlc/Makefile.am (working copy) @@ -5,6 +5,7 @@ nobase_mlc_HEADERS = \ abort.hh \ assert.hh \ + basic.hh \ bexpr.hh \ bool.hh \ case.hh \

1 0

686: Fix the distribution (Extended).
by Roland Levillain 27 Oct '06

27 Oct '06

https://svn.lrde.epita.fr/svn/oln/trunk/extended Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix the distribution. * xtd/Makefile.am (nobase_xtd_HEADERS): Add math/ops.hh. Makefile.am | 1 + 1 file changed, 1 insertion(+) Index: xtd/Makefile.am --- xtd/Makefile.am (revision 685) +++ xtd/Makefile.am (working copy) @@ -38,6 +38,7 @@ math/log.hh \ math/log10.hh \ math/logic.hh \ + math/ops.hh \ math/pow.hh \ math/sin.hh \ math/sinh.hh \

1 0

685: Extend morpher adding a look-up table (oln::morpher::with_lut).
by Roland Levillain 26 Oct '06

26 Oct '06

https://svn.lrde.epita.fr/svn/oln/trunk/olena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Extend morpher adding a look-up table (oln::morpher::with_lut). * oln/core/abstract/image/hierarchies.hh (image_hierarchy_wrt_value_wise_accessibility): New hierarchy. (image_hybrid_hierarchy_wrt_classical) (image_hierarchy_wrt_value, image_hierarchy_wrt_data_retrieval): Adjust numbers. * oln/core/abstract/image/all.hh (oln/core/abstract/image/value_wise_accessibility/hierarchy.hh): Include it. Adjust. * oln/core/abstract/image/value_wise_accessibility/hierarchy.hh: New. * oln/core/automatic/image/image_being_value_wise_random_accessible.hh: New. * oln/core/internal/fwd_viter_lut.hh, * oln/core/gen/fwd_viter_lut.hh: New. * oln/core/typedefs.hh (fwd_viter_type, mutable_fwd_viter_type) (lut_type, lut_iter_type): New virtual types declarations. * oln/core/lookup_table.hh (lookup_table): Rename the first two parameters to Orig_Value and New_Value. Add two parameters Orig_Value_Compare and New_Value_Compare, defaulting to std::less<Orig_Value> and std::less<New_Value> respectively. (lookup_table::key_type, lookup_table::data_type): Rename typedefs as... (lookup_table::orig_value_type, lookup_table::new_value_type): ...these. (lookup_table::map_type): Remove typedef. (lookup_table::orig_value_type, lookup_table::new_value_type) (lookup_table::const_iterator, lookup_table::iterator): New typedefs. Adjust signatures of methods. (lookup_table::map): Remove method. (lookup_table::begin, lookup_table::end, lookup_table::find) (lookup_table::orig_to_new_map, lookup_table::new_to_orig_map): New methods. (lookup_table::map_): Remove attributes. (lookup_table::orig_to_new_map_, lookup_table::new_to_orig_map_): New attributes. (lookup_table::add): Adjust method. * oln/morpher/with_lut.hh: Adjust. (single_vtype<morpher::with_lut<Image, Lut>, typedef_::fwd_viter_type>) (single_vtype<morpher::with_lut<Image ,Lut>, typedef_::mutable_fwd_viter_type>): New. (with_lut::lut_t, with_lut::value_t, with_lut::rvalue_t) (with_lut::psite_t): Rename typedefs as... (with_lut::lut_type, with_lut::value_type, with_lut::rvalue_type) (with_lut::psite_type): ...these. Adjust. (with_lut::fwd_viter_type, with_lut::mutable_fwd_viter_type): New typedefs. (with_lut::impl_value): New methods. (operator+ (const abstract::image&, const lookup_table<K, D>&)): Turn into... (operator+ (const abstract::image&, lookup_table<K, D>&)): ...this. Adjust. * tests/morphers/with_lut.cc: Augment this test. * oln/value/color/rgb.hh (rgb_<T>::operator==(const rgb_&)): New operator. * TODO: New. TODO | 23 oln/core/abstract/image/all.hh | 6 oln/core/abstract/image/hierarchies.hh | 7 oln/core/abstract/image/value_wise_accessibility/hierarchy.hh | 154 +++++ oln/core/automatic/image/image_being_value_wise_random_accessible.hh | 104 +++ oln/core/gen/fwd_viter_lut.hh | 302 ++++++++++ oln/core/internal/fwd_viter_lut.hh | 171 +++++ oln/core/iterator_vtypes.hh | 2 oln/core/lookup_table.hh | 185 ++++-- oln/core/typedefs.hh | 15 oln/morpher/slice.hh | 5 oln/morpher/with_lut.hh | 101 ++- oln/value/color/rgb.hh | 14 tests/morphers/with_lut.cc | 106 ++- 14 files changed, 1093 insertions(+), 102 deletions(-) Index: tests/morphers/with_lut.cc --- tests/morphers/with_lut.cc (revision 684) +++ tests/morphers/with_lut.cc (working copy) @@ -34,17 +34,65 @@ #include <oln/debug/print.hh> -// FIXME: Remove. -using namespace oln; - +// A simple (fake) routine. template <typename I> void image_test(const oln::abstract::image&) { // Do nothing. } + +/*--------------------------------------------------------------. +| Equipment of the new value type of the look-up table (rgb8). | +`--------------------------------------------------------------*/ + oln::value::color::rgb8 white(255, 255, 255); oln::value::color::rgb8 blue ( 0, 0, 255); +oln::value::color::rgb8 red (255, 0, 0); + +// We don't want to equip rgb8 with an operator<, nor to specialize +// std::less, so we pass the functor rgb8_less_t as fourth parameter +// of the look-up table. +xtd::lexi_less_t lexi_less; +struct rgb8_less_t +{ + bool operator()(const oln::value::color::rgb8& lhs, + const oln::value::color::rgb8& rhs) const + { + return lexi_less(lhs.to_vec(), rhs.to_vec()); + } +}; + +// FIXME: Move this elsewhere? +namespace oln +{ + std::ostream& + operator<< (std::ostream& ostr, value::color::rgb8 val) + { + // The static_cast are needed because components of rgb8 are + // unsigned chars, printed as a classic chars. + ostr << "(" + << static_cast<int>(val.red()) << ", " + << static_cast<int>(val.green()) << ", " + << static_cast<int>(val.blue()) + << ")"; + return ostr; + } + +} // end of namespace oln + + +/*---------------------. +| Look-up table type. | +`---------------------*/ + +typedef oln::lookup_table< unsigned, oln::value::color::rgb8, + std::less<unsigned>, rgb8_less_t > lut_t; + + +/*-------. +| Test. | +`-------*/ int main() { @@ -52,45 +100,53 @@ unsigned data[] = { 0, 1, 2, 0, 1, 2, 0, 1, 2}; - typedef image2d<unsigned> image_t; + typedef oln::image2d<unsigned> image_t; image_t ima(3, 3); - level::fill(ima, data); - debug::print(ima); + oln::level::fill(ima, data); + oln::debug::print(ima); - typedef lookup_table<unsigned, rgb8> lut_t; lut_t lut; rgb8 c(16, 6, 4); lut. add(0, blue). add(1, white). add(2, c); - std::cout << lut << std::endl; - typedef morpher::with_lut<image_t, lut_t> lutimage_t; - lutimage_t ima2 = ima + lut; + typedef oln::morpher::with_lut<image_t, lut_t> image_with_lut_t; + // FIXME: ``ima + lut'' doesn't work. Maybe a `using' statement is + // required. + image_with_lut_t ima_with_lut(ima, lut); + +#if 0 + // Disable the display to speed up the test. + std::cout << "lut = " << std::endl << ima_with_lut.lut() << std::endl; + oln::debug::print(ima_with_lut); + std::cout << std::endl; +#endif - // ima2 is an image, and can be as argument to to image routines. - image_test(ima2); + image_test(ima_with_lut); - // FIXME: To be enabled later. #if 0 - // it is value-wise accessible: - ima2.value(c) = red; + std::cout << ima_with_lut.value(c) << std::endl; #endif - // let's look at it - debug::print(ima2); + // Change a value in the LUT. + ima_with_lut.value(c) = red; + +#if 0 + // Disable the display to speed up the test. + std::cout << "lut = " << std::endl << ima_with_lut.lut() << std::endl; + oln::debug::print(ima_with_lut); std::cout << std::endl; +#endif - // it is a 2D image so we have: - point2d p(1, 1); - std::cout << "ima2(p) =" << ima2(p) << std::endl; - // or (likewise): - std::cout << "ima2.at(1, 1) =" << ima2.at(1, 1) << std::endl; + oln::point2d p(1, 2); + assert(ima_with_lut(p) == red); + assert(ima_with_lut.at(1, 2) == red); - // FIXME: To be enabled later. + // FIXME: To be enabled later, when oln::level::fill is specialized + // for abstract::mutable_image_being_value_wise_random_accessible. #if 0 - // FIXME... - level::apply(ima2, fun); // 3 ops only !!! + oln::level::apply(ima_with_lut, fun); // 3 ops only !!! #endif } Index: TODO --- TODO (revision 0) +++ TODO (revision 0) @@ -0,0 +1,23 @@ +* Renaming + +** point_accessibility + +Rename oln/core/abstract/image/accessibility +into oln/core/abstract/image/point_wise_accessibility; +rename structures as well, and adjust clients. + +** lvalue vs wvalue + +Rename lvalue (``left value'') as wvalue (``writable value'')? +(Recall that rvalue can stand for either ``right-value'' or ``readable +value'', even if the latter makes more sense). + +Or even, rename rvalue and lvalue as ro_value (read-only) and rw_value +(read-write). + + + +Local Variables: +mode: outline +ispell-local-dictionary: "american" +End: Index: oln/core/typedefs.hh --- oln/core/typedefs.hh (revision 684) +++ oln/core/typedefs.hh (working copy) @@ -90,6 +90,7 @@ // mlc_decl_typedef(iter_type); // mlc_decl_typedef(fwd_iter_type); // mlc_decl_typedef(bkd_iter_type); +// -------------------------------------------------------------------- mlc_decl_typedef(piter_type); mlc_decl_typedef(fwd_piter_type); @@ -102,7 +103,11 @@ mlc_decl_typedef(niter_type); mlc_decl_typedef(fwd_niter_type); mlc_decl_typedef(bkd_niter_type); -// -------------------------------------------------------------------- + + mlc_decl_typedef(fwd_viter_type); + mlc_decl_typedef(mutable_fwd_viter_type); + // FIXME: bkd_viter_type. + // FIXME: mutable_bkd_viter_type. /*----------------------. @@ -189,6 +194,14 @@ mlc_decl_typedef(vec_type); + /*-------------------------. + | category::lookup_table. | + `-------------------------*/ + + mlc_decl_typedef(lut_type); + mlc_decl_typedef(lut_iter_type); + + /*------------------------------------. | category::fun1 and category::fun2. | `------------------------------------*/ Index: oln/core/automatic/image/image_being_value_wise_random_accessible.hh --- oln/core/automatic/image/image_being_value_wise_random_accessible.hh (revision 0) +++ oln/core/automatic/image/image_being_value_wise_random_accessible.hh (revision 0) @@ -0,0 +1,104 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_CORE_AUTOMATIC_IMAGE_IMAGE_BEING_VALUE_WISE_RANDOM_ACCESSIBLE_HH +# define OLN_CORE_AUTOMATIC_IMAGE_IMAGE_BEING_VALUE_WISE_RANDOM_ACCESSIBLE_HH + +# include <oln/core/automatic/impl.hh> +# include <oln/morpher/tags.hh> + + +namespace oln +{ + + // Forward declaration. + namespace abstract + { + template <typename E> class image_being_value_wise_random_accessible; + template <typename E> class mutable_image_being_value_wise_random_accessible; + + } // end of namespace oln::abstract + + + namespace automatic + { + + /// Default implementation corresponding to the interface + /// oln::abstract::image_being_value_wise_random_accessible. + template <typename E, typename M> + class set_impl<abstract::image_being_value_wise_random_accessible, M, E> : + public virtual stc::any__simple<E> + { + public: + typedef oln_type_of(E, value) value_type; + typedef oln_type_of(E, fwd_viter) fwd_viter_type; + + public: + fwd_viter_type impl_value(const value_type& v) const; + }; + + + /// Default implementation corresponding to the interface + /// oln::abstract::mutable_image_being_value_wise_random_accessible. + template <typename E, typename M> + class set_impl<abstract::mutable_image_being_value_wise_random_accessible, + M, E> : + public virtual stc::any__simple<E> + { + public: + typedef oln_type_of(E, value) value_type; + typedef oln_type_of(E, fwd_viter) fwd_viter_type; + + public: + fwd_viter_type impl_value(const value_type& v); + }; + + + +# ifndef OLN_INCLUDE_ONLY + + template <typename E, typename M> + typename set_impl<abstract::image_being_value_wise_random_accessible, M, E>::fwd_viter_type + set_impl<abstract::image_being_value_wise_random_accessible, M, E>::impl_value(const typename set_impl<abstract::image_being_value_wise_random_accessible, M, E>::value_type& v) const + { + return this->exact().delegate().value(v); + } + + template <typename E, typename M> + typename set_impl<abstract::mutable_image_being_value_wise_random_accessible, M, E>::fwd_viter_type + set_impl<abstract::mutable_image_being_value_wise_random_accessible, M, E>::impl_value(const typename set_impl<abstract::mutable_image_being_value_wise_random_accessible, M, E>::value_type& v) + { + return this->exact().delegate().value(v); + } + +# endif + + } // end of namespace oln::automatic + +} // end of namespace oln + +#endif // ! OLN_CORE_AUTOMATIC_IMAGE_IMAGE_BEING_VALUE_WISE_RANDOM_ACCESSIBLE_HH Index: oln/core/iterator_vtypes.hh --- oln/core/iterator_vtypes.hh (revision 684) +++ oln/core/iterator_vtypes.hh (working copy) @@ -33,7 +33,6 @@ # include <oln/core/1d/aliases.hh> # include <oln/core/2d/aliases.hh> # include <oln/core/3d/aliases.hh> -// # include <oln/core/type_fun/slice.hh> namespace oln @@ -272,7 +271,6 @@ }; - } // end of namespace oln Index: oln/core/abstract/image/hierarchies.hh --- oln/core/abstract/image/hierarchies.hh (revision 684) +++ oln/core/abstract/image/hierarchies.hh (working copy) @@ -41,13 +41,14 @@ typedef hierarchy<abstract::image, 5> image_hierarchy_wrt_accessibility; typedef hierarchy<abstract::image, 6> image_hierarchy_wrt_mutability; typedef hierarchy<abstract::image, 7> image_hierarchy_wrt_computability; + typedef hierarchy<abstract::image, 8> image_hierarchy_wrt_value_wise_accessibility; - typedef hierarchy<abstract::image, 8> image_hybrid_hierarchy_wrt_classical; + typedef hierarchy<abstract::image, 9> image_hybrid_hierarchy_wrt_classical; // FIXME: To be continued. #if 0 - typedef hierarchy<abstract::image, 9> image_hierarchy_wrt_value; - typedef hierarchy<abstract::image, 10> image_hierarchy_wrt_data_retrieval; + typedef hierarchy<abstract::image, 10> image_hierarchy_wrt_value; + typedef hierarchy<abstract::image, 11> image_hierarchy_wrt_data_retrieval; // ... #endif Index: oln/core/abstract/image/all.hh --- oln/core/abstract/image/all.hh (revision 684) +++ oln/core/abstract/image/all.hh (working copy) @@ -40,14 +40,16 @@ # include <oln/core/abstract/image/neighborhood/hierarchy.hh> // Hierarchy 4: image w.r.t. bounding box. # include <oln/core/abstract/image/bbox/hierarchy.hh> -// Hierarchy 5: image w.r.t. accessibility. +// Hierarchy 5: image w.r.t. point accessibility. # include <oln/core/abstract/image/accessibility/hierarchy.hh> // Hierarchy 6: image w.r.t. data mutability. # include <oln/core/abstract/image/mutability/hierarchy.hh> // Hierarchy 7: image w.r.t. computability. # include <oln/core/abstract/image/computability/hierarchy.hh> +// Hierarchy 8: image w.r.t. value-wise accessibility. +# include <oln/core/abstract/image/value_wise_accessibility/hierarchy.hh> -// Hybrid hierarchy 8: image w.r.t. classical features. +// (Hybrid) hierarchy 9: image w.r.t. classical features. # include <oln/core/abstract/image/hybrid/classical.hh> #endif // ! OLN_CORE_ABSTRACT_IMAGE_ALL_HH Index: oln/core/abstract/image/value_wise_accessibility/hierarchy.hh --- oln/core/abstract/image/value_wise_accessibility/hierarchy.hh (revision 0) +++ oln/core/abstract/image/value_wise_accessibility/hierarchy.hh (revision 0) @@ -0,0 +1,154 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_CORE_ABSTRACT_IMAGE_VALUE_WISE_ACCESSIBILITY_HIERARCHY_HH +# define OLN_CORE_ABSTRACT_IMAGE_VALUE_WISE_ACCESSIBILITY_HIERARCHY_HH + +# include <mlc/logic.hh> +# include <mlc/cmp.hh> + +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/image/hierarchies.hh> +# include <oln/core/automatic/image/image_being_value_wise_random_accessible.hh> + + +namespace oln +{ + + /*----------------------------------------. + | Value-wise accessibility abstractions. | + `----------------------------------------*/ + + namespace abstract + { + + /// Image having a value-wise random accessibility. + template <typename E> + struct image_being_value_wise_random_accessible : + public virtual image<E>, + public automatic::get_impl< image_being_value_wise_random_accessible, E > + { + typedef oln_type_of(E, value) value_t; + typedef oln_type_of(E, fwd_viter) fwd_viter_t; + + + public: + // Value descriptor (read-only access). + fwd_viter_t value(const value_t& v) const; + + protected: + /// Constructor (protected, empty). + image_being_value_wise_random_accessible(); + }; + + /// Mutable image having a value-wise random accessibility. + template <typename E> + struct mutable_image_being_value_wise_random_accessible : + public virtual image_being_value_wise_random_accessible<E>, + public automatic::get_impl< mutable_image_being_value_wise_random_accessible, E > + { + typedef oln_type_of(E, value) value_t; + typedef oln_type_of(E, mutable_fwd_viter) mutable_fwd_viter_t; + + public: + using image_being_value_wise_random_accessible<E>::value; + // Value descriptor (read-write access). + mutable_fwd_viter_t value(const value_t& v); + + protected: + /// Constructor (protected, empty). + mutable_image_being_value_wise_random_accessible(); + }; + + + +# ifndef OLN_INCLUDE_ONLY + + // image_being_value_wise_random_accessible. + + template <typename E> + typename image_being_value_wise_random_accessible<E>::fwd_viter_t + image_being_value_wise_random_accessible<E>::value(const typename image_being_value_wise_random_accessible<E>::value_t& v) const + { + return this->exact().impl_value(v); + } + + template <typename E> + image_being_value_wise_random_accessible<E>::image_being_value_wise_random_accessible() + { + } + + + // mutable_image_being_value_wise_random_accessible. + + template <typename E> + typename mutable_image_being_value_wise_random_accessible<E>::mutable_fwd_viter_t + mutable_image_being_value_wise_random_accessible<E>::value(const typename mutable_image_being_value_wise_random_accessible<E>::value_t& v) + { + return this->exact().impl_value(v); + } + + template <typename E> + mutable_image_being_value_wise_random_accessible<E>::mutable_image_being_value_wise_random_accessible() + { + } + +# endif + + } // end of namespace oln::abstract + + + /*-------------------. + | Dimension switch. | + `-------------------*/ + + /* FIXME: Handle mutability. This is not easy, as, for instance an + image with LUT has no lvalue type, but can be perfectly const or + mutable. How can we deal with this? By adding a specific + vtype? */ + + /// With value-wise random accessibility ( + template <typename E> + struct case_< image_hierarchy_wrt_value_wise_accessibility, E, 1 > : + where_< mlc_is_ok(oln_type_of(E, fwd_viter)) > + { + typedef abstract::mutable_image_being_value_wise_random_accessible<E> ret; + }; + +// /// With accessibility. +// template <typename E> +// struct case_< image_hierarchy_wrt_value_wise_accessibility, E, 2 > : +// where_< mlc_and( mlc_is_ok(oln_type_of(E, fwd_viter)), +// mlc_is_ok(oln_type_of(E, lvalue)) ) > +// { +// typedef abstract::mutable_image_being_value_wise_random_accessible<E> ret; +// }; + +} // end of namespace oln + + +#endif // ! OLN_CORE_ABSTRACT_IMAGE_VALUE_WISE_ACCESSIBILITY_HIERARCHY_HH Index: oln/core/gen/fwd_viter_lut.hh --- oln/core/gen/fwd_viter_lut.hh (revision 0) +++ oln/core/gen/fwd_viter_lut.hh (revision 0) @@ -0,0 +1,302 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_CORE_GEN_FWD_VITER_LUT_HH +# define OLN_CORE_GEN_FWD_VITER_LUT_HH + +# include <oln/core/internal/fwd_viter_lut.hh> +# include <oln/core/lookup_table.hh> + +namespace oln +{ + + /*------------. + | fwd_viter. | + `------------*/ + + // Forward declaration. + template <typename Lut> class fwd_viter_lut; + + + /// Super type declaration. + template <typename Lut> + struct set_super_type< fwd_viter_lut<Lut> > + { + typedef fwd_viter_lut<Lut> self_t; + typedef internal::fwd_viter_lut<self_t> ret; + }; + + + /// Virtual types associated to oln::fwd_viter_lut<Lut>. + template <typename Lut> + struct vtypes< fwd_viter_lut<Lut> > + { + // The look-up table is immutable. + typedef const Lut lut_type; + typedef typename Lut::const_iterator lut_iter_type; + typedef typename Lut::new_value_type rvalue_type; + }; + + + /// Const forward value iterator on look-up table. + template <typename Lut> + class fwd_viter_lut : + public stc_get_supers(fwd_viter_lut<Lut>) + // Check that Lut is a look-up table. + // FIXME: an abstract::lookup_table would be useful. + { + typedef fwd_viter_lut<Lut> self_t; + typedef stc_get_super(self_t) super_t; + + public: + typedef oln_type_of(self_t, lut) lut_t; + typedef oln_type_of(self_t, rvalue) rvalue_type; + + public: + // Construct an uninitialized value iterator. + fwd_viter_lut(const Lut& lut); + // Construct an iterator pointing to value \a val. + fwd_viter_lut(const Lut& lut, const rvalue_type& val); + + // Get the value pointed by this iterator (const version). + operator rvalue_type() const; + + void print(std::ostream& ostr) const; + }; + + + template <typename Lut> + std::ostream& operator<<(std::ostream& ostr, + const fwd_viter_lut<Lut>& t); + + + +# ifndef OLN_INCLUDE_ONLY + + template <typename Lut> + fwd_viter_lut<Lut>::fwd_viter_lut(const Lut& lut) + : super_t(lut) + { + // Initialize underlying iterator (i.e., \a i_.) + this->invalidate(); + } + + template <typename Lut> + fwd_viter_lut<Lut>::fwd_viter_lut(const Lut& lut, + const typename fwd_viter_lut<Lut>::rvalue_type& val) + : super_t(lut, val) + { + // The underlying iterator is initialized by the super class. + } + + template <typename Lut> + fwd_viter_lut<Lut>::operator typename fwd_viter_lut<Lut>::rvalue_type() const + { + precondition(this->is_valid()); + return this->i_->second; + } + + template <typename Lut> + void fwd_viter_lut<Lut>::print(std::ostream& ostr) const + { + precondition(this->is_valid()); + ostr << "fwd_viter_lut<Lut> { value = " << this->i_->second << " }"; + } + + + template <typename Lut> + std::ostream& operator<<(std::ostream& ostr, + const fwd_viter_lut<Lut>& t) + { + t.print(ostr); + return ostr; + } + +# endif + + + + /*--------------------. + | mutable_fwd_viter. | + `--------------------*/ + + // Forward declaration. + template <typename Lut> class mutable_fwd_viter_lut; + + + /// Super type declaration. + template <typename Lut> + struct set_super_type< mutable_fwd_viter_lut<Lut> > + { + typedef mutable_fwd_viter_lut<Lut> self_t; + typedef internal::fwd_viter_lut<self_t> ret; + }; + + + /// Virtual types associated to oln::mutable_fwd_viter_lut<Lut>. + template <typename Lut> + struct vtypes< mutable_fwd_viter_lut<Lut> > + { + typedef Lut lut_type; + typedef typename Lut::iterator lut_iter_type; + typedef typename Lut::new_value_type rvalue_type; + typedef typename Lut::new_value_type& lvalue_type; + }; + + + /// Const forward value iterator on look-up table. + template <typename Lut> + class mutable_fwd_viter_lut : + public stc_get_supers(mutable_fwd_viter_lut<Lut>) + // Check that Lut is a look-up table. + // FIXME: an abstract::lookup_table would be useful. + { + typedef mutable_fwd_viter_lut<Lut> self_t; + typedef stc_get_super(self_t) super_t; + typedef typename Lut::orig_value_type orig_value_t; + typedef typename Lut::new_value_type new_value_t; + + public: + typedef Lut lut_t; + typedef oln_type_of(self_t, rvalue) rvalue_type; + typedef oln_type_of(self_t, lvalue) lvalue_type; + + self_t& operator=(const rvalue_type& rhs); + + public: + // Construct an uninitialized value iterator. + mutable_fwd_viter_lut(Lut& lut); + // Construct an iterator pointing to value \a val. + mutable_fwd_viter_lut(Lut& lut, const rvalue_type& val); + + // Get the value pointed by this iterator (const version). + operator rvalue_type() const; + // Get the value pointed by this iterator (mutable version). + operator lvalue_type(); + + void print(std::ostream& ostr) const; + }; + + + template <typename Lut> + std::ostream& operator<<(std::ostream& ostr, + const mutable_fwd_viter_lut<Lut>& t); + + + +# ifndef OLN_INCLUDE_ONLY + + template <typename Lut> + mutable_fwd_viter_lut<Lut>::mutable_fwd_viter_lut(Lut& lut) + : super_t(lut) + { + // Initialize underlying iterator (i.e., \a i_.) + this->invalidate(); + } + + template <typename Lut> + mutable_fwd_viter_lut<Lut>::mutable_fwd_viter_lut(Lut& lut, + const typename mutable_fwd_viter_lut<Lut>::rvalue_type& val) + : super_t(lut, val) + { + // The underlying iterator is initialized by the super class. + } + + template <typename Lut> + mutable_fwd_viter_lut<Lut>::operator typename mutable_fwd_viter_lut<Lut>::rvalue_type() const + { + precondition(this->is_valid()); + return this->i_->second; + } + + template <typename Lut> + mutable_fwd_viter_lut<Lut>::operator typename mutable_fwd_viter_lut<Lut>::lvalue_type() + { + precondition(this->is_valid()); + return this->i_->second; + } + + template <typename Lut> + mutable_fwd_viter_lut<Lut>& + mutable_fwd_viter_lut<Lut>::operator=(const typename mutable_fwd_viter_lut<Lut>::rvalue_type& rhs) + { + precondition(this->is_valid()); + + // Current ``new'' value. + new_value_t cur_new_val = this->i_->first; + + // Shortcuts. + typedef typename Lut::iterator new_iter_t; + typedef std::pair<new_iter_t, new_iter_t> new_iter_range_t; + + // Current ``original'' value(s) associated to the next ``new'' value RHS. + new_iter_range_t cur_orig_val_range = + this->lut_.new_to_orig_map().equal_range(cur_new_val); + // A temporary map where additional bindings will be stored. + typename Lut::new_to_orig_map_type additional_bindings; + + for (new_iter_t j = cur_orig_val_range.first; + j != cur_orig_val_range.second; ++j) + { + // Update the orig-to-new map (substitution). + orig_value_t orig_val = j->second; + this->lut_.orig_to_new_map()[orig_val] = rhs; + // Populate the temp map. + additional_bindings.insert(std::make_pair(rhs, orig_val)); + } + // Update the new-to-orig map (deletion). + this->lut_.new_to_orig_map().erase(cur_orig_val_range.first, + cur_orig_val_range.second); + // Update the new-to-orig map (insertion). + this->lut_.new_to_orig_map().insert(additional_bindings.begin(), + additional_bindings.end()); + return *this; + } + + template <typename Lut> + void mutable_fwd_viter_lut<Lut>::print(std::ostream& ostr) const + { + precondition(this->is_valid()); + ostr + << "mutable_fwd_viter_lut<Lut> { value = " << this->i_->second << " }"; + } + + + template <typename Lut> + std::ostream& operator<<(std::ostream& ostr, + const mutable_fwd_viter_lut<Lut>& t) + { + t.print(ostr); + return ostr; + } + +# endif + +} // end of namespace oln + + +#endif // ! OLN_CORE_GEN_FWD_VITER_LUT_HH Index: oln/core/internal/fwd_viter_lut.hh --- oln/core/internal/fwd_viter_lut.hh (revision 0) +++ oln/core/internal/fwd_viter_lut.hh (revision 0) @@ -0,0 +1,171 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_CORE_INTERNAL_FWD_VITER_LUT_HH +# define OLN_CORE_INTERNAL_FWD_VITER_LUT_HH + +# include <oln/core/abstract/iterator.hh> + + +namespace oln +{ + + namespace internal + { + // Forward declaration. + template <typename Exact> class fwd_viter_lut; + + } // end of namespace oln::internal + + + /// Super type declaration. + template <typename Exact> + struct set_super_type< internal::fwd_viter_lut<Exact> > + { + typedef internal::fwd_viter_lut<Exact> self_t; + typedef abstract::iterator<self_t> ret; + }; + + + namespace internal + { + /// Forward value iterator on look-up table (abstract + /// factorization class). + template <typename Exact> + class fwd_viter_lut : public stc_get_supers(fwd_viter_lut<Exact>) + // Check that oln_type_of(Exact, lut) is a look-up table. + // FIXME: an abstract::lookup_table would be useful. + { + typedef fwd_viter_lut<Exact> self_t; + typedef stc_get_super(self_t) super_t; + typedef oln_type_of(Exact, lut_iter) lut_iter_t; + + public: + typedef oln_type_of(Exact, lut) lut_type; + typedef oln_type_of(Exact, rvalue) rvalue_type; + + public: + /// Iterator manipulators. + /// \{ + void start(); + void next(); + void invalidate(); + bool is_valid() const; + /// \} + + protected: + // Construct an uninitialized value iterator. + fwd_viter_lut(lut_type& lut); + // Construct an iterator pointing to value \a val. + fwd_viter_lut(lut_type& lut, const rvalue_type& val); + + protected: + /// Look-up table. + lut_type& lut_; + /// Iterator on \a lut_. + lut_iter_t i_; + }; + + + template <typename Exact> + std::ostream& operator<<(std::ostream& ostr, const fwd_viter_lut<Exact>& t); + + + +# ifndef OLN_INCLUDE_ONLY + + template <typename Exact> + fwd_viter_lut<Exact>::fwd_viter_lut(typename fwd_viter_lut<Exact>::lut_type& lut) + : super_t(), + lut_(lut), + i_() + { + // Initialize underlying iterator (i.e., \a i_.) + this->invalidate(); + } + + template <typename Exact> + fwd_viter_lut<Exact>::fwd_viter_lut(typename fwd_viter_lut<Exact>::lut_type& lut, + const typename fwd_viter_lut<Exact>::rvalue_type& val) + : super_t(), + lut_(lut), + i_() + { + // Initialize underlying iterator (i.e., \a i_.) + i_ = lut_.find(val); + assert(i_ != lut_.end()); + } + + template <typename Exact> + void + fwd_viter_lut<Exact>::start() + { + i_ = lut_.begin(); + } + + template <typename Exact> + void + fwd_viter_lut<Exact>::next() + { + /* Iterate until a different key is reached. In fact, + std::multimap might not be the best choice to implement + new_to_orig_map_. Maybe a std::map binding orig_val to a + std::set of new_val's would is better?. */ + rvalue_type val = i_->first; + do + ++i_; + while (i_ != lut_.end() and i_->first == val); + } + + template <typename Exact> + void + fwd_viter_lut<Exact>::invalidate() + { + i_ = lut_.end(); + } + + template <typename Exact> + bool + fwd_viter_lut<Exact>::is_valid() const + { + return (i_ != lut_.end()); + } + + template <typename Exact> + std::ostream& operator<<(std::ostream& ostr, const fwd_viter_lut<Exact>& t) + { + t.print(ostr); + return ostr; + } + +# endif + + } // end of namespace oln::internal + +} // end of namespace oln + +#endif // ! OLN_CORE_INTERNAL_FWD_VITER_LUT_HH Index: oln/core/lookup_table.hh --- oln/core/lookup_table.hh (revision 684) +++ oln/core/lookup_table.hh (working copy) @@ -34,83 +34,196 @@ namespace oln { - template <typename Key, typename Data> + // FIXME: Document! + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare = std::less<Orig_Value>, + typename New_Value_Compare = std::less<New_Value> > class lookup_table { - typedef lookup_table<Key, Data> self_t; + typedef lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare> self_t; public: - typedef Key key_type; - typedef Data data_type; - typedef std::map<Key, Data> map_type; + typedef Orig_Value orig_value_type; + typedef New_Value new_value_type; + typedef std::map<Orig_Value, New_Value, Orig_Value_Compare> orig_to_new_map_type; + typedef std::multimap<New_Value, Orig_Value, New_Value_Compare> new_to_orig_map_type; + + typedef typename new_to_orig_map_type::const_iterator const_iterator; + typedef typename new_to_orig_map_type::iterator iterator; public: lookup_table(); - self_t& add (const key_type& k, const data_type& d); + self_t& add (const orig_value_type& orig_value, const new_value_type& new_value); - const data_type operator () (const key_type& key) const; + const new_value_type operator() (const orig_value_type& orig_value) const; - const map_type& map() const; + /// (Internal) iterators. + /// \{ + const_iterator begin() const; + iterator begin(); + + const_iterator end() const; + iterator end(); + /// \} + + const_iterator find(const new_value_type& val) const; + iterator find(const new_value_type& val); + + /// Accessors. + /// \{ + const orig_to_new_map_type& orig_to_new_map() const; + orig_to_new_map_type& orig_to_new_map(); + const new_to_orig_map_type& new_to_orig_map() const; + new_to_orig_map_type& new_to_orig_map(); + /// \} private: - std::map<Key, Data> map_; + orig_to_new_map_type orig_to_new_map_; + new_to_orig_map_type new_to_orig_map_; }; # ifndef OLN_INCLUDE_ONLY - template <typename Key, typename Data> - lookup_table<Key, Data>::lookup_table() : - map_() + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + lookup_table<Orig_Value, New_Value, + Orig_Value_Compare, New_Value_Compare>::lookup_table() : + orig_to_new_map_() { } - template <typename Key, typename Data> - lookup_table<Key, Data>& - lookup_table<Key, Data>::add (const Key& k, const Data& d) + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>& + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::add (const Orig_Value& orig_value, + const New_Value& new_value) { - map_.insert(std::make_pair(k, d)); + orig_to_new_map_.insert(std::make_pair(orig_value, new_value)); + new_to_orig_map_.insert(std::make_pair(new_value, orig_value)); return *this; } - template <typename Key, typename Data> - const Data - lookup_table<Key, Data>::operator () (const Key& key) const - { - typedef typename lookup_table<Key, Data>::map_type map_t; - typename map_t::const_iterator i = map_.find(key); - // FIXME: Is this the expected behavior when the LUT has no data - // for \a key. - assert(i != map_.end()); + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + const New_Value + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::operator () (const Orig_Value& orig_value) const + { + typedef typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::orig_to_new_map_type orig_to_new_map_t; + typename orig_to_new_map_t::const_iterator i = orig_to_new_map_.find(orig_value); + // FIXME: Is this the expected behavior when the LUT has no new_value + // for \a orig_value? + assert(i != orig_to_new_map_.end()); return i->second; } - template <typename Key, typename Data> - const typename lookup_table<Key, Data>::map_type& - lookup_table<Key, Data>::map() const + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::const_iterator + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::begin() const + { + return new_to_orig_map_.begin(); + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::iterator + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::begin() + { + return new_to_orig_map_.begin(); + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::const_iterator + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::end() const + { + return new_to_orig_map_.end(); + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::iterator + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::end() + { + return new_to_orig_map_.end(); + } + + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::const_iterator + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::find(const New_Value& val) const + { + return new_to_orig_map_.find(val); + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::iterator + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::find(const New_Value& val) + { + return new_to_orig_map_.find(val); + } + + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + const typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::orig_to_new_map_type& + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::orig_to_new_map() const + { + return orig_to_new_map_; + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::orig_to_new_map_type& + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::orig_to_new_map() + { + return orig_to_new_map_; + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + const typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::new_to_orig_map_type& + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::new_to_orig_map() const + { + return new_to_orig_map_; + } + + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> + typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::new_to_orig_map_type& + lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::new_to_orig_map() { - return map_; + return new_to_orig_map_; } # endif /// Print a look-up table. - template <typename Key, typename Data> + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> std::ostream& - operator<< (std::ostream& ostr, const lookup_table<Key, Data>& lut); + operator<< (std::ostream& ostr, + const lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>& lut); # ifndef OLN_INCLUDE_ONLY - template <typename Key, typename Data> + template <typename Orig_Value, typename New_Value, + typename Orig_Value_Compare, typename New_Value_Compare> std::ostream& - operator<< (std::ostream& ostr, const lookup_table<Key, Data>& lut) + operator<< (std::ostream& ostr, + const lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>& lut) { - typedef lookup_table<Key, Data> lut_t; - const typename lut_t::map_type& map = lut.map(); - for (typename lut_t::map_type::const_iterator i = map.begin (); + typedef lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare> lut_t; + const typename lut_t::orig_to_new_map_type& map = lut.orig_to_new_map(); + for (typename lut_t::orig_to_new_map_type::const_iterator i = map.begin (); i != map.end(); ++i) ostr << " " << i->first << " -> " << i->second << std::endl; return ostr; Index: oln/morpher/slice.hh --- oln/morpher/slice.hh (revision 684) +++ oln/morpher/slice.hh (working copy) @@ -86,6 +86,7 @@ typedef oln_type_of(Image, value) value_type; // rvalue_type: see below. + // lvalue_type: see below. // fwd_piter_type: see oln/core/iterator_vtypes.hh. // bkd_piter_type: see oln/core/iterator_vtypes.hh. @@ -140,9 +141,6 @@ /// \} - - - // piters. /// fwd_piter vtype of morpher::slice. @@ -189,6 +187,7 @@ }; + // FIXME: What about niters on morpher::slice? Index: oln/morpher/with_lut.hh --- oln/morpher/with_lut.hh (revision 684) +++ oln/morpher/with_lut.hh (working copy) @@ -30,6 +30,7 @@ # include <oln/morpher/internal/image_value_morpher.hh> # include <oln/core/lookup_table.hh> +# include <oln/core/gen/fwd_viter_lut.hh> namespace oln @@ -61,58 +62,84 @@ public: typedef mlc::true_ is_computed_type; // Value type. - typedef typename Lut::data_type value_type; + typedef typename Lut::new_value_type value_type; // Look-up table type. typedef Lut lut_type; + + // rvalue_type: see below. + // lvalue_type: undefined (see + // oln/morpher/internal/image_value_morpher.hh). + + // fwd_viter_type: see below. + // mutable_fwd_viter_type: see below. + + // FIXME: implement bkd_viter_type! + // FIXME: implement mutable_bkd_viter_type! }; // Rvalue. template <typename Image, typename Lut> struct single_vtype< morpher::with_lut<Image, Lut>, typedef_::rvalue_type > { + private: typedef morpher::with_lut<Image, Lut> self_t; + public: typedef oln_value(self_t) ret; }; - // FIXME: What about lvalue type? + /// Const forward viter vtype of morpher::with_lut. + template <typename Image, typename Lut> + struct single_vtype< morpher::with_lut<Image, Lut>, + typedef_::fwd_viter_type > + { + typedef fwd_viter_lut<Lut> ret; + }; -// // Lvalue. -// template <typename Image> -// struct single_vtype< morpher::slice<Image>, typedef_::lvalue_type > -// { -// typedef oln_type_of(Image, lvalue) ret; -// }; + /// Mutable forward viter vtype of morpher::with_lut. + template <typename Image, typename Lut> + struct single_vtype< morpher::with_lut<Image, Lut>, + typedef_::mutable_fwd_viter_type > + { + typedef mutable_fwd_viter_lut<Lut> ret; + }; /// \} + // FIXME: What about bkd_viter_type on morpher::with_lut? + + + namespace morpher { /// Look-up table addition morpher. template <typename Image, typename Lut> class with_lut : public stc_get_supers(mlc_comma_1(with_lut<Image, Lut>)) - // FIXME: Ensure oln_value(Image) == Lut::data_type? Or just let + // FIXME: Ensure oln_value(Image) == Lut::new_value_type? Or just let // the ctor check this property? { - private: typedef with_lut<Image, Lut> self_t; typedef stc_get_super(self_t) super_t; - typedef Lut lut_t; - typedef oln_type_of(self_t, value) value_t; - typedef oln_type_of(self_t, rvalue) rvalue_t; - typedef oln_type_of(self_t, psite) psite_t; - // FIXME: Useful typedef? -// typedef oln_type_of(Image, value) orig_value_t; + + public: + typedef Lut lut_type; + typedef oln_type_of(self_t, value) value_type; + typedef oln_type_of(self_t, rvalue) rvalue_type; + typedef oln_type_of(self_t, psite) psite_type; + typedef oln_type_of(self_t, fwd_viter) fwd_viter_type; + typedef oln_type_of(self_t, mutable_fwd_viter) mutable_fwd_viter_type; public: with_lut(const Image& image, const Lut& lut); - const lut_t& lut() const; + const lut_type& lut() const; - rvalue_t impl_op_read(const psite_t& p) const; + rvalue_type impl_op_read(const psite_type& p) const; - // FIXME: Implement impl_op_write() when there is value proxy? + // FIXME: Constness of this method? + fwd_viter_type impl_value(const value_type& v) const; + mutable_fwd_viter_type impl_value(const value_type& v); protected: - lut_t lut_; + lut_type lut_; }; @@ -123,13 +150,12 @@ super_t(image), lut_(lut) { - mlc::assert_equal_< oln_value(Image), typename Lut::key_type >::check(); + mlc::assert_equal_< oln_value(Image), typename Lut::orig_value_type >::check(); } template <typename Image, typename Lut> - typename with_lut<Image, Lut>::rvalue_t - with_lut<Image, Lut>:: - impl_op_read(const typename with_lut<Image, Lut>::psite_t& p) const + typename with_lut<Image, Lut>::rvalue_type + with_lut<Image, Lut>::impl_op_read(const typename with_lut<Image, Lut>::psite_type& p) const { // FIXME: What if lut_ has no value for `this->image_(p)'? At // least, document the behavior of this method (will it abort, @@ -138,7 +164,21 @@ } template <typename Image, typename Lut> - const typename with_lut<Image, Lut>::lut_t& + typename with_lut<Image, Lut>::fwd_viter_type + with_lut<Image, Lut>::impl_value(const value_type& v) const + { + return fwd_viter_type(lut_, v); + } + + template <typename Image, typename Lut> + typename with_lut<Image, Lut>::mutable_fwd_viter_type + with_lut<Image, Lut>::impl_value(const value_type& v) + { + return mutable_fwd_viter_type(lut_, v); + } + + template <typename Image, typename Lut> + const typename with_lut<Image, Lut>::lut_type& with_lut<Image, Lut>::lut() const { return lut_; @@ -149,11 +189,12 @@ } // end of namespace oln::morpher + // FIXME: Provide a version of op+ where the LUT is const? template <typename I, typename K, typename D> morpher::with_lut< I, lookup_table<K, D> > operator + (const abstract::image& image, - const lookup_table<K, D>& lut); + lookup_table<K, D>& lut); # ifndef OLN_INCLUDE_ONLY @@ -161,11 +202,11 @@ template <typename I, typename K, typename D> morpher::with_lut< I, lookup_table<K, D> > operator + (const abstract::image& image, - const lookup_table<K, D>& lut) + lookup_table<K, D>& lut) { - typedef lookup_table<K, D> lut_t; - mlc::assert_equal_< oln_value(I), typename lut_t::key_type >::check(); - morpher::with_lut<I, lut_t> tmp(image.exact(), lut); + typedef lookup_table<K, D> lut_type; + mlc::assert_equal_< oln_value(I), typename lut_type::orig_value_type >::check(); + morpher::with_lut<I, lut_type> tmp(image.exact(), lut); return tmp; } Index: oln/value/color/rgb.hh --- oln/value/color/rgb.hh (revision 684) +++ oln/value/color/rgb.hh (working copy) @@ -63,6 +63,10 @@ template <typename U> rgb_<T>& operator=(const rgb_& rhs); + /// Op==. + template <typename U> + bool operator==(const rgb_& rhs); + T red() const; T& red(); typedef T red_type; @@ -124,6 +128,16 @@ } template <typename T> + template <typename U> + bool rgb_<T>::operator==(const rgb_& rhs) + { + return + val_[0] == rhs.red() and + val_[1] == rhs.green() and + val_[2] == rhs.blue(); + } + + template <typename T> T rgb_<T>::red() const { return val_[0];

1 0

684: Oops.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Oops. * oln/value/two_way.hh: New. Index: oln/value/two_way.hh =================================================================== --- oln/value/two_way.hh (revision 0) +++ oln/value/two_way.hh (revision 0) @@ -0,0 +1,81 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_CORE_VALUE_TWO_WAY_HH +# define OLN_CORE_VALUE_TWO_WAY_HH + +# include <iostream> +# include <oln/value/proxy.hh> +# include <oln/core/abstract/functions.hh> + + +namespace oln +{ + + namespace value + { + + template <typename I, typename F> + class two_way : public abstract::proxy< two_way<I,F> > + { + public: + + typedef oln_value(I) value_type; + + // Ctor. + two_way(I& ima, + F fun, + const oln_psite(I)& p); + + // Read. + template <typename V> + operator V() const; + + // Explicit read. + typename F::result_type value() const; + + // Write. + template <typename V> + two_way<I,F>& operator=(const V& value); + + protected: + I ima_; + F fun_; + const oln_psite(I)& p_; + }; + + + template <typename I, typename F> + std::ostream& operator<<(std::ostream& ostr, const two_way<I,F>& proxy); + + + } // end of namespace oln::value + +} // end of namespace oln + + +#endif // ! OLN_CORE_VALUE_TWO_WAY_HH

1 0

683: Tiny fix just before pastis.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Tiny fix just before pastis. * oln/basics1d.hh (include): Add missing headers. * oln/basics2d.hh: Likewise. * oln/basics3d.hh: Likewise. Index: oln/basics1d.hh =================================================================== --- oln/basics1d.hh (revision 680) +++ oln/basics1d.hh (working copy) @@ -32,6 +32,10 @@ # define OLN_ENV_1D +# include <oln/core/typedefs.hh> +# include <oln/core/case.hh> +# include <oln/core/traits.hh> +# include <oln/value/proxy.hh> # include <oln/core/1d/aliases.hh> Index: oln/basics2d.hh =================================================================== --- oln/basics2d.hh (revision 680) +++ oln/basics2d.hh (working copy) @@ -32,6 +32,10 @@ # define OLN_ENV_2D +# include <oln/core/typedefs.hh> +# include <oln/core/case.hh> +# include <oln/core/traits.hh> +# include <oln/value/proxy.hh> # include <oln/core/2d/aliases.hh> Index: oln/basics3d.hh =================================================================== --- oln/basics3d.hh (revision 680) +++ oln/basics3d.hh (working copy) @@ -32,6 +32,10 @@ # define OLN_ENV_3D +# include <oln/core/typedefs.hh> +# include <oln/core/case.hh> +# include <oln/core/traits.hh> +# include <oln/value/proxy.hh> # include <oln/core/3d/aliases.hh>

1 0

682: New header xtd/math/ops.hh.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * xtd/math.hh (include): Move ops inclusion into... * xtd/math/ops.hh: ... this new file. Index: xtd/math.hh =================================================================== --- xtd/math.hh (revision 681) +++ xtd/math.hh (working copy) @@ -68,9 +68,7 @@ /// \{ /// Definition of xtd operators and related functions. -# include <xtd/math/arith.hh> -# include <xtd/math/logic.hh> -# include <xtd/math/cmp.hh> +# include <xtd/math/ops.hh> /// \} Index: xtd/math/ops.hh =================================================================== --- xtd/math/ops.hh (revision 0) +++ xtd/math/ops.hh (revision 0) @@ -0,0 +1,37 @@ +// Copyright (C) 2002, 2005, 2006 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, 51 Franklin Street, Fifth Floor, +// 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 XTD_MATH_OPS_HH +# define XTD_MATH_OPS_HH + + +# include <xtd/math/arith.hh> +# include <xtd/math/logic.hh> +# include <xtd/math/cmp.hh> + + +#endif // ! XTD_MATH_OPS_HH

1 0

681: Add two-way morpher.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Add two-way morpher. * tests/morphers/two_way_morpher.cc: New. * tests/morphers/Makefile.am: Update. * oln/morpher/two_way.hh: New. * oln/Makefile.am: Update. * oln/core/abstract/image.hh (id_): Unconst. * oln/core/abstract/functions.hh (fun_v2w2v): New. * oln/core/traits.hh (oln_xtd_case_op_id): Fix number. (include): Add commentary. Index: tests/morphers/Makefile.am =================================================================== --- tests/morphers/Makefile.am (revision 680) +++ tests/morphers/Makefile.am (working copy) @@ -24,6 +24,7 @@ count_rw_morpher \ slice_morpher \ stack_morpher \ + two_way_morpher \ value_cast \ with_lut \ \ @@ -35,6 +36,7 @@ count_rw_morpher_SOURCES = count_rw_morpher.cc slice_morpher_SOURCES = slice_morpher.cc stack_morpher_SOURCES = stack_morpher.cc +two_way_morpher_SOURCES = two_way_morpher.cc value_cast_SOURCES = value_cast.cc with_lut_SOURCES = with_lut.cc Index: tests/morphers/two_way_morpher.cc =================================================================== --- tests/morphers/two_way_morpher.cc (revision 0) +++ tests/morphers/two_way_morpher.cc (revision 0) @@ -0,0 +1,68 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// Test the two-way morpher. + +#include <cassert> + +#include <oln/core/traits.hh> +#include <oln/basics2d.hh> +#include <oln/morpher/two_way.hh> + + +struct F : public oln::abstract::fun_v2w2v< F > +{ + typedef int result_type; + + int direct(int i) const + { + return i + 1; + } + + int reverse(int i) const + { + return i - 1; + } +}; + + +int main() +{ + F fun; + + using namespace oln; + typedef image2d<int> I; + I ima(1,1); + point2d p(0,0); + + ima(p) = 50; + assert(fun(ima)(p) == 51); + + morpher::two_way<I,F> ima_bis(ima); + ima_bis(p) = 52; + assert(ima(p) == 51); +} Index: oln/core/abstract/image.hh =================================================================== --- oln/core/abstract/image.hh (revision 680) +++ oln/core/abstract/image.hh (working copy) @@ -133,7 +133,7 @@ private: - const unsigned id_; + unsigned id_; }; Index: oln/core/abstract/functions.hh =================================================================== --- oln/core/abstract/functions.hh (revision 680) +++ oln/core/abstract/functions.hh (working copy) @@ -30,11 +30,19 @@ # include <stc/any.hh> # include <oln/core/type.hh> +# include <oln/core/abstract/image.hh> namespace oln { + + // Fwd decl. + namespace morpher { + template <typename I, typename F> class two_way; + } + + namespace abstract { @@ -60,6 +68,21 @@ }; + // Value1 -> Value2 *and* Value2 -> Value1. + + template <typename E> + struct fun_v2w2v : public virtual stc::any__simple<E>, + public oln::type + { + public: + template <typename I> + oln::morpher::two_way<I, E> + operator()(oln::abstract::mutable_image& input) const; + protected: + fun_v2w2v(); + }; + + // Point -> Point. template <typename E> @@ -84,6 +107,11 @@ } template <typename E> + fun_v2w2v<E>::fun_v2w2v() + { + } + + template <typename E> fun_p2p<E>::fun_p2p() { } Index: oln/core/traits.hh =================================================================== --- oln/core/traits.hh (revision 680) +++ oln/core/traits.hh (working copy) @@ -28,11 +28,12 @@ #ifndef OLN_CORE_TRAITS_HH # define OLN_CORE_TRAITS_HH - # include <mlc/assert.hh> # include <mlc/abort.hh> -# include <xtd/optraits.hh> -# include <xtd/math/ops.hh> + +# include <xtd/optraits.hh> // case #1 for C++ builtins +# include <xtd/math/ops.hh> // case #2 for xtd::fun_expr_ + # include <stc/exact.hh> # include <oln/core/type.hh> @@ -56,7 +57,7 @@ namespace xtd { - static const unsigned oln_xtd_case_op_id = 2; + static const unsigned oln_xtd_case_op_id = 3; // case #3 template <typename name, Index: oln/Makefile.am =================================================================== --- oln/Makefile.am (revision 680) +++ oln/Makefile.am (working copy) @@ -183,6 +183,7 @@ morpher/stack.hh \ morpher/thru_fun.hh \ morpher/thru_mfun.hh \ + morpher/two_way.hh \ morpher/value_cast.hh \ morpher/with_lut.hh \ \ Index: oln/morpher/two_way.hh =================================================================== --- oln/morpher/two_way.hh (revision 0) +++ oln/morpher/two_way.hh (revision 0) @@ -0,0 +1,238 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_MORPHER_TWO_WAY_HH +# define OLN_MORPHER_TWO_WAY_HH + +# include <oln/value/two_way.hh> +# include <oln/morpher/internal/image_value_morpher.hh> + + +namespace oln +{ + + namespace morpher + { + // Forward declaration. + template <typename Image, typename Fun> struct two_way; + + } // end of namespace oln::morpher + + + /// Super type. + template <typename Image, typename Fun> + struct set_super_type< morpher::two_way<Image, Fun> > + { + typedef morpher::two_way<Image, Fun> self_t; + typedef morpher::internal::image_value_morpher<Image, self_t> ret; + }; + + + template <typename Image, typename Fun> + struct vtypes< morpher::two_way<Image, Fun> > + { + typedef morpher::two_way<Image, Fun> self_t; + public: + typedef mlc::true_ is_computed_type; + + typedef typename Fun::result_type value_type; + typedef value::two_way<Image, Fun> lvalue_type; + }; + + template <typename Image, typename Fun> + struct single_vtype< morpher::two_way<Image, Fun>, typedef_::rvalue_type > + { + typedef typename Fun::result_type ret; + }; + + + namespace morpher + { + + /// 'Image thru Function' morpher. + template <typename Image, typename Fun> + class two_way : public internal::image_value_morpher< Image, + morpher::two_way<Image, Fun> > + { + private: + + typedef two_way<Image, Fun> self_t; + + typedef internal::image_value_morpher<Image, self_t> super_t; + using super_t::image_; + + typedef oln_rvalue(self_t) rvalue_t; + typedef oln_lvalue(self_t) lvalue_t; + typedef oln_psite(self_t) psite_t; + + public: + + two_way(Image& image, Fun fun); + two_way(Image& image); + + two_way(oln::abstract::mutable_image<Image>& image, + const oln::abstract::fun_v2w2v<Fun>& fun); + + rvalue_t impl_op_read(const psite_t& p) const; + lvalue_t impl_op_readwrite(const psite_t& p); + + protected: + + Fun fun_; + }; + + + namespace ERROR + { + + struct FIXME; + + } // end of namespace oln::morpher::ERROR + + +# ifndef OLN_INCLUDE_ONLY + + // public + + template <typename Image, typename Fun> + two_way<Image, Fun>::two_way(Image& image) : + super_t(image), + fun_() + { + } + + template <typename Image, typename Fun> + two_way<Image, Fun>::two_way(Image& image, Fun fun) : + super_t(image), + fun_(fun) + { + } + + template <typename Image, typename Fun> + two_way<Image, Fun>::two_way(oln::abstract::mutable_image<Image>& image, + const oln::abstract::fun_v2w2v<Fun>& fun) : + super_t(image.exact()), + fun_(fun.exact()) + { + } + + template <typename Image, typename Fun> + typename two_way<Image, Fun>::rvalue_t + two_way<Image, Fun>::impl_op_read(const typename two_way<Image, Fun>::psite_t& p) const + { + return fun_.direct(image_(p)); + } + + template <typename Image, typename Fun> + typename two_way<Image, Fun>::lvalue_t + two_way<Image, Fun>::impl_op_readwrite(const typename two_way<Image, Fun>::psite_t& p) + { + value::two_way<Image, Fun> tmp(image_, fun_, p); + return tmp; + } + +# endif + + } // end of namespace oln::morpher + + +# ifndef OLN_INCLUDE_ONLY + + namespace value + { + + // Ctor. + template <typename I, typename F> + two_way<I,F>::two_way(I& ima, + F fun, + const oln_psite(I)& p) + : ima_(ima), + fun_(fun), + p_(p) + { + } + + // Read. + template <typename I, typename F> + template <typename V> + two_way<I,F>::operator V() const + { + return fun_.direct(ima_(p_)); + } + + // Explicit read. + template <typename I, typename F> + typename F::result_type + two_way<I,F>::value() const + { + return fun_.direct(ima_(p_)); + } + + // Write. + + template <typename I, typename F> + template <typename V> + two_way<I,F>& + two_way<I,F>::operator=(const V& value) + { + ima_(p_) = fun_.reverse(value); + return *this; + } + + // Op <<. + template <typename I, typename F> + std::ostream& operator<<(std::ostream& ostr, + const two_way<I,F>& proxy) + { + return ostr << proxy.value(); + } + + } // end of namespace oln::value + + + namespace abstract + { + + template <typename F> + template <typename I> + oln::morpher::two_way<I, F> + fun_v2w2v<F>::operator()(oln::abstract::mutable_image& input) const + { + morpher::two_way<I, F> tmp(input.exact(), this->exact()); + return tmp; + } + + } // end of namespace oln::abstract + +# endif + + + +} // end of namespace oln + + +#endif // ! OLN_MORPHER_TWO_WAY_HH

1 0

680: Add oln::level::apply_inplace.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Add oln::level::apply_inplace. * tests/level/apply_inplace.cc: New. * oln/level/assign.hh: Typo. * oln/level/apply.hh (apply_inplace): New. * oln/level/fill.hh (include): Fix. * oln/core/traits.hh (include): Add xtd/math/ops.hh. Index: tests/level/apply_inplace.cc =================================================================== --- tests/level/apply_inplace.cc (revision 0) +++ tests/level/apply_inplace.cc (revision 0) @@ -0,0 +1,40 @@ +#include <oln/basics2d.hh> +#include <oln/debug/print.hh> + +#include <oln/level/apply.hh> +#include <oln/level/assign.hh> +#include <oln/level/clone.hh> +#include <oln/level/fill.hh> + + + +struct chessboard_2d : public oln::abstract::fun_p2v< chessboard_2d > +{ + bool operator()(const oln::point2d& p) const + { + return (p.row() + p.col()) % 2; + } +}; + + +struct negate : public oln::abstract::fun_v2v< negate > +{ + bool operator()(bool b) const + { + return not b; + } +}; + + + +int main() +{ + using namespace oln; + image2d<bool> ima(3,3); + + oln::level::fill(ima, chessboard_2d()); + debug::print(ima); + + oln::level::apply_inplace(ima, negate()); + debug::print(ima); +} Index: oln/level/assign.hh =================================================================== --- oln/level/assign.hh (revision 679) +++ oln/level/assign.hh (working copy) @@ -45,8 +45,7 @@ namespace level { - /// Fwd decls. - + /// Fwd decl. template <typename Idest, typename Isrc> void assign(abstract::mutable_image<Idest>& dest, const abstract::image<Isrc>& src); Index: oln/level/apply.hh =================================================================== --- oln/level/apply.hh (revision 679) +++ oln/level/apply.hh (working copy) @@ -50,7 +50,15 @@ oln_plain_value(I, typename F::result_value) apply(const abstract::image& input, const abstract::fun_v2v<F>& fun); + /// Fwd decl. + template <typename I, typename V> + void apply_inplace(abstract::mutable_image& input, V (*fun)(const oln_value(I)&)); + /// Fwd decl. + template <typename I, typename F> + void apply_inplace(abstract::mutable_image& input, const abstract::fun_v2v<F>& fun); + + # ifndef OLN_INCLUDE_ONLY namespace impl @@ -80,6 +88,27 @@ return output; } + + /// Generic version. + template <typename I, typename V> + void + apply_inplace(abstract::mutable_image& input, V (*fun)(const oln_value(I)&)) + { + oln_piter(I) p(input.topo()); + for_all(p) + input(p) = fun(input(p)); + } + + /// Generic version. + template <typename I, typename F> + void + apply_inplace(abstract::mutable_image& input, const abstract::fun_v2v<F>& fun) + { + oln_piter(I) p(input.topo()); + for_all(p) + input(p) = fun.exact()(input(p)); + } + } // end of namespace oln::level::impl @@ -99,6 +128,23 @@ return impl::apply(input, fun); } + + /// Facade. + template <typename I, typename V> + void + apply_inplace(abstract::mutable_image& input, V (*fun)(const oln_value(I)&)) + { + return impl::apply_inplace(input, fun); + } + + /// Facade. + template <typename I, typename F> + void + apply_inplace(abstract::mutable_image& input, const abstract::fun_v2v<F>& fun) + { + return impl::apply_inplace(input, fun); + } + # endif } // end of namespace oln::level Index: oln/level/fill.hh =================================================================== --- oln/level/fill.hh (revision 679) +++ oln/level/fill.hh (working copy) @@ -31,13 +31,9 @@ # include <iostream> -# include <mlc/assert.hh> -# include <mlc/is_a.hh> - # include <oln/core/abstract/image.hh> # include <oln/core/abstract/iterator.hh> # include <oln/core/abstract/functions.hh> -# include <oln/core/automatic/image/mutable_image.hh> namespace oln @@ -75,8 +71,7 @@ /// Fwd decl. template <typename I, typename F> - void fill(abstract::mutable_image& input, - const abstract::fun_p2v<F>& fun); + void fill(abstract::mutable_image& input, const abstract::fun_p2v<F>& fun); # ifndef OLN_INCLUDE_ONLY @@ -115,11 +110,9 @@ /// Generic version. template <typename I, typename F> - void fill(abstract::mutable_image& input, - const abstract::fun_p2v<F>& fun) + void fill(abstract::mutable_image& input, const abstract::fun_p2v<F>& fun) { oln_piter(I) p(input.topo()); - unsigned i = 0; for_all(p) input(p) = fun.exact()(p); } @@ -150,8 +143,7 @@ /// Facade. template <typename I, typename F> - void fill(abstract::mutable_image& input, - const abstract::fun_p2v<F>& fun) + void fill(abstract::mutable_image& input, const abstract::fun_p2v<F>& fun) { return impl::fill(input.exact(), fun); } Index: oln/core/traits.hh =================================================================== --- oln/core/traits.hh (revision 678) +++ oln/core/traits.hh (working copy) @@ -32,6 +32,7 @@ # include <mlc/assert.hh> # include <mlc/abort.hh> # include <xtd/optraits.hh> +# include <xtd/math/ops.hh> # include <stc/exact.hh> # include <oln/core/type.hh>

1 0

679: Add oln abstract functions + move slice vtype definitions.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Add oln abstract functions + move slice vtype definitions. * oln/level/assign.hh: New. * oln/level/apply.hh: New. * oln/level/clone.hh: New. * oln/core/abstract/functions.hh: New. * oln/debug/track.hh (dummy): Add code to remove warning. * oln/debug/print.hh (OLN_ENV_2D): Guard specific code. * oln/level/fill.hh (fill): New couple of versions. * oln/basics1d.hh (OLN_ENV_1D): New. * oln/core/typedefs.hh (oln_plain_value, oln_plain_value_): New. * oln/core/iterator_vtypes.hh (slice): Move type definitions to... * oln/morpher/slice.hh: ...here. * oln/basics2d.hh (OLN_ENV_2D): New. * oln/basics3d.hh (OLN_ENV_3D): New. * oln/Makefile.am: Update. Index: oln/debug/track.hh =================================================================== --- oln/debug/track.hh (revision 678) +++ oln/debug/track.hh (working copy) @@ -38,6 +38,16 @@ static unsigned n_images = 0; static unsigned n_arrays = 0; + +# ifndef OLN_INCLUDE_ONLY + namespace dummy { + // FIXME: Quick hack to suppress the warning + // "'oln::debug::n_arrays' defined but not used" + void foo() { n_arrays = n_arrays; } + } +# endif + + } // end of namespace oln::debug } // end of namespace oln Index: oln/debug/print.hh =================================================================== --- oln/debug/print.hh (revision 678) +++ oln/debug/print.hh (working copy) @@ -34,9 +34,12 @@ # include <oln/core/abstract/iterator.hh> # include <oln/core/spe/row.hh> # include <oln/core/spe/col.hh> -# include <oln/core/2d/point2d.hh> +# ifdef OLN_ENV_2D +# include <oln/core/2d/point2d.hh> +# endif + namespace oln { @@ -76,6 +79,8 @@ } +# ifdef OLN_ENV_2D + /// Version for classical 2D images. template <typename I> void print(const abstract::classical_2d_image& input, @@ -96,10 +101,12 @@ } } +# endif + + } // end of namespace oln::debug::impl - /// Facade. template <typename I> void print(const abstract::image& input, std::ostream& ostr) Index: oln/level/assign.hh =================================================================== --- oln/level/assign.hh (revision 0) +++ oln/level/assign.hh (revision 0) @@ -0,0 +1,85 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_LEVEL_ASSIGN_HH +# define OLN_LEVEL_ASSIGN_HH + +# include <iostream> + +# include <mlc/assert.hh> +# include <mlc/is_a.hh> + +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/iterator.hh> +# include <oln/core/automatic/image/mutable_image.hh> + + +namespace oln +{ + + namespace level + { + + /// Fwd decls. + + template <typename Idest, typename Isrc> + void assign(abstract::mutable_image<Idest>& dest, const abstract::image<Isrc>& src); + + +# ifndef OLN_INCLUDE_ONLY + + namespace impl + { + + /// Generic version. + template <typename Idest, typename Isrc> + void assign(abstract::mutable_image<Idest>& dest, const abstract::image<Isrc>& src) + { + oln_piter(Isrc) p(src.topo()); + for_all(p) + dest(p) = src(p); + } + + } // end of namespace oln::level::impl + + + /// Facade. + template <typename Idest, typename Isrc> + void assign(abstract::mutable_image<Idest>& dest, const abstract::image<Isrc>& src) + { + impl::assign(dest.exact(), src.exact()); + } + +# endif + + } // end of namespace oln::level + +} // end of namespace oln + + +#endif // ! OLN_LEVEL_ASSIGN_HH Index: oln/level/apply.hh =================================================================== --- oln/level/apply.hh (revision 0) +++ oln/level/apply.hh (revision 0) @@ -0,0 +1,109 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_LEVEL_APPLY_HH +# define OLN_LEVEL_APPLY_HH + +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/iterator.hh> +# include <oln/core/abstract/functions.hh> + + +namespace oln +{ + + namespace level + { + + /// Fwd decl. + template <typename I, typename V> + oln_plain_value(I, V) + apply(const abstract::image& input, V (*fun)(const oln_value(I)&)); + + /// Fwd decl. + template <typename I, typename F> + oln_plain_value(I, typename F::result_value) + apply(const abstract::image& input, const abstract::fun_v2v<F>& fun); + + +# ifndef OLN_INCLUDE_ONLY + + namespace impl + { + + /// Generic version. + template <typename I, typename V> + oln_plain_value(I, V) + apply(const abstract::image& input, V (*fun)(const oln_value(I)&)) + { + oln_plain_value(I, V) output(input.topo()); + oln_piter(I) p(input.topo()); + for_all(p) + output(p) = fun(input(p)); + return output; + } + + /// Generic version. + template <typename I, typename F> + oln_plain_value(I, typename F::result_value) + apply(const abstract::image& input, const abstract::fun_v2v<F>& fun) + { + oln_plain_value(I, typename F::result_value) output(input.topo()); + oln_piter(I) p(input.topo()); + for_all(p) + output(p) = fun.exact()(input(p)); + return output; + } + + } // end of namespace oln::level::impl + + + /// Facade. + template <typename I, typename V> + oln_plain_value(I, V) + apply(const abstract::image& input, V (*fun)(const oln_value(I)&)) + { + return impl::apply(input, fun); + } + + /// Facade. + template <typename I, typename F> + oln_plain_value(I, typename F::result_value) + apply(const abstract::image& input, const abstract::fun_v2v<F>& fun) + { + return impl::apply(input, fun); + } + +# endif + + } // end of namespace oln::level + +} // end of namespace oln + + +#endif // ! OLN_LEVEL_APPLY_HH Index: oln/level/fill.hh =================================================================== --- oln/level/fill.hh (revision 678) +++ oln/level/fill.hh (working copy) @@ -36,6 +36,7 @@ # include <oln/core/abstract/image.hh> # include <oln/core/abstract/iterator.hh> +# include <oln/core/abstract/functions.hh> # include <oln/core/automatic/image/mutable_image.hh> @@ -68,7 +69,16 @@ template <typename I, typename V> void fill(abstract::mutable_image& input, const V values[]); + /// Fwd decl. + template <typename I, typename V, typename P> + void fill(abstract::mutable_image& input, V (*fun)(const P&)); + /// Fwd decl. + template <typename I, typename F> + void fill(abstract::mutable_image& input, + const abstract::fun_p2v<F>& fun); + + # ifndef OLN_INCLUDE_ONLY namespace impl @@ -93,9 +103,30 @@ input(p) = values[i++]; } - } // end of namespace oln::level::fill + /// Generic version. + template <typename I, typename V, typename P> + void fill(abstract::mutable_image& input, V (*fun)(const P&)) + { + oln_piter(I) p(input.topo()); + unsigned i = 0; + for_all(p) + input(p) = fun(p); + } + /// Generic version. + template <typename I, typename F> + void fill(abstract::mutable_image& input, + const abstract::fun_p2v<F>& fun) + { + oln_piter(I) p(input.topo()); + unsigned i = 0; + for_all(p) + input(p) = fun.exact()(p); + } + } // end of namespace oln::level::impl + + /// Facade. template <typename I> void fill(abstract::mutable_image& input, const oln_value(I)& value) @@ -110,7 +141,21 @@ return impl::fill(input.exact(), values); } + /// Facade. + template <typename I, typename V, typename P> + void fill(abstract::mutable_image& input, V (*fun)(const P&)) + { + return impl::fill(input.exact(), fun); + } + /// Facade. + template <typename I, typename F> + void fill(abstract::mutable_image& input, + const abstract::fun_p2v<F>& fun) + { + return impl::fill(input.exact(), fun); + } + # endif } // end of namespace oln::level Index: oln/level/clone.hh =================================================================== --- oln/level/clone.hh (revision 0) +++ oln/level/clone.hh (revision 0) @@ -0,0 +1,80 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_LEVEL_CLONE_HH +# define OLN_LEVEL_CLONE_HH + +# include <oln/core/abstract/image.hh> +# include <oln/core/abstract/iterator.hh> + + +namespace oln +{ + + namespace level + { + + /// Fwd decl. + template <typename I> + oln_plain(I) clone(const abstract::image& input); + + +# ifndef OLN_INCLUDE_ONLY + + namespace impl + { + + /// Generic version. + template <typename I> + oln_plain(I) clone(const abstract::image& input) + { + oln_plain(I) output(input.topo()); + oln_piter(I) p(input.topo()); + for_all(p) + output(p) = input(p); + return output; + } + + } // end of namespace oln::level::impl + + + /// Facade. + template <typename I> + oln_plain(I) clone(const abstract::image& input) + { + return impl::clone(input); + } + +# endif + + } // end of namespace oln::level + +} // end of namespace oln + + +#endif // ! OLN_LEVEL_CLONE_HH Index: oln/basics1d.hh =================================================================== --- oln/basics1d.hh (revision 678) +++ oln/basics1d.hh (working copy) @@ -30,6 +30,9 @@ # define OLN_BASICS1D_HH +# define OLN_ENV_1D + + # include <oln/core/1d/aliases.hh> # include <oln/core/gen/grid.hh> Index: oln/core/typedefs.hh =================================================================== --- oln/core/typedefs.hh (revision 678) +++ oln/core/typedefs.hh (working copy) @@ -279,6 +279,9 @@ # define oln_plain(T) typename oln::type_fun::plain<T>::ret # define oln_plain_(T) oln::type_fun::plain<T>::ret +# define oln_plain_value(I, V) typename oln::type_fun::ch_value< oln_plain(I), V >::ret +# define oln_plain_value_(I, V) oln::type_fun::ch_value< oln_plain(I), V >::ret + /// \} Index: oln/core/iterator_vtypes.hh =================================================================== --- oln/core/iterator_vtypes.hh (revision 678) +++ oln/core/iterator_vtypes.hh (working copy) @@ -33,7 +33,7 @@ # include <oln/core/1d/aliases.hh> # include <oln/core/2d/aliases.hh> # include <oln/core/3d/aliases.hh> -# include <oln/core/type_fun/slice.hh> +// # include <oln/core/type_fun/slice.hh> namespace oln @@ -272,67 +272,7 @@ }; - /*-----------------------------. - | oln::morpher::slice<Image>. | - `-----------------------------*/ - // Forward declarations. - namespace morpher - { - template <typename Image> struct slice; - } - template <typename Piter, typename Topo> class piter_slice_; - - - // piters. - - /// fwd_piter vtype of morpher::slice. - template <typename Image> - struct single_vtype< morpher::slice<Image>, typedef_::fwd_piter_type > - { - private: - typedef oln_type_of(Image, fwd_piter) orig_fwd_piter; - public: - typedef typename type_fun::slice_iterator<orig_fwd_piter>::ret ret; - }; - - /// bkd_piter vtype of morpher::slice. - template <typename Image> - struct single_vtype< morpher::slice<Image>, typedef_::bkd_piter_type > - { - private: - typedef oln_type_of(Image, bkd_piter) orig_bkd_piter; - public: - typedef typename type_fun::slice_iterator<orig_bkd_piter>::ret ret; - }; - - - // qiters. - - /// fwd_qiter vtype of morpher::slice. - template <typename Image> - struct single_vtype< morpher::slice<Image>, typedef_::fwd_qiter_type > - { - private: - typedef oln_type_of(Image, fwd_qiter) orig_fwd_qiter; - public: - typedef typename type_fun::slice_iterator<orig_fwd_qiter>::ret ret; - }; - - /// bkd_qiter vtype of morpher::slice. - template <typename Image> - struct single_vtype< morpher::slice<Image>, typedef_::bkd_qiter_type > - { - private: - typedef oln_type_of(Image, bkd_qiter) orig_bkd_qiter; - public: - typedef typename type_fun::slice_iterator<orig_bkd_qiter>::ret ret; - }; - - - // FIXME: What about niters? - - } // end of namespace oln Index: oln/core/abstract/functions.hh =================================================================== --- oln/core/abstract/functions.hh (revision 0) +++ oln/core/abstract/functions.hh (revision 0) @@ -0,0 +1,98 @@ +// Copyright (C) 2006 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, 51 Franklin Street, Fifth Floor, +// 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 OLN_CORE_ABSTRACT_FUNCTIONS_HH +# define OLN_CORE_ABSTRACT_FUNCTIONS_HH + +# include <stc/any.hh> +# include <oln/core/type.hh> + + +namespace oln +{ + + namespace abstract + { + + // Point -> Value. + + template <typename E> + struct fun_p2v : public virtual stc::any__simple<E>, + public oln::type + { + protected: + fun_p2v(); + }; + + + // Value -> Value. + + template <typename E> + struct fun_v2v : public virtual stc::any__simple<E>, + public oln::type + { + protected: + fun_v2v(); + }; + + + // Point -> Point. + + template <typename E> + struct fun_p2p : public virtual stc::any__simple<E>, + public oln::type + { + protected: + fun_p2p(); + }; + + +# ifndef OLN_INCLUDE_ONLY + + template <typename E> + fun_p2v<E>::fun_p2v() + { + } + + template <typename E> + fun_v2v<E>::fun_v2v() + { + } + + template <typename E> + fun_p2p<E>::fun_p2p() + { + } + +# endif + + } // end of namespace oln::abstract + +} // end of namespace oln + + +#endif // ! OLN_CORE_ABSTRACT_FUNCTIONS_HH Index: oln/basics2d.hh =================================================================== --- oln/basics2d.hh (revision 678) +++ oln/basics2d.hh (working copy) @@ -30,6 +30,9 @@ # define OLN_BASICS2D_HH +# define OLN_ENV_2D + + # include <oln/core/2d/aliases.hh> # include <oln/core/gen/grid.hh> Index: oln/Makefile.am =================================================================== --- oln/Makefile.am (revision 678) +++ oln/Makefile.am (working copy) @@ -80,6 +80,7 @@ core/abstract/bbox.hh \ core/abstract/dpoint.hh \ core/abstract/entry.hh \ + core/abstract/functions.hh \ core/abstract/fwd_decls.hh \ core/abstract/grid.hh \ core/abstract/image.hh \ @@ -165,6 +166,9 @@ \ io/pnm.hh \ \ + level/apply.hh \ + level/assign.hh \ + level/clone.hh \ level/fill.hh \ \ morpher/internal/image_extension.hh \ Index: oln/basics3d.hh =================================================================== --- oln/basics3d.hh (revision 678) +++ oln/basics3d.hh (working copy) @@ -30,6 +30,9 @@ # define OLN_BASICS3D_HH +# define OLN_ENV_3D + + # include <oln/core/3d/aliases.hh> # include <oln/core/gen/grid.hh> Index: oln/morpher/slice.hh =================================================================== --- oln/morpher/slice.hh (revision 678) +++ oln/morpher/slice.hh (working copy) @@ -140,6 +140,58 @@ /// \} + + + + // piters. + + /// fwd_piter vtype of morpher::slice. + template <typename Image> + struct single_vtype< morpher::slice<Image>, typedef_::fwd_piter_type > + { + private: + typedef oln_type_of(Image, fwd_piter) orig_fwd_piter; + public: + typedef typename type_fun::slice_iterator<orig_fwd_piter>::ret ret; + }; + + /// bkd_piter vtype of morpher::slice. + template <typename Image> + struct single_vtype< morpher::slice<Image>, typedef_::bkd_piter_type > + { + private: + typedef oln_type_of(Image, bkd_piter) orig_bkd_piter; + public: + typedef typename type_fun::slice_iterator<orig_bkd_piter>::ret ret; + }; + + + // qiters. + + /// fwd_qiter vtype of morpher::slice. + template <typename Image> + struct single_vtype< morpher::slice<Image>, typedef_::fwd_qiter_type > + { + private: + typedef oln_type_of(Image, fwd_qiter) orig_fwd_qiter; + public: + typedef typename type_fun::slice_iterator<orig_fwd_qiter>::ret ret; + }; + + /// bkd_qiter vtype of morpher::slice. + template <typename Image> + struct single_vtype< morpher::slice<Image>, typedef_::bkd_qiter_type > + { + private: + typedef oln_type_of(Image, bkd_qiter) orig_bkd_qiter; + public: + typedef typename type_fun::slice_iterator<orig_bkd_qiter>::ret ret; + }; + + + + + namespace morpher { @@ -203,4 +255,5 @@ } // end of namespace oln + #endif // ! OLN_MORPHER_SLICE_HH

1 0

678: Introduce ids for images and better oln::morpher::count_rw_.
by Thierry GERAUD 25 Oct '06

25 Oct '06

2006-10-25 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Introduce ids for images and better oln::morpher::count_rw_. * tests/morphers/count_rw_morpher.cc: Add sample code in comments. * oln/core/abstract/iterator_on_points.hh (operator<<): New. * oln/core/abstract/image.hh (image, operator=): New. (id_, id): New. * oln/core/gen/piter_isubset.hh (isubset_): Remove &. * oln/core/gen/pw_value.hh (ima_): Remove &. (impl_calc): Fix static check. * oln/core/gen/topo_add_isubset.hh (isubset_): Add comment. * oln/core/gen/fwd_piter_bbox.hh (operator<<): Remove; obsolete. * oln/core/gen/bkd_piter_bbox.hh: Likewise. * oln/morpher/add_isubset.hh (operator|): New overloading. (add_isubset): Relax static check. * oln/morpher/internal/image_value_morpher.hh (image_): Remove &. * oln/morpher/internal/image_extension.hh (image_): Remove &. (image_extension): New cpy ctor. * oln/morpher/count_rw.hh (count_rw): Rename the class as... (count_rw_): ...this. (count_rw): New overloading. * oln/value/rw_counter.hh (counter_rw): Rewrite. (rw_counter): Remove & from ima_ type. (ro_counter): Likewise. Index: tests/morphers/count_rw_morpher.cc =================================================================== --- tests/morphers/count_rw_morpher.cc (revision 677) +++ tests/morphers/count_rw_morpher.cc (working copy) @@ -38,7 +38,7 @@ typedef image2d<int> image_t; image_t ima(3,3); - morpher::count_rw<image_t> ima2(ima); + morpher::count_rw_<image_t> ima2(ima); point2d p(0,0); ima2(p); @@ -46,8 +46,84 @@ int i = ima2(p); i = 0; // suppress "unused i" warning - assert(value::counter::n_readwrite_calls(ima) == 3); - assert(value::counter::n_readonly_calls(ima) == 0); - assert(value::counter::n_reads(ima) == 1); - assert(value::counter::n_writes(ima) == 1); + assert(value::counter_rw::n_readwrite_calls(ima) == 3); + assert(value::counter_rw::n_readonly_calls(ima) == 0); + assert(value::counter_rw::n_reads(ima) == 1); + assert(value::counter_rw::n_writes(ima) == 1); } + + +/* + +// another piece of nice code: + + +#include <cassert> + +#include <oln/basics2d.hh> +#include <oln/core/gen/pw_value.hh> + +#include <oln/morpher/add_isubset.hh> +#include <oln/morpher/add_neighborhood.hh> +#include <oln/morpher/count_rw.hh> + +#include <oln/debug/print.hh> +#include <oln/level/fill.hh> + + +template <typename I> +void test(const oln::abstract::image& input) +{ + oln_value(I) dev_null; + oln_piter(I) p(input.topo()); + oln_niter(I) n(p, input.topo()); + for_all(p) + { + std::cout < image_t; + + image_t ima(5, 5); + int values[] = + { 3, 7, 1, 1, 7, + 9, 3, 2, 1, 1, + 1, 6, 5, 4, 3, + 7, 9, 8, 1, 3, + 3, 3, 9, 7, 1 }; + ima << values; + +# define pred (pw_value(ima) % 2 == 0 or pw_value(ima) == 5) + + debug::print(ima | pred); + test(count_rw((ima + c4) | pred)); + + value::counter_rw::print(); + +// gives: +// - - - - - +// - - 2 - - +// - 6 5 4 - +// - - 8 - - +// - - - - - +// (1, 2): (2, 2) +// (2, 1): (2, 2) +// (2, 2): (1, 2) (2, 1) (2, 3) (3, 2) +// (2, 3): (2, 2) +// (3, 2): (2, 2) +// n_readwrite_calls = 0 +// n_readonly_calls = 8 +// n_reads = 8 +// n_writes = 0 + +*/ Index: oln/core/abstract/iterator_on_points.hh =================================================================== --- oln/core/abstract/iterator_on_points.hh (revision 677) +++ oln/core/abstract/iterator_on_points.hh (working copy) @@ -91,7 +91,10 @@ }; // end of class oln::abstract::iterator_on_points<E> + template <typename E> + std::ostream& operator<<(std::ostream& ostr, const iterator_on_points<E>& pit); + # ifndef OLN_INCLUDE_ONLY template <typename E> @@ -130,6 +133,13 @@ } + template <typename E> + std::ostream& operator<<(std::ostream& ostr, const iterator_on_points<E>& pit) + { + return ostr << pit.to_point(); + } + + # endif } // end of namespace oln::abstract Index: oln/core/abstract/image.hh =================================================================== --- oln/core/abstract/image.hh (revision 677) +++ oln/core/abstract/image.hh (working copy) @@ -40,6 +40,12 @@ namespace oln { + + // Fwd decl. + static unsigned& current_image_id(); + + + /*! \namespace oln::abstract ** \brief oln::abstract namespace. */ @@ -108,17 +114,26 @@ oln_rvalue(E) operator()(const oln_psite(E)& p) const; + unsigned id() const; + protected: - /*! \brief Constructor (protected, empty). + /*! \brief Constructors (protected). */ image(); - image(const image&); + image(const image& rhs); + /*! \brief Assignment (protected). + */ + E& operator=(const image& rhs); + /*! \brief Destructor. */ virtual ~image(); + private: + + const unsigned id_; }; @@ -139,17 +154,26 @@ template <typename E> image<E>::image() + : id_(++current_image_id()) { ++debug::n_images; } template <typename E> - image<E>::image(const image&) + image<E>::image(const image& rhs) + : id_(rhs.id_) { ++debug::n_images; } template <typename E> + E& image<E>::operator=(const image<E>& rhs) + { + this->id_ = rhs.id_; + return this->exact(); + } + + template <typename E> image<E>::~image() { decl(); @@ -157,6 +181,13 @@ } template <typename E> + unsigned + image<E>::id() const + { + return id_; + } + + template <typename E> const oln_topo(E)& image<E>::topo() const { @@ -176,6 +207,19 @@ } // end of namespace oln::abstract + + +# ifndef OLN_INCLUDE_ONLY + + static unsigned& current_image_id() + { + static unsigned id_ = 0; + return id_; + } + +# endif + + } // end of namespace oln Index: oln/core/gen/piter_isubset.hh =================================================================== --- oln/core/gen/piter_isubset.hh (revision 677) +++ oln/core/gen/piter_isubset.hh (working copy) @@ -97,7 +97,7 @@ protected: piter_t p_; - const isubset_t& isubset_; + isubset_t isubset_; // Cpy. }; // end of class oln::piter_isubset_<point> Index: oln/core/gen/pw_value.hh =================================================================== --- oln/core/gen/pw_value.hh (revision 677) +++ oln/core/gen/pw_value.hh (working copy) @@ -61,7 +61,7 @@ protected: - const I& ima_; + const I ima_; }; @@ -72,7 +72,8 @@ oln_rvalue(I) pw_value_type::impl_calc(const A& a) const { - mlc::assert_< mlc_is_a(A, oln::abstract::point) >::check(); + mlc::assert_< mlc::or_< mlc_is_a(A, oln::abstract::point), + mlc_is_a(A, oln::abstract::iterator_on_points) > >::check(); return ima_(a); } Index: oln/core/gen/topo_add_isubset.hh =================================================================== --- oln/core/gen/topo_add_isubset.hh (revision 677) +++ oln/core/gen/topo_add_isubset.hh (working copy) @@ -84,7 +84,7 @@ protected: topo_t topo_; - isubset_t isubset_; + isubset_t isubset_; // Cpy. }; Index: oln/core/gen/fwd_piter_bbox.hh =================================================================== --- oln/core/gen/fwd_piter_bbox.hh (revision 677) +++ oln/core/gen/fwd_piter_bbox.hh (working copy) @@ -79,11 +79,7 @@ }; // end of class oln::fwd_piter_bbox_<point> - template <typename point_t> - std::ostream& operator<<(std::ostream& ostr, const fwd_piter_bbox_<point_t>& t); - - # ifndef OLN_INCLUDE_ONLY template <typename point_t> @@ -100,14 +96,6 @@ << " }"; } - template <typename point_t> - std::ostream& operator<<(std::ostream& ostr, const fwd_piter_bbox_<point_t>& t) - { - t.print(ostr); - return ostr; - } - - # endif } // end of namespace oln Index: oln/core/gen/bkd_piter_bbox.hh =================================================================== --- oln/core/gen/bkd_piter_bbox.hh (revision 677) +++ oln/core/gen/bkd_piter_bbox.hh (working copy) @@ -79,11 +79,7 @@ }; // end of class oln::bkd_piter_bbox_<point_t> - template <typename point_t> - std::ostream& operator<<(std::ostream& ostr, const bkd_piter_bbox_<point_t>& t); - - # ifndef OLN_INCLUDE_ONLY template <typename point_t> @@ -100,13 +96,6 @@ << " }"; } - template <typename point_t> - std::ostream& operator<<(std::ostream& ostr, const bkd_piter_bbox_<point_t>& t) - { - t.print(ostr); - return ostr; - } - # endif } // end of namespace oln Index: oln/morpher/add_isubset.hh =================================================================== --- oln/morpher/add_isubset.hh (revision 677) +++ oln/morpher/add_isubset.hh (working copy) @@ -34,7 +34,10 @@ # include <oln/core/gen/topo_add_isubset.hh> # include <oln/core/gen/piter_isubset.hh> +# include <xtd/abstract/fun_nary_expr.hh> +# include <oln/core/gen/pw_value.hh> + namespace oln { @@ -124,7 +127,7 @@ super_t(image), topo_(image.topo(), isubset) { - mlc::assert_equal_<oln_type_of(Image, grid), oln_type_of(Isubset, grid)>::check(); + // mlc::assert_equal_<oln_type_of(Image, grid), oln_type_of(Isubset, grid)>::check(); // FIXME: check that Image is without a isubset } @@ -151,6 +154,13 @@ // FIXME: Add mutable version. + template <typename I, typename S> + morpher::add_isubset<I, S> + operator | (const abstract::image& image, + const xtd::abstract::fun_nary_expr_<1,S>& fsubset); + + + # ifndef OLN_INCLUDE_ONLY template <typename I, typename S> @@ -164,6 +174,15 @@ return tmp; } + template <typename I, typename S> + morpher::add_isubset<I, S> + operator | (const abstract::image& image, + const xtd::abstract::fun_nary_expr_<1,S>& fsubset) + { + morpher::add_isubset<I, S> tmp(image.exact(), fsubset.exact_()); + return tmp; + } + # endif } // end of namespace oln Index: oln/morpher/internal/image_value_morpher.hh =================================================================== --- oln/morpher/internal/image_value_morpher.hh (revision 677) +++ oln/morpher/internal/image_value_morpher.hh (working copy) @@ -96,7 +96,7 @@ Image& delegate(); protected: - Image& image_; + Image image_; }; Index: oln/morpher/internal/image_extension.hh =================================================================== --- oln/morpher/internal/image_extension.hh (revision 677) +++ oln/morpher/internal/image_extension.hh (working copy) @@ -86,6 +86,7 @@ // FIXME: Handle the constness. image_extension(const Image& image); + image_extension(Image& image); const Image& delegate() const; Image& delegate(); @@ -100,6 +101,12 @@ template <typename Image, typename Exact> image_extension<Image, Exact>::image_extension(const Image& image) : + image_(const_cast<Image&>(image)) + { + } + + template <typename Image, typename Exact> + image_extension<Image, Exact>::image_extension(Image& image) : image_(image) { } Index: oln/morpher/count_rw.hh =================================================================== --- oln/morpher/count_rw.hh (revision 677) +++ oln/morpher/count_rw.hh (working copy) @@ -39,22 +39,22 @@ namespace morpher { // Forward declaration. - template <typename Image> struct count_rw; + template <typename Image> struct count_rw_; } // end of namespace oln::morpher /// Super type. template <typename Image> - struct set_super_type< morpher::count_rw<Image> > + struct set_super_type< morpher::count_rw_<Image> > { - typedef morpher::count_rw<Image> self_t; + typedef morpher::count_rw_<Image> self_t; typedef morpher::internal::image_value_morpher<Image, self_t> ret; }; template <typename Image> - struct vtypes< morpher::count_rw<Image> > + struct vtypes< morpher::count_rw_<Image> > { public: typedef mlc::true_ is_computed_type; @@ -64,7 +64,7 @@ }; template <typename Image> - struct single_vtype< morpher::count_rw<Image>, typedef_::rvalue_type > + struct single_vtype< morpher::count_rw_<Image>, typedef_::rvalue_type > { typedef value::ro_counter<Image> ret; }; @@ -76,20 +76,20 @@ /// 'Image thru Function' morpher. template <typename Image> - class count_rw : public internal::image_value_morpher< Image, - morpher::count_rw<Image> > + class count_rw_ : public internal::image_value_morpher< Image, + morpher::count_rw_<Image> > { private: - typedef count_rw<Image> self_t; + typedef count_rw_<Image> self_t; typedef internal::image_value_morpher<Image, self_t> super_t; using super_t::image_; public: - count_rw(Image& image); - count_rw(oln::abstract::mutable_image<Image>& image); + count_rw_(Image& image); + count_rw_(oln::abstract::mutable_image<Image>& image); oln_rvalue(self_t) impl_op_read(const oln_psite(self_t)& p) const; oln_lvalue(self_t) impl_op_readwrite(const oln_psite(self_t)& p); @@ -109,28 +109,28 @@ // public template <typename Image> - count_rw<Image>::count_rw(Image& image) : + count_rw_<Image>::count_rw_(Image& image) : super_t(image) { } template <typename Image> - count_rw<Image>::count_rw(oln::abstract::mutable_image<Image>& image) : + count_rw_<Image>::count_rw_(oln::abstract::mutable_image<Image>& image) : super_t(image.exact()) { } template <typename Image> - oln_rvalue(count_rw<Image>) - count_rw<Image>::impl_op_read(const oln_psite(count_rw<Image>)& p) const + oln_rvalue(count_rw_<Image>) + count_rw_<Image>::impl_op_read(const oln_psite(count_rw_<Image>)& p) const { value::ro_counter<Image> tmp(image_, p); return tmp; } template <typename Image> - oln_lvalue(count_rw<Image>) - count_rw<Image>::impl_op_readwrite(const oln_psite(count_rw<Image>)& p) + oln_lvalue(count_rw_<Image>) + count_rw_<Image>::impl_op_readwrite(const oln_psite(count_rw_<Image>)& p) { value::rw_counter<Image> tmp(image_, p); return tmp; @@ -142,14 +142,24 @@ template <typename I> - morpher::count_rw + morpher::count_rw_ count_rw(oln::abstract::mutable_image& input) { - morpher::count_rw tmp(input.exact()); + morpher::count_rw_ tmp(input.exact()); return tmp; } + template <typename I> + morpher::count_rw_ + count_rw(const oln::abstract::mutable_image& input) + { + // FIXME: Hack. + I& input_ = const_cast<I&>(input.exact()); + morpher::count_rw_ tmp(input_); + return tmp; + } + } // end of namespace oln Index: oln/value/rw_counter.hh =================================================================== --- oln/value/rw_counter.hh (revision 677) +++ oln/value/rw_counter.hh (working copy) @@ -30,6 +30,7 @@ # include <iostream> # include <map> +# include <set> # include <oln/value/proxy.hh> # include <oln/core/abstract/image/all.hh> @@ -42,45 +43,80 @@ { - struct counter + struct counter_rw { - typedef std::map<void*, unsigned> map_t; + typedef std::map<unsigned, unsigned> map_t; + typedef std::set<unsigned> set_t; + static map_t n_rwc_; + static map_t n_roc_; + static map_t n_r_; + static map_t n_w_; + static set_t ids_; // read-write call - static unsigned& n_readwrite_calls(const oln::type& ima) + template <typename I> + static unsigned& n_readwrite_calls(const oln::abstract::image& ima) { - static map_t n; - return n[(void*)(&ima)]; + ids_.insert(ima.id()); + return n_rwc_[ima.id()]; } // read-only call - static unsigned& n_readonly_calls(const oln::type& ima) + template <typename I> + static unsigned& n_readonly_calls(const oln::abstract::image& ima) { - static map_t n; - return n[(void*)(&ima)]; + ids_.insert(ima.id()); + return n_roc_[ima.id()]; } // read (effective) - static unsigned& n_reads(const oln::type& ima) + template <typename I> + static unsigned& n_reads(const oln::abstract::image& ima) { - static map_t n; - return n[(void*)(&ima)]; + ids_.insert(ima.id()); + return n_r_[ima.id()]; } // write (effective) - static unsigned& n_writes(const oln::type& ima) + template <typename I> + static unsigned& n_writes(const oln::abstract::image& ima) { - static map_t n; - return n[(void*)(&ima)]; + ids_.insert(ima.id()); + return n_w_[ima.id()]; } - static void print(const oln::type& ima) + static void print(unsigned id) { - std::cout << "n_readwrite_calls = " << n_readwrite_calls(ima) << std::endl - << "n_readonly_calls = " << n_readonly_calls(ima) << std::endl - << "n_reads = " << n_reads(ima) << std::endl - << "n_writes = " << n_writes(ima) << std::endl; + ids_.insert(id); + std::cout << "n_readwrite_calls = " << n_rwc_[id] << std::endl + << "n_readonly_calls = " << n_roc_[id] << std::endl + << "n_reads = " << n_r_[id] << std::endl + << "n_writes = " << n_w_[id] << std::endl; } + + template <typename I> + static void print(const oln::abstract::image& ima) + { + print(ima.id()); + } + + static void print() + { + set_t::const_iterator it; + for (it = ids_.begin(); it != ids_.end(); ++it) + print(*it); + } }; +# ifndef OLN_INCLUDE_ONLY + + counter_rw::map_t counter_rw::n_rwc_; + counter_rw::map_t counter_rw::n_roc_; + counter_rw::map_t counter_rw::n_r_; + counter_rw::map_t counter_rw::n_w_; + counter_rw::set_t counter_rw::ids_; + +# endif + + template <typename I> class rw_counter : public abstract::proxy< rw_counter > { @@ -104,7 +140,7 @@ rw_counter& operator=(const V& value); protected: - I& ima_; + I ima_; const oln_psite(I)& p_; }; @@ -132,7 +168,7 @@ oln_rvalue(I) value() const; protected: - const I& ima_; + const I ima_; const oln_psite(I)& p_; }; @@ -151,7 +187,7 @@ : ima_(ima.exact()), p_(p) { - ++counter::n_readwrite_calls(ima_); + ++counter_rw::n_readwrite_calls(ima_); } // Read. @@ -159,7 +195,7 @@ template <typename V> rw_counter::operator V() const { - ++counter::n_reads(ima_); + ++counter_rw::n_reads(ima_); V tmp = ima_(p_); return tmp; } @@ -169,7 +205,7 @@ oln_rvalue(I) rw_counter::value() const { - ++counter::n_reads(ima_); + ++counter_rw::n_reads(ima_); return ima_(p_); } @@ -181,7 +217,7 @@ rw_counter::operator=(const V& value) { ima_(p_) = value; - ++counter::n_writes(ima_); + ++counter_rw::n_writes(ima_); return *this; } @@ -201,7 +237,7 @@ : ima_(ima.exact()), p_(p) { - ++counter::n_readonly_calls(ima_); + ++counter_rw::n_readonly_calls(ima_); } // Read. @@ -209,7 +245,7 @@ template <typename V> ro_counter::operator V() const { - ++counter::n_reads(ima_); + ++counter_rw::n_reads(ima_); V tmp = ima_(p_); return tmp; } @@ -219,7 +255,7 @@ oln_rvalue(I) ro_counter::value() const { - ++counter::n_reads(ima_); + ++counter_rw::n_reads(ima_); return ima_(p_); }

1 0