Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

proto-1.0 89: Add delta to structuring element and neighborhood

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/core/abstract/struct_elt.hh: Add delta to stucturing element.. * oln/core/2d/window2d.hh: Likewise. * oln/core/abstract/neighborhood.hh: Add delta to neighborhood. * oln/core/2d/neighborhood2d.hh: Likewise. * oln/core/accum.hh: New. Accumulator needed for delta computation. * oln/makefile.src: Add missing files. core/2d/neighborhood2d.hh | 25 ++++++++++------ core/2d/window2d.hh | 10 +++++- core/abstract/neighborhood.hh | 27 +++++++++++++++-- core/abstract/struct_elt.hh | 25 ++++++++++++++-- core/accum.hh | 65 ++++++++++++++++++++++++++++++++++++++++++ makefile.src | 4 ++ 6 files changed, 140 insertions(+), 16 deletions(-) Index: oln/core/abstract/struct_elt.hh --- oln/core/abstract/struct_elt.hh (revision 88) +++ oln/core/abstract/struct_elt.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/properties.hh> # include <oln/core/coord.hh> # include <oln/core/abstract/dpoint.hh> +# include <oln/core/accum.hh> # include <vector> # include <utility> # include <iostream> @@ -132,6 +133,18 @@ return this->exact().impl_at(i); } + coord_t + get_delta() const + { + return this->exact().impl_get_delta(); + } + + coord_t + delta_update(const dpoint_type& dp) + { + return this->exact().impl_delta_update(dp); + } + protected: bool @@ -145,9 +158,16 @@ { if (!(impl_has(dp))) this->dp_.push_back(dp); + this->delta_update(dp); return this->exact(); } + coord_t + impl_get_delta() const + { + return delta_; + } + unsigned impl_card() const { @@ -161,15 +181,16 @@ return dp_[i]; } - struct_elt() : dp_() + struct_elt() : dp_(), delta_(0) {}; - struct_elt(unsigned size) : dp_() + struct_elt(unsigned size) : dp_(), delta_(0) { dp_.reserve(size); }; std::vector<dpoint_type> dp_; + max_accumulator<coord_t> delta_; }; } // end of abstract Index: oln/core/abstract/neighborhood.hh --- oln/core/abstract/neighborhood.hh (revision 88) +++ oln/core/abstract/neighborhood.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/properties.hh> # include <oln/core/coord.hh> # include <oln/core/abstract/dpoint.hh> +# include <oln/core/accum.hh> # include <vector> # include <utility> # include <iostream> @@ -129,6 +130,18 @@ return this->exact().impl_at(i); } + coord_t + get_delta() const + { + return this->exact().impl_get_delta(); + } + + coord_t + delta_update(const dpoint_type& dp) + { + return this->exact().impl_delta_update(dp); + } + protected: bool @@ -145,9 +158,16 @@ this->dp_.push_back(dp); this->dp_.push_back(-dp); } + this->delta_update(dp); return this->exact(); } - + + coord_t + impl_get_delta() const + { + return delta_; + } + unsigned impl_card() const { @@ -161,15 +181,16 @@ return dp_[i]; } - neighborhood() : dp_() + neighborhood() : dp_(), delta_(0) {}; - neighborhood(unsigned size) : dp_() + neighborhood(unsigned size) : dp_(), delta_(0) { dp_.reserve(size); }; std::vector<dpoint_type> dp_; + max_accumulator<coord_t> delta_; }; } // end of abstract Index: oln/core/2d/neighborhood2d.hh --- oln/core/2d/neighborhood2d.hh (revision 88) +++ oln/core/2d/neighborhood2d.hh (working copy) @@ -31,7 +31,7 @@ # include <oln/core/2d/dpoint2d.hh> # include <oln/core/2d/size2d.hh> # include <oln/core/coord.hh> -# include <oln/core/abstract/struct_elt.hh> +# include <oln/core/abstract/neighborhood.hh> namespace oln { @@ -39,29 +39,30 @@ // category template <> - struct set_category< neighborhood2d > { typedef category::struct_elt ret; }; + struct set_category< neighborhood2d > + { typedef category::neighborhood ret; }; // super_type template <> struct set_super_type< neighborhood2d > { - typedef abstract::struct_elt< neighborhood2d > ret; + typedef abstract::neighborhood< neighborhood2d > ret; }; template <> - struct set_props< category::struct_elt, neighborhood2d > - : public props_of<category::struct_elt> + struct set_props< category::neighborhood, neighborhood2d > + : public props_of<category::neighborhood> { typedef dpoint2d dpoint_type; typedef size2d size_type; }; - class neighborhood2d : public abstract::struct_elt<neighborhood2d> + class neighborhood2d : public abstract::neighborhood<neighborhood2d> { public: - typedef abstract::struct_elt<neighborhood2d> super_type; + typedef abstract::neighborhood<neighborhood2d> super_type; /*! ** \brief Construct a neighborhood of 2 dimensions. @@ -108,8 +109,14 @@ return std::string("neighborhood2d"); } - protected: - + coord_t + impl_delta_update(const dpoint_type& dp) + { + delta_(abs(dp.row())); + delta_(abs(dp.col())); + return delta_; + } + }; inline const neighborhood2d& Index: oln/core/2d/window2d.hh --- oln/core/2d/window2d.hh (revision 88) +++ oln/core/2d/window2d.hh (working copy) @@ -110,8 +110,14 @@ return std::string("window2d"); } - protected: - + coord_t + impl_delta_update(const dpoint_type& dp) + { + delta_(abs(dp.row())); + delta_(abs(dp.col())); + return delta_; + } + }; Index: oln/core/accum.hh --- oln/core/accum.hh (revision 0) +++ oln/core/accum.hh (revision 0) @@ -0,0 +1,65 @@ +// Copyright (C) 2001, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ACCUM_HH +# define OLENA_CORE_ACCUM_HH + + +/*! \class max_accumulator +** +** This is a \a functor. It saves the maximum T value +** that has been passed as an argument of its operator() +** method. To retrieve the value saved, just use the +** max_accumulator as a T instance. +*/ + +template <class T> +struct max_accumulator +{ + + max_accumulator (T t) : acc_(t) + {} + + void + operator()(T t) + { + if (t > acc_) + acc_ = t; + } + + operator T() const + { + return acc_; + } + +private: + + T acc_; + +}; + +#endif // OLENA_CORE_ACCUM_HH Index: oln/makefile.src --- oln/makefile.src (revision 88) +++ oln/makefile.src (working copy) @@ -11,6 +11,9 @@ basics3d.hh \ config/pconf.hh \ config/system.hh \ + convert/value_to_point.hh \ + morpho/stat.hh \ + morpho/erosion.hh \ core/1d/array1d.hh \ core/1d/dpoint1d.hh \ core/1d/fwd_piter1d.hh \ @@ -50,6 +53,7 @@ core/abstract/size.hh \ core/abstract/neighborhood.hh \ core/abstract/struct_elt.hh \ + core/accum.hh \ core/coord.hh \ core/compose.hh \ core/properties.hh \

19 years, 9 months

proto-1.0 88: Activate testsuite for convert and morpho

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * configure.ac: Activate test suite for morpho and convert. configure.ac | 2 ++ 1 files changed, 2 insertions(+) Index: configure.ac --- configure.ac (revision 86) +++ configure.ac (working copy) @@ -99,9 +99,11 @@ # OLN_TESTS defined in oln-local.m4 OLN_TESTS([sanity]) + OLN_TESTS([convert]) OLN_TESTS([core]) OLN_TESTS([io]) OLN_TESTS([level]) + OLN_TESTS([morpho]) OLN_TESTS([utils]) AC_SUBST([OLN_TESTS_SUBDIRS])

19 years, 9 months

proto-1.0 87: Add temporary conversion of value to point

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/convert/value_to_point.hh: New. Conversion of value to point. This is temporary: waiting for a coherent `convert' in this prototype. * tests/convert/tests/value_to_point: New. * tests/convert: New. * tests/convert/tests: New. * tests/convert/Makefile.am: New. * oln/convert: New. oln/convert/value_to_point.hh | 106 +++++++++++++++++++++++++++++++++++++ tests/convert/Makefile.am | 5 + tests/convert/tests/value_to_point | 27 +++++++++ 3 files changed, 138 insertions(+) Index: tests/convert/tests/value_to_point --- tests/convert/tests/value_to_point (revision 0) +++ tests/convert/tests/value_to_point (revision 0) @@ -0,0 +1,27 @@ + +#include <iostream> + +#include <ntg/basics.hh> +#include <ntg/color.hh> +#include <oln/convert/value_to_point.hh> + +#include "check.hh" +#include "data.hh" + +bool check() +{ + oln::point1d p = oln::convert::value_to_point(42u); + oln::point3d p2 = oln::convert::value_to_point(ntg::rgb_8(1,6,64)); + std::cout << p.index() << std::endl; + std::cout << p2.row() << std::endl; + std::cout << p2.col() << std::endl; + std::cout << p2.slice() << std::endl; + std::cout << p2 << std::endl; +fdas + if (p.index() != 42 || + p2.row() != 6 || + p2.col() != 64 || + p2.slice() != 1) + return true; + return false; +} Index: tests/convert/Makefile.am --- tests/convert/Makefile.am (revision 0) +++ tests/convert/Makefile.am (revision 0) @@ -0,0 +1,5 @@ +include ../check/Makefile.runtests +include ../check/Makefile.check + + +check-local: check-runtests Index: oln/convert/value_to_point.hh --- oln/convert/value_to_point.hh (revision 0) +++ oln/convert/value_to_point.hh (revision 0) @@ -0,0 +1,106 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_VALUE_TO_POINT +# define OLENA_VALUE_TO_POINT + +# include <ntg/basics.hh> + +# include <oln/core/1d/point1d.hh> +# include <oln/core/3d/point3d.hh> + +// FIXME: waiting for a coherent convert. + +namespace oln { + + namespace convert { + /*! Convert a value of pixel to a point. + ** + ** For example, transform an RGB color to a 3D point + ** (ntg::rgb_8 => oln::point3d). + ** This function is useful to build the histogram. \n + ** Example: + ** \verbatim + ** f(oln::convert::value_to_point<ntg::rgb_8>()(ntg::rgb_8(1,6,64))); + ** // is equivalent to: + ** f(oln::point3d(1, 6, 64)); + ** \endverbatim + */ + + namespace internal { + + template <typename ValueType> + struct value_to_point + { + typedef ValueType value_type; + typedef point1d point_type; + + value_to_point(const value_type& v) + : v_(v) + {} + + operator point_type() + { + return point1d(v_ - ntg_min_val(value_type)); + } + + const value_type& v_; + }; + + template <unsigned Qbits, template <unsigned> class S> + struct value_to_point< ntg::color<3, Qbits, S> > + { + typedef ntg::color<3, Qbits, S> value_type; + typedef point3d point_type; + + value_to_point(const value_type& v) + : v_(v) + {} + + operator point_type() + { + return point_type(coord_t(v_[0]), coord_t(v_[1]), coord_t(v_[2])); + } + + const value_type& v_; + }; + + + } + + template <typename ValueType> + typename internal::value_to_point<ValueType>::point_type + value_to_point(const ValueType& v) + { + return internal::value_to_point<ValueType>(v); + } + + } // convert + +} // oln + +#endif

19 years, 9 months

proto-1.0 86: Add morpho min and max

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/morpho: New. * oln/morpho/stat.hh: New. Add morphological min and max. * oln/core/abstract/piter.hh: Add `for_all_remaining' macro. * oln/core/abstract/point.hh: Fix a return type (was abstract). * tests/morpho: New. Add test suite for morpho. * tests/morpho/tests: New. Likewise. * tests/morpho/Makefile.am: New. Likewise. * oln/basics.hh: Add headers. oln/basics.hh | 2 oln/core/abstract/piter.hh | 6 + oln/core/abstract/point.hh | 4 oln/morpho/stat.hh | 185 +++++++++++++++++++++++++++++++++++++++++++++ tests/morpho/Makefile.am | 1 5 files changed, 196 insertions(+), 2 deletions(-) Index: tests/morpho/Makefile.am --- tests/morpho/Makefile.am (revision 0) +++ tests/morpho/Makefile.am (revision 0) @@ -0,0 +1 @@ +include ../check/Makefile.runtests Index: oln/basics.hh --- oln/basics.hh (revision 85) +++ oln/basics.hh (working copy) @@ -57,8 +57,10 @@ # include <oln/core/abstract/size.hh> # include <oln/core/abstract/point.hh> # include <oln/core/abstract/images.hh> +# include <oln/core/abstract/entry.hh> # include <oln/core/abstract/piter.hh> +# include <oln/core/abstract/witer.hh> // # include <oln/core/abstract/niter.hh> # include <oln/core/abstract/struct_elt.hh> Index: oln/morpho/stat.hh --- oln/morpho/stat.hh (revision 0) +++ oln/morpho/stat.hh (revision 0) @@ -0,0 +1,185 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_STAT_HH +# define OLENA_MORPHO_STAT_HH + +# include <oln/basics.hh> +# include <ntg/bin.hh> + +namespace oln { + + namespace morpho { + + namespace internal { + + /*! + ** \brief Min and Max on a structuring element. + ** + ** We need to use this inner definition in order to specialize + ** max and min on binary images. + ** + ** \param I Image exact type. + ** \param E Structuring element type. + ** \param V Associated value type. + */ + template <class I, class E, class V =oln_type_of(I, value)> + struct stat_ + { + /*! + ** \brief Maximum of a structuring element. + ** + ** Look for the maximum in the structuring element se disposed + ** on the image input, at the point p. + ** + ** \arg input Input image. + ** \arg p Point of the image to move the structuring element on. + ** \arg se The structuring element to use. + */ + static V + max(const I& input, const oln_type_of(I, point)& p, const E& se) + { + // FIXME: test dim I == dim E + + oln_type_of(E, fwd_witer) dp(se); + dp.start(); + V val = input[p + dp]; + for_all_remaining (dp) + if (val < input[p + dp].value()) + val = input[p + dp].value(); + return val; + } + + /*! + ** \brief Minimum of a structuring element. + ** + ** Look for the minimum in the structuring element se disposed + ** on the image input, at the point p. + ** + ** \arg input Input image. + ** \arg p Point of the image to move the structuring element on. + ** \arg se The structuring element to use. + */ + static V + min(const I& input, const oln_type_of(I, point)& p, const E& se) + { + // FIXME: test dim I == dim E + + oln_type_of(E, fwd_witer) dp(se); + dp.start(); + V val = input[p + dp]; + for_all_remaining (dp) + if (val > input[p + dp].value()) + val = input[p + dp].value(); + return val; + } + + }; + + /* Binary specialization. */ + + template <class I, class E> + struct stat_<I, E, ntg::bin> + { + static ntg::bin + max(const I& input, const oln_type_of(I, point)& p, const E& se) + { + mlc::eq<I::dim, E::dim>::ensure(); + oln_type_of(E, fwd_witer) dp(se); + for_all (dp) + if (input[p + dp] == true) + return true; + return false; + } + + static ntg::bin + min(const I& input, const oln_type_of(I, point)& p, const E& se) + { + mlc::eq<I::dim, E::dim>::ensure(); + oln_type_of(E, fwd_witer) dp(se); + for_all (dp) + if (input[p + dp] == false) + return false; + return true; + } + + }; + + } // internal + + /*! + ** \brief Maximum of a structuring element. + ** + ** Look for the maximum in the structuring element se disposed + ** on the image input, at the point p. + ** + ** \param I Image exact type. + ** \param E Structuring element type. + ** + ** \arg input Input image. + ** \arg p Point of the image to move the structuring element on. + ** \arg se The structuring element to use. + */ + template<class I, class E> + oln_type_of(I, value) + max(const abstract::non_vectorial_image& input, + const oln_type_of(I, point)& p, + const abstract::struct_elt<E>& se) + { + // FIXME: test dim I == dim E + return internal::stat_<I, E>::max(input.exact(), p, se.exact()); + } + + /*! ** \brief Minimum of a structuring element. + ** + ** Look for the minimum in the structuring element se disposed + ** on the image input, at the point p. + ** + ** \param I Image exact type. + ** \param E Structuring element type. + ** + ** \arg input Input image. + ** \arg p Point of the image to move the structuring element on. + ** \arg se The structuring element to use. + */ + template<class I, class E> + oln_type_of(I, value) + min(const abstract::non_vectorial_image& input, + const oln_type_of(I, point)& p, + // const mlc_exact_type(I)::iter_type& p, + const abstract::struct_elt<E>& se) + { + // FIXME: test dim I == dim E + return internal::stat_<I, E>::min(input.exact(), p, se.exact()); + } + + } // end of namespace morpho + +} // end of namespace oln + + +#endif // ! OLENA_MORPHO_STAT_HH Index: oln/core/abstract/piter.hh --- oln/core/abstract/piter.hh (revision 85) +++ oln/core/abstract/piter.hh (working copy) @@ -37,9 +37,13 @@ -# define for_all(p) for(p.start(); p.is_valid(); p.next()) +# define for_all(p) \ + for(p.start(); p.is_valid(); p.next()) +# define for_all_remaining(p) \ + for(; p.is_valid(); p.next()) + namespace oln { // fwd decl Index: oln/core/abstract/point.hh --- oln/core/abstract/point.hh (revision 85) +++ oln/core/abstract/point.hh (working copy) @@ -87,6 +87,8 @@ struct point : public mlc::any__best_memory<E> { + typedef E exact_type; + /*! \brief Test equality of two points. Nota bene: this method ** is abstract-like. ** @@ -111,7 +113,7 @@ typedef oln_type_of(E, dpoint) dpoint_type; - const point operator+(const dpoint_type& dp) const + const exact_type operator+(const dpoint_type& dp) const { return this->exact().impl_plus(dp); }

19 years, 9 months

proto-1.0 85: Add window iterator (missing file)

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/core/2d/fwd_witer2d.hh: New. Forward window iterator in 2d. fwd_witer2d.hh | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 68 insertions(+) Index: oln/core/2d/fwd_witer2d.hh --- oln/core/2d/fwd_witer2d.hh (revision 0) +++ oln/core/2d/fwd_witer2d.hh (revision 0) @@ -0,0 +1,68 @@ +// Copyright (C) 2001, 2003, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_FWD_WITER2D_HH +# define OLENA_CORE_FWD_WITER2D_HH + +# include <oln/core/abstract/witer.hh> +# include <oln/core/2d/window2d.hh> + +# include <string> + +namespace oln { + + // fwd decl + struct fwd_witer2d; + + // category + template <> + struct set_category<fwd_witer2d> { typedef category::witer ret; }; + + // props + template <> + struct set_props < category::witer, fwd_witer2d > : public props_of<category::witer> + { + typedef window2d se_type; + }; + + struct fwd_witer2d : public abstract::witer< fwd_witer2d > + { + + typedef abstract::witer<fwd_witer2d> super_type; + + fwd_witer2d(const se_type& se) : + super_type(se) + { + this->exact_ptr = this; + this->invalidate(); + } + + }; + +} // oln + +#endif // OLENA_CORE_FWD_WITER2D_HH

19 years, 9 months

proto-1.0 84: Add windows iterator

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/core/tests/fwd_witer2d: New. Test for forward window iterator in 2d. * oln/makefile.src: Add new headers. * oln/core/abstract/struct_elt.hh: Fix a bad prototype. * oln/core/abstract/neighborhood.hh: Likewise. * oln/core/abstract/witer.hh: New. Add window iterator. * oln/core/2d/window2d.hh: Add `fwd_witer' property.. * oln/core/properties.hh: Likewise. * oln/basics2d.hh: Add new headers. oln/basics2d.hh | 1 oln/core/2d/window2d.hh | 2 oln/core/abstract/neighborhood.hh | 2 oln/core/abstract/struct_elt.hh | 5 + oln/core/abstract/witer.hh | 142 ++++++++++++++++++++++++++++++++++++++ oln/core/properties.hh | 3 oln/makefile.src | 2 tests/core/tests/fwd_witer2d | 25 ++++++ 8 files changed, 180 insertions(+), 2 deletions(-) Index: tests/core/tests/fwd_witer2d --- tests/core/tests/fwd_witer2d (revision 0) +++ tests/core/tests/fwd_witer2d (revision 0) @@ -0,0 +1,25 @@ +#include <oln/core/2d/fwd_witer2d.hh> +#include <oln/core/abstract/piter.hh> + +#include <ntg/all.hh> + +#include <cassert> + +using namespace oln; +using namespace ntg; + +template <typename E> +bool foo(const E& w) +{ + oln_type_of(E, fwd_witer) i(w); + unsigned cpt = 0; + for_all(i) + ++cpt; + return not (cpt == w.card()); +} + +int main() +{ + window2d w = win_c8p(); + return foo(w); +} Index: oln/makefile.src --- oln/makefile.src (revision 83) +++ oln/makefile.src (working copy) @@ -25,6 +25,7 @@ core/2d/point2d.hh \ core/2d/size2d.hh \ core/2d/neighborhood2d.hh \ + core/2d/fwd_witer2d.hh \ core/2d/window2d.hh \ core/3d/array3d.hh \ core/3d/fwd_piter3d.hh \ @@ -44,6 +45,7 @@ core/abstract/internal/image_impl.hh \ core/abstract/op.hh \ core/abstract/piter.hh \ + core/abstract/witer.hh \ core/abstract/point.hh \ core/abstract/size.hh \ core/abstract/neighborhood.hh \ Index: oln/core/abstract/struct_elt.hh --- oln/core/abstract/struct_elt.hh (revision 83) +++ oln/core/abstract/struct_elt.hh (working copy) @@ -60,12 +60,14 @@ mlc_decl_prop(category::struct_elt, dpoint_type); mlc_decl_prop(category::struct_elt, size_type); + mlc_decl_prop(category::struct_elt, fwd_witer_type); static void echo(std::ostream& ostr) { ostr << "props_of( category::struct_elt, " << typeid(type).name() << ") = {" << " size_type = " << typeid(size_type).name() << "," << std::endl + << " fwd_witer_type = " << typeid(fwd_witer_type).name() << "," << std::endl << " dpoint_type = " << typeid(dpoint_type).name() << " }" << std::endl; } @@ -73,6 +75,7 @@ mlc_register_prop(category::struct_elt, dpoint_type); mlc_register_prop(category::struct_elt, size_type); + mlc_register_prop(category::struct_elt, fwd_witer_type); namespace abstract { @@ -100,7 +103,7 @@ } bool - has(const abstract::dpoint<dpoint_type>& dp) const + has(const dpoint_type& dp) const { return this->exact().impl_has(dp.exact()); } Index: oln/core/abstract/witer.hh --- oln/core/abstract/witer.hh (revision 0) +++ oln/core/abstract/witer.hh (revision 0) @@ -0,0 +1,142 @@ +// Copyright (C) 2001, 2003, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_WITER_HH +# define OLENA_CORE_ABSTRACT_WITER_HH + +# include <mlc/any.hh> +# include <mlc/types.hh> + +# include <oln/core/properties.hh> + +# include <string> + +namespace oln { + + // fwd decl + namespace abstract { + template <typename E> struct witer; + } + + // category + template <typename E> + struct set_category< abstract::witer<E> > { typedef category::witer ret; }; + + /// properties of any type in category::witer + // + template <typename type> + struct props_of < category::witer, type > + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::witer, se_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::witer, " + << typeid(type).name() << ") = {" + << " se_type = " << typeid(se_type).name() + << " }" << std::endl; + } + }; + + mlc_register_prop(category::witer, se_type); + + namespace abstract { + + template <typename E> + struct witer : public mlc::any__best_speed<E> + { + + typedef witer<E> self_type; + + typedef oln_type_of(E, se) se_type; + typedef oln_type_of(se_type, dpoint) dpoint_type; + + void start() + { + this->exact().impl_start(); + } + + void next() + { + precondition(this->is_valid()); + this->exact().impl_next(); + } + + bool is_valid() const + { + return this->exact().impl_is_valid(); + } + + operator dpoint_type() const + { + precondition(this->is_valid()); + return this->se_[pos_]; + } + + void invalidate() + { + this->exact().impl_invalidate(); + postcondition(! this->is_valid()); + } + + protected: + + void impl_start() + { + pos_ = 0; + } + + void impl_next() + { + ++pos_; + } + + bool impl_is_valid() const + { + return pos_ != se_.card(); + } + + void impl_invalidate() + { + pos_ = se_.card(); + } + + witer(const se_type& se) + : se_(se), pos_(0) + {} + + const se_type& se_; + unsigned pos_; + }; + + } // abstract + +} // oln + +#endif // OLENA_CORE_ABSTRACT_WITER_HH Index: oln/core/abstract/neighborhood.hh --- oln/core/abstract/neighborhood.hh (revision 83) +++ oln/core/abstract/neighborhood.hh (working copy) @@ -100,7 +100,7 @@ } bool - has(const abstract::dpoint<dpoint_type>& dp) const + has(const dpoint_type& dp) const { return this->exact().impl_has(dp.exact()); } Index: oln/core/2d/window2d.hh --- oln/core/2d/window2d.hh (revision 83) +++ oln/core/2d/window2d.hh (working copy) @@ -36,6 +36,7 @@ namespace oln { class window2d; // forward declaration + class fwd_witer2d; // category template <> @@ -54,6 +55,7 @@ { typedef dpoint2d dpoint_type; typedef size2d size_type; + typedef fwd_witer2d fwd_witer_type; }; class window2d : public abstract::struct_elt<window2d> Index: oln/core/properties.hh --- oln/core/properties.hh (revision 83) +++ oln/core/properties.hh (working copy) @@ -46,6 +46,7 @@ struct point; struct size; struct piter; + struct witer; struct niter; // FIXME: ... } @@ -60,9 +61,11 @@ struct dpoint_type; struct fwd_piter_type; struct bkd_piter_type; + struct fwd_witer_type; struct iter_type; struct delegated_type; struct size_type; + struct se_type; struct image_constness_type; struct image_dimension_type; Index: oln/basics2d.hh --- oln/basics2d.hh (revision 83) +++ oln/basics2d.hh (working copy) @@ -35,6 +35,7 @@ # include <oln/core/2d/size2d.hh> # include <oln/core/2d/point2d.hh> # include <oln/core/2d/image2d.hh> +# include <oln/core/2d/fwd_witer2d.hh> # include <oln/core/2d/window2d.hh> # include <oln/core/2d/neighborhood2d.hh>

19 years, 9 months

proto-1.0 77: Add function composition

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/makefile.src: Add compose.hh. * oln/core/compose.hh: New. core/compose.hh | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ makefile.src | 3 2 files changed, 172 insertions(+), 1 deletion(-) Index: oln/makefile.src --- oln/makefile.src (revision 76) +++ oln/makefile.src (working copy) @@ -45,8 +45,9 @@ core/abstract/point.hh \ core/abstract/size.hh \ core/abstract/neighborhood.hh \ - core/abstract/window.hh \ + core/abstract/struct_elt.hh \ core/coord.hh \ + core/compose.hh \ core/properties.hh \ core/value_box.hh \ fancy/iota.hh \ Index: oln/core/compose.hh --- oln/core/compose.hh (revision 0) +++ oln/core/compose.hh (revision 0) @@ -0,0 +1,170 @@ +// Copyright (C) 2001, 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_COMPOSE_HH +# define OLENA_CORE_COMPOSE_HH + +# include <functional> + +namespace oln { + + namespace internal { + + /*! \class compose_uu_ + ** + ** The operator () of this class performs a composition between + ** two unary functors \a F1 & \a F2. + */ + + template< class F1, class F2 > + struct compose_uu_ : + public std::unary_function <typename F2::argument_type, + typename F1::result_type> + { + typedef compose_uu_ self_type; + + typename self_type::result_type + operator()(typename self_type::argument_type arg) const + { + return f1_(f2_(arg)); + } + + compose_uu_(const F1& f1, const F2& f2) : f1_(f1), f2_(f2) {} + + private: + + const F1 f1_; + const F2 f2_; + + }; + + /*! \class compose_ub_ + ** + ** The operator () of this class performs a composition between + ** a unary functor \a F1 and a binary functor \a F2. + */ + + + template< class F1, class F2 > + struct compose_ub_ : + public std::binary_function <typename F2::first_argument_type, + typename F2::second_argument_type, + typename F1::result_type> + { + typedef compose_ub_ self_type; + + typename self_type::result_type + operator()(typename self_type::first_argument_type arg1, + typename self_type::second_argument_type arg2) const + { + return f1_(f2_(arg1, arg2)); + } + + compose_ub_(const F1& f1, const F2& f2) : f1_(f1), f2_(f2) {} + + private: + + const F1 f1_; + const F2 f2_; + + }; + + /*! \class compose_bu_ + ** + ** The operator () of this class performs a composition between + ** a binary functor \a F1 and an unary functor \a F2. + */ + + template< class F1, class F2 > + struct compose_bu_ : + public std::binary_function <typename F2::argument_type, + typename F2::argument_type, + typename F1::result_type> + { + typedef compose_bu_ self_type; + + typename self_type::result_type + operator()(typename self_type::first_argument_type arg1, + typename self_type::second_argument_type arg2) const + { + return f1_(f2_(arg1), f2_(arg2)); + } + + compose_bu_(const F1& f1, const F2& f2) : f1_(f1), f2_(f2) {} + + private: + + const F1 f1_; + const F2 f2_; + + }; + + } + + + /// Compose two unary functors \a F1 & \a F2. + template<class UF1, class UF2> + internal::compose_uu_<UF1, UF2> + compose_uu(const UF1& f1, const UF2& f2) + { + return internal::compose_uu_<UF1, UF2>(f1, f2); + } + + /// Compose a unary functor \a F1 with a binary functor \a F2. + template<class UF1, class BF2> + internal::compose_ub_<UF1, BF2> + compose_ub(const UF1& f1, const BF2& f2) + { + return internal::compose_ub_<UF1, BF2>(f1, f2); + } + + /// Compose a binary functor \a F1 and an unary functor \a F2. + template<class BF1, class UF2> + internal::compose_bu_<BF1, UF2> + compose_bu(const BF1& f1, const UF2& f2) + { + return internal::compose_bu_<BF1, UF2>(f1, f2); + } + + /*! \class f_identity + ** + ** This functor returns its argument. + */ + + template<class T> + struct f_identity : std::unary_function<T, T> + { + T + operator()(T t) const + { + return t; + } + }; + +} // end of oln + +#endif // OLENA_CORE_COMPOSE_HH

19 years, 9 months

proto-1.0 83: Add utils directory for olena tests suite

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Add utils directory for olena tests suite. configure.ac | 9 +++++---- 1 files changed, 5 insertions(+), 4 deletions(-) Index: configure.ac --- configure.ac (revision 80) +++ configure.ac (working copy) @@ -98,11 +98,12 @@ # OLN_TESTS defined in oln-local.m4 + OLN_TESTS([sanity]) OLN_TESTS([core]) - OLN_TESTS([sanity]) OLN_TESTS([io]) OLN_TESTS([level]) - + OLN_TESTS([utils]) + AC_SUBST([OLN_TESTS_SUBDIRS]) ], [tests])dnl End of OLN_COMPONENT([olena/tests]) @@ -165,7 +166,7 @@ metalic/tests/check/defs], [dnl Configuration for the testsuite - MLC_TESTS_SUBDIRS="main" + MLC_TESTS_SUBDIRS="" AC_CACHE_CHECK([for selection of tests], [mlc_cv_tests_selection], @@ -178,9 +179,9 @@ # MLC_TESTS defined in oln-local.m4 + MLC_TESTS([sanity]) MLC_TESTS([array]) MLC_TESTS([main]) - MLC_TESTS([sanity]) AC_SUBST([MLC_TESTS_SUBDIRS])

19 years, 9 months

proto-1.0 81: Add clone images function

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/utils: New. * tests/utils/tests: New. * tests/utils/tests/clone: New. * tests/utils/Makefile.am: New. * oln/utils: New. * oln/utils/clone.hh: New. Clone images. * oln/makefile.src: Add new file. * oln/core/value_box.hh: Add operators for value_box because it does not match template <typename II> value_box<II>. * oln/core/abstract/op.hh: Add missing initialization. * oln/core/1d/image1d.hh: Add constructor for size1d. * oln/core/2d/image2d.hh: Add constructor for size2d. * oln/core/3d/image3d.hh: Add constructor for size3d. oln/core/1d/image1d.hh | 9 +++- oln/core/2d/image2d.hh | 5 ++ oln/core/3d/image3d.hh | 9 +++- oln/core/abstract/op.hh | 8 +++- oln/core/value_box.hh | 28 +++++++++++++- oln/makefile.src | 3 + oln/utils/clone.hh | 95 ++++++++++++++++++++++++++++++++++++++++++++++++ tests/utils/Makefile.am | 5 ++ tests/utils/tests/clone | 35 +++++++++++++++++ 9 files changed, 189 insertions(+), 8 deletions(-) Index: tests/utils/tests/clone --- tests/utils/tests/clone (revision 0) +++ tests/utils/tests/clone (revision 0) @@ -0,0 +1,35 @@ +#include "data.hh" + +#include <ntg/all.hh> + +#include <oln/basics2d.hh> +#include <oln/utils/clone.hh> +#include <oln/io/read_image.hh> +#include <oln/level/compare.hh> +#include <oln/level/fill.hh> + + +bool check() +{ + oln::image2d<ntg::int_u8> ima1; + oln::image2d<ntg::int_u8> ima2; + oln::image2d<ntg::int_u8> ima_copy; + + ima1 = oln::io::read(rdata("lena.pgm")); + ima2 = oln::io::read(rdata("lena.pgm")); + ima_copy = oln::utils::clone(ima1); + + oln::level::fill(ima1, 0); + if (oln::level::is_equal(ima2, ima_copy)) + { + std::cout << "OK" << std::endl; + return false; + } + else + { + std::cout << "FAIL" << std::endl; + return true; + } +} + + Index: tests/utils/Makefile.am --- tests/utils/Makefile.am (revision 0) +++ tests/utils/Makefile.am (revision 0) @@ -0,0 +1,5 @@ +include ../check/Makefile.runtests +include ../check/Makefile.check + + +check-local: check-runtests Index: oln/utils/clone.hh --- oln/utils/clone.hh (revision 0) +++ oln/utils/clone.hh (revision 0) @@ -0,0 +1,95 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_UTILS_CLONE_HH +# define OLN_UTILS_CLONE_HH + +# include <oln/core/abstract/op.hh> +# include <oln/core/abstract/piter.hh> + +namespace oln { + + // fwd decl + namespace utils { + template <typename I> struct clone_type; + } + + // category + template <typename I> + struct set_category < utils::clone_type > + { + typedef category::image ret; + }; + + // super_type + template <typename I> + struct set_super_type < utils::clone_type > + { + typedef abstract::op<I, utils::clone_type > ret; + }; + + + + namespace utils { + + template <typename I> + struct clone_type : abstract::op<I, clone_type > + { + typedef abstract::op<I, clone_type > super_type; + + mlc::box input_; + + clone_type(I& input) : input_(input) + {} + + void impl_run() + { + I ima(input_->size()); + oln_type_of(I, fwd_piter) it(input_->size()); + + for_all(it) + { + ima[it] = (*input_)[it]; + } + + *this->image_ = ima; + } + }; + + + template <typename I> + clone_type clone(abstract::image& ima) + { + clone_type tmp(ima.exact()); + tmp.run(); + return tmp; + } + } +} + + +#endif // ! OLN_UTILS_CLONE_HH Index: oln/makefile.src --- oln/makefile.src (revision 80) +++ oln/makefile.src (working copy) @@ -61,4 +61,5 @@ io/write_image.hh \ io/write_image_2d_pnm.hh \ level/compare.hh \ - level/fill.hh + level/fill.hh \ + utils/clone.hh Index: oln/core/value_box.hh --- oln/core/value_box.hh (revision 80) +++ oln/core/value_box.hh (working copy) @@ -98,6 +98,12 @@ return ! this->operator==(rhs); } + /*! \brief operator < + ** + ** Define the main comparison operator for value_box. <= >= and > + ** are computed using integre operators \see ntg/core/global_ops.hh:138. + */ + template <typename V> bool operator<(const V& rhs) const { @@ -110,6 +116,15 @@ return this->value() < value.value(); } + /*! \brief specialized version for value_box + ** + ** FIXME: why do we need this class ??? + */ + bool operator<(const value_box& rhs) const + { + return this->value() < value.value(); + } + /*! \brief op= ** FIXME:... ** \return (*this) @@ -138,7 +153,13 @@ return *this; } + value_box& operator=(const value_box& rhs) + { + ima_->set(p_, rhs.value()); // automatic conversion from rhs to value_type + return *this; + } + /*! \brief Set ** ** NEW code @@ -275,11 +296,16 @@ } template <typename II> - bool operator<(const value_box<II>& rhs) const + bool operator<(const value_box<const II>& rhs) const { return this->value() < rhs.value(); } + bool operator<(const value_box<const I>& rhs) const + { + return this->value() < rhs.value(); + } + /*! \brief Assignment (op=) is declared but undefined. */ Index: oln/core/abstract/op.hh --- oln/core/abstract/op.hh (revision 80) +++ oln/core/abstract/op.hh (working copy) @@ -58,7 +58,10 @@ this->exact_ptr = (E*)(void*)(this); } - op() {} + op() + { + this->exact_ptr = (E*)(void*)(this); + } void run() { @@ -74,7 +77,8 @@ template <typename E> struct void_op : public mlc::any<E> { - void_op() {} + void_op() + {} void run() { Index: oln/core/1d/image1d.hh --- oln/core/1d/image1d.hh (revision 80) +++ oln/core/1d/image1d.hh (working copy) @@ -120,12 +120,17 @@ this->exact_ptr = this; } - image1d(coord_t nindices) : - super_type(size1d(nindices)) + image1d(const size1d& size) : super_type(size) { this->exact_ptr = this; } + image1d(coord_t nindices, size_t border = 2) : + super_type(size1d(nindices, border)) + { + this->exact_ptr = this; + } + image1d(image1d& rhs) : super_type(rhs) { Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 80) +++ oln/core/2d/image2d.hh (working copy) @@ -129,6 +129,11 @@ this->exact_ptr = this; } + image2d(const size2d& size) : super_type(size) + { + this->exact_ptr = this; + } + image2d(coord_t nrows, coord_t ncols, size_t border = 2) : super_type(size2d(nrows, ncols, border)) { Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 80) +++ oln/core/3d/image3d.hh (working copy) @@ -115,12 +115,17 @@ this->exact_ptr = this; } - image3d(coord_t nslices, coord_t nrows, coord_t ncols) : - super_type(size3d(nslices, nrows, ncols)) + image3d(const size3d& size) : super_type(size) { this->exact_ptr = this; } + image3d(coord_t nslices, coord_t nrows, coord_t ncols, size_t border = 2) : + super_type(size3d(nslices, nrows, ncols, border)) + { + this->exact_ptr = this; + } + image3d(image3d& rhs) : super_type(rhs) {

19 years, 9 months

proto-1.0 81: Add structuring element and neighborhood headers to basics.hh and basics2d.hh

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/basics.hh: Add structuring element and neighborhood headers. * oln/basics2d.hh: Likewise. basics.hh | 3 +++ basics2d.hh | 2 ++ 2 files changed, 5 insertions(+) Index: oln/basics.hh --- oln/basics.hh (revision 80) +++ oln/basics.hh (working copy) @@ -61,5 +61,8 @@ # include <oln/core/abstract/piter.hh> // # include <oln/core/abstract/niter.hh> +# include <oln/core/abstract/struct_elt.hh> +# include <oln/core/abstract/neighborhood.hh> + #endif // ! OLENA_BASICS_HH Index: oln/basics2d.hh --- oln/basics2d.hh (revision 80) +++ oln/basics2d.hh (working copy) @@ -35,6 +35,8 @@ # include <oln/core/2d/size2d.hh> # include <oln/core/2d/point2d.hh> # include <oln/core/2d/image2d.hh> +# include <oln/core/2d/window2d.hh> +# include <oln/core/2d/neighborhood2d.hh> #endif // ! OLENA_BASICS2D_HH

19 years, 9 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches