Olena-patches March 2005

olena-patches@lrde.epita.fr

10 participants
59 discussions

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, 1 month

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, 1 month

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, 1 month

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, 1 month

proto-1.0 80: Add vectorialness for images in abstract hierarchy

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/core/tests/image_vectorialness: New. * tests/core/tests/readwrite_image: Add vectorialness property. * oln/makefile.src: Add new files. * oln/core/abstract/image.hh: Register `vectorialness' property. * oln/core/abstract/image_vectorialness.hh: New. Add vectorialness abstraction. * oln/core/abstract/entry.hh: Add inheritance to new branch `vectorialness'. * oln/core/1d/image1d.hh: Add `vectorialness' property. * oln/core/2d/image2d.hh: Likewise. * oln/core/3d/image3d.hh: Likewise. * oln/core/properties.hh: Declare `vectorialness' property.. oln/core/1d/image1d.hh | 3 oln/core/2d/image2d.hh | 3 oln/core/3d/image3d.hh | 3 oln/core/abstract/entry.hh | 4 oln/core/abstract/image.hh | 3 oln/core/abstract/image_vectorialness.hh | 126 +++++++++++++++++++++++++++++++ oln/core/properties.hh | 1 oln/makefile.src | 1 tests/core/tests/image_vectorialness | 26 ++++++ tests/core/tests/readwrite_image | 1 10 files changed, 170 insertions(+), 1 deletion(-) Index: tests/core/tests/image_vectorialness --- tests/core/tests/image_vectorialness (revision 0) +++ tests/core/tests/image_vectorialness (revision 0) @@ -0,0 +1,26 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics2d.hh> + +#include <oln/fancy/iota.hh> +#include <oln/fancy/print.hh> + +#include "check.hh" +#include "data.hh" + + + +template <typename I> +void foo_i(const oln::abstract::integer_image& input) +{} + + +bool check() +{ + // it lacks test for decimal, vectorial, ... images. + oln::image2d<ntg::int_u8> ima_i; + foo_i(ima_i); + return false; +} Index: tests/core/tests/readwrite_image --- tests/core/tests/readwrite_image (revision 79) +++ tests/core/tests/readwrite_image (working copy) @@ -24,6 +24,7 @@ { typedef is_a<abstract::readwrite_image> image_constness; typedef is_a<abstract::image2d> image_dimension_type; + typedef vectorialness_from_valuetype_(ntg::int_u8) image_vectorialness_type; typedef size2d size_type; typedef point2d point_type; Index: oln/makefile.src --- oln/makefile.src (revision 79) +++ oln/makefile.src (working copy) @@ -37,6 +37,7 @@ core/abstract/image.hh \ core/abstract/image_constness.hh \ core/abstract/image_dimension.hh \ + core/abstract/image_vectorialness.hh \ core/abstract/image_identity.hh \ core/abstract/image_with_data.hh \ core/abstract/images.hh \ Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 79) +++ oln/core/abstract/image.hh (working copy) @@ -70,6 +70,7 @@ mlc_decl_prop_with_default(category::image, image_constness_type, is_a<abstract::readonly_image>); mlc_decl_prop(category::image, image_dimension_type); + mlc_decl_prop(category::image, image_vectorialness_type); //... @@ -87,6 +88,7 @@ << " image_constness_type = " << typeid(image_constness_type).name() << " image_dimension_type = " << typeid(image_dimension_type).name() + << " image_vectorialness_type = " << typeid(image_vectorialness_type).name() << " }" << std::endl; } @@ -103,6 +105,7 @@ mlc_register_prop(category::image, image_constness_type); mlc_register_prop(category::image, image_dimension_type); + mlc_register_prop(category::image, image_vectorialness_type); Index: oln/core/abstract/image_vectorialness.hh --- oln/core/abstract/image_vectorialness.hh (revision 0) +++ oln/core/abstract/image_vectorialness.hh (revision 0) @@ -0,0 +1,126 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_IMAGE_VECTORIALNESS_HH +# define OLENA_CORE_ABSTRACT_IMAGE_VECTORIALNESS_HH + +# include <mlc/bool.hh> + +# include <ntg/basics.hh> + +# include <oln/core/abstract/image.hh> + +/*! \namespace oln +** \brief oln namespace. +*/ +namespace oln { + + /*! \namespace oln::abstract + ** \brief oln::abstract namespace. + */ + namespace abstract { + + template <typename E> + struct data_type_image : public virtual image<E> + { + protected: + data_type_image() {} + }; + + template <typename E> + struct vectorial_image : public data_type_image<E> + { + protected: + vectorial_image() {} + }; + + template <typename E> + struct non_vectorial_image : public data_type_image<E> + { + protected: + non_vectorial_image() {} + }; + + template <typename E> + struct decimal_image : public non_vectorial_image<E> + { + protected: + decimal_image() {} + }; + + template <typename E> + struct integer_image : public non_vectorial_image<E> + { + protected: + integer_image() {} + }; + + template <typename E> + struct binary_image : public non_vectorial_image<E> + { + protected: + binary_image() {} + }; + + + } // end of namespace oln::abstract + + template <typename T> + struct vectorialness_from_valuetype + { + typedef typename mlc::bool_switch_< + + mlc::bool_case_<ntg_is_a(T, ntg::binary)::ret, + is_a<abstract::binary_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::integer)::ret, + is_a<abstract::integer_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::decimal)::ret, + is_a<abstract::decimal_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::vectorial)::ret, + is_a<abstract::vectorial_image>, + + mlc::bool_case_<ntg_is_a(T, ntg::non_vectorial)::ret, + is_a<abstract::non_vectorial_image>, + + mlc::bool_case_<true, + is_a<abstract::data_type_image> > + + > > > > > >::ret ret; + }; + + #define vectorialness_from_valuetype(T) \ + typename vectorialness_from_valuetype< T >::ret + #define vectorialness_from_valuetype_(T) \ + vectorialness_from_valuetype< T >::ret + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_VECTORIALNESS_HH Index: oln/core/abstract/entry.hh --- oln/core/abstract/entry.hh (revision 79) +++ oln/core/abstract/entry.hh (working copy) @@ -30,6 +30,7 @@ # include <oln/core/abstract/image_constness.hh> # include <oln/core/abstract/image_dimension.hh> +# include <oln/core/abstract/image_vectorialness.hh> // FIXME: this file should move to oln/core/abstract/ @@ -68,7 +69,8 @@ struct image_entry : // intrusive: public oln_type_of_(E, image_constness) ::template instantiated_with<E>::ret, - public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret + public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret, + public oln_type_of_(E, image_vectorialness) ::template instantiated_with<E>::ret // ... { protected: Index: oln/core/1d/image1d.hh --- oln/core/1d/image1d.hh (revision 79) +++ oln/core/1d/image1d.hh (working copy) @@ -31,6 +31,7 @@ # include <mlc/traits.hh> # include <oln/core/abstract/image_with_data.hh> +# include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/1d/array1d.hh> # include <oln/core/1d/fwd_piter1d.hh> @@ -63,6 +64,8 @@ { // intrusive property: typedef is_a<abstract::image1d> image_dimension_type; + // FIXME: should be generalized + typedef vectorialness_from_valuetype(T) image_vectorialness_type; typedef mlc::no_type delegated_type; Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 79) +++ oln/core/2d/image2d.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/abstract/image_identity.hh> # include <oln/core/abstract/image_with_data.hh> +# include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/2d/array2d.hh> # include <oln/core/2d/fwd_piter2d.hh> # include <oln/core/2d/bkd_piter2d.hh> @@ -72,6 +73,8 @@ { // intrusive property: typedef is_a<abstract::image2d> image_dimension_type; + // FIXME: should be generalized + typedef vectorialness_from_valuetype(T) image_vectorialness_type; typedef mlc::no_type delegated_type; Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 79) +++ oln/core/3d/image3d.hh (working copy) @@ -31,6 +31,7 @@ # include <mlc/traits.hh> # include <oln/core/abstract/image_with_data.hh> +# include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/3d/array3d.hh> # include <oln/core/3d/fwd_piter3d.hh> @@ -61,6 +62,8 @@ { // intrusive property: typedef is_a<abstract::image3d> image_dimension_type; + // FIXME: should be generalized + typedef vectorialness_from_valuetype(T) image_vectorialness_type; typedef mlc::no_type delegated_type; Index: oln/core/properties.hh --- oln/core/properties.hh (revision 79) +++ oln/core/properties.hh (working copy) @@ -66,6 +66,7 @@ struct image_constness_type; struct image_dimension_type; + struct image_vectorialness_type; // FIXME: ... }

19 years, 1 month

proto-1.0 79: Add backward 2D iterators

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/core/tests/piter2d: Add a test for backward 2d iterators. * oln/makefile.src: Add new file. * oln/core/2d/image2d.hh: Include bkd_piter2d.hh. * oln/core/2d/bkd_piter2d.hh: New. bkd_piter2d implementation. * oln/core/properties.hh: Add bkd_piter_type property. oln/core/2d/bkd_piter2d.hh | 117 +++++++++++++++++++++++++++++++++++++++++++++ oln/core/2d/image2d.hh | 2 oln/core/properties.hh | 3 - oln/makefile.src | 1 tests/core/tests/piter2d | 23 ++++++-- 5 files changed, 140 insertions(+), 6 deletions(-) Index: tests/core/tests/piter2d --- tests/core/tests/piter2d (revision 78) +++ tests/core/tests/piter2d (working copy) @@ -14,16 +14,29 @@ { oln::image2d<int> ima(10, 10); int cpt = 0; - - oln::fwd_piter2d it(ima.size()); - for_all (it) + + oln::fwd_piter2d fwd_it(ima.size()); + for_all (fwd_it) { - ima[it] = 0; + ima[fwd_it] = 0; cpt++; } if (cpt != 100) return true; - + + + cpt = 0; + oln::bkd_piter2d bkd_it(ima.size()); + for_all (bkd_it) + { + ima[bkd_it] = 0; + cpt++; + } + + if (cpt != 100) + return true; + + return false; } Index: oln/makefile.src --- oln/makefile.src (revision 78) +++ oln/makefile.src (working copy) @@ -18,6 +18,7 @@ core/1d/point1d.hh \ core/1d/size1d.hh \ core/2d/array2d.hh \ + core/2d/bkd_piter2d.hh \ core/2d/dpoint2d.hh \ core/2d/fwd_piter2d.hh \ core/2d/image2d.hh \ Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 78) +++ oln/core/2d/image2d.hh (working copy) @@ -34,6 +34,7 @@ # include <oln/core/abstract/image_with_data.hh> # include <oln/core/2d/array2d.hh> # include <oln/core/2d/fwd_piter2d.hh> +# include <oln/core/2d/bkd_piter2d.hh> /*! \namespace oln @@ -80,6 +81,7 @@ typedef fwd_piter2d piter_type; typedef fwd_piter2d fwd_piter_type; + typedef bkd_piter2d bkd_piter_type; // please note that value_storage_type means data_type // since image2d is an image_with_data Index: oln/core/2d/bkd_piter2d.hh --- oln/core/2d/bkd_piter2d.hh (revision 0) +++ oln/core/2d/bkd_piter2d.hh (revision 0) @@ -0,0 +1,117 @@ +// 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_CORE_2D_BKD_PITER2D_HH +# define OLENA_CORE_2D_BKD_PITER2D_HH + +# include <mlc/contract.hh> + +# include <oln/core/abstract/piter.hh> +# include <oln/core/2d/point2d.hh> +# include <oln/core/2d/size2d.hh> + + +namespace oln { + + // fwd decl + struct bkd_piter2d; + + // category + template <> + struct set_category<bkd_piter2d> { typedef category::piter ret; }; + + + // props + template <> + struct set_props < category::piter, bkd_piter2d > : public props_of<category::piter> + { + typedef point2d point_type; + typedef size2d size_type; + }; + + + + struct bkd_piter2d : public abstract::piter< bkd_piter2d > + { + + typedef abstract::piter<bkd_piter2d> super_type; + + bkd_piter2d(const size2d& size) : + super_type(size) + { + this->exact_ptr = this; + this->invalidate(); + } + +# if defined __GNUC__ && __GNUC__ >= 3 + friend class abstract::piter< bkd_piter2d >; + protected: +# endif + + void impl_start() + { + this->p_.row() = this->s_.nrows() - 1; + this->p_.col() = this->s_.ncols() - 1; + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + } + + bool impl_is_valid() const + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + return this->p_.row() >= 0; + } + + void impl_next() + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + precondition(this->p_.row() >= 0 && this->p_.row() < this->s_.nrows() && + this->p_.col() >= 0 && this->p_.col() < this->s_.ncols()); + --this->p_.col(); + if (this->p_.col() >= 0) + return; + this->p_.col() = this->s_.ncols() - 1; + --this->p_.row(); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + } + + void impl_invalidate() + { + this->p_.row() = -1; + this->p_.col() = -1; + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + } + + }; +} + + +#endif // ! OLENA_CORE_2D_BKD_PITER2D_HH Index: oln/core/properties.hh --- oln/core/properties.hh (revision 78) +++ oln/core/properties.hh (working copy) @@ -36,7 +36,7 @@ */ namespace oln { - + namespace category { struct data_storage; @@ -59,6 +59,7 @@ struct point_type; struct dpoint_type; struct fwd_piter_type; + struct bkd_piter_type; struct iter_type; struct delegated_type; struct size_type;

19 years, 1 month

proto-1.0 78: Add border_resize in array2d

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/core/tests/border2d: New. * oln/core/abstract/image_with_data.hh: Add resize_border and impl_hold_large methods. * oln/core/abstract/data_storage.hh: Add resize_border in generic data_storage class. * oln/core/2d/array2d.hh: Add resize_border implementation for array2d. * oln/core/2d/image2d.hh: Add a border argument to image2d constructor. oln/core/2d/array2d.hh | 71 ++++++++++++++++++++++++++++------- oln/core/2d/image2d.hh | 4 - oln/core/abstract/data_storage.hh | 13 ++++-- oln/core/abstract/image_with_data.hh | 13 +++++- tests/core/tests/border2d | 38 ++++++++++++++++++ 5 files changed, 119 insertions(+), 20 deletions(-) Index: tests/core/tests/border2d --- tests/core/tests/border2d (revision 0) +++ tests/core/tests/border2d (revision 0) @@ -0,0 +1,38 @@ + +#include <iostream> + +#include <ntg/all.hh> +#include <oln/basics2d.hh> +#include <oln/level/fill.hh> + +#include "check.hh" +#include "data.hh" + + + +bool check() +{ + oln::point2d p(0,0); + + typedef oln::image2d<ntg::int_u8> image_type; + image_type ima(10, 10, 2); + + int i = 0; + + for (p.col() = -0; p.col() < 10; p.col()++) + for (p.row() = -0; p.row() < 10; p.row()++) + ima[p] = i++; + + ima.resize_border(3, true); + + i = 0; + for (p.col() = -3; p.col() < 13; p.col()++) + for (p.row() = -3; p.row() < 13; p.row()++) + { + if (p.col() >= -0 && p.col() < 10 && p.row() >= -0 && p.row() < 10) + if (ima[p] != i++) + return true; + } + + return false; +} Index: oln/core/abstract/data_storage.hh --- oln/core/abstract/data_storage.hh (revision 77) +++ oln/core/abstract/data_storage.hh (working copy) @@ -49,7 +49,7 @@ struct props_of < category::data_storage, type > { typedef mlc::true_type user_defined_; - + mlc_decl_prop(category::data_storage, size_type); mlc_decl_prop(category::data_storage, point_type); mlc_decl_prop(category::data_storage, data_type); @@ -65,9 +65,9 @@ }; - mlc_register_prop(category::data_storage, size_type); - mlc_register_prop(category::data_storage, point_type); - mlc_register_prop(category::data_storage, data_type); + mlc_register_prop(category::data_storage, size_type); + mlc_register_prop(category::data_storage, point_type); + mlc_register_prop(category::data_storage, data_type); namespace abstract { @@ -106,6 +106,11 @@ this->exact().impl_resize(s); } + void resize_border(size_t new_border, bool copy_border) + { + this->exact().impl_resize_border(new_border, copy_border); + } + unsigned long npoints() const { if (! this->has_data()) Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 77) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -51,7 +51,7 @@ { typedef category::image ret; }; - + // super_type template <typename E> struct set_super_type < abstract::image_with_data<E> > @@ -139,7 +139,13 @@ return this->data_->hold(p); } + bool impl_hold_large(const point_type& p) const + { + precondition(this->has_data()); + return this->data_->hold_large(p); + } + /*! \brief Implement both abstract::readonly_image<E>::get(p) ** and abstract::readwrite_image<E>::get(p) so read-only access ** to the value stored at \a p in the current image. @@ -172,7 +178,12 @@ return data_ != 0; } + void resize_border(size_t new_border, bool copy_border = false) + { + this->data_->resize_border(new_border, copy_border); + } + protected: /*! \brief Constructor (protected) with no memory allocation for Index: oln/core/2d/array2d.hh --- oln/core/2d/array2d.hh (revision 77) +++ oln/core/2d/array2d.hh (working copy) @@ -39,13 +39,13 @@ template <typename T> struct array2d; // category - template <typename T> + template <typename T> struct set_category< array2d<T> > { typedef category::data_storage ret; }; // super_type - template <typename T> + template <typename T> struct set_super_type< array2d<T> > { typedef abstract::data_storage< array2d<T> > ret; }; - + // props template <typename T> struct set_props < category::data_storage, array2d<T> > : public props_of<category::data_storage> @@ -56,7 +56,26 @@ }; + template<class T> + void alloc_and_init(T*& buffer, T**& array, const size2d& s) + { + size_t nrows_eff = s.nrows() + 2 * s.border(); + size_t ncols_eff = s.ncols() + 2 * s.border(); + size_t nelts_eff = nrows_eff * ncols_eff; + buffer = new T[nelts_eff]; + array = new T*[nrows_eff]; + + buffer = buffer; + T* buf = buffer + s.border(); + for (size_t row = 0; row < nrows_eff; ++row) + { + array[row] = buf; + buf += ncols_eff; + } + array += s.border(); + } + template <typename T> class array2d : public abstract::data_storage< array2d<T> > { @@ -129,20 +148,44 @@ this->clear_data(); size_ = s; - size_t nrows_eff = size_.nrows() + 2 * size_.border(); - size_t ncols_eff = size_.ncols() + 2 * size_.border(); - size_t nelts_eff = nrows_eff * ncols_eff; + alloc_and_init(buffer_, array_, s); + invariant_(); + } - buffer_ = new T[nelts_eff]; - array_ = new T*[nrows_eff]; + void impl_resize_border(size_t new_border, bool copy_border) + { + invariant_(); + T* new_buffer_; + T** new_array_; + size2d new_size_(this->size_.nrows(), this->size_.ncols(), new_border); - T* buf = buffer_ + size_.border(); - for (size_t row = 0; row < nrows_eff; ++row) + alloc_and_init(new_buffer_, new_array_, new_size_); + + if (buffer_ != 0) { - array_[row] = buf; - buf += ncols_eff; + size_t border = this->size_.border(); + + if (border > new_border) + border = new_border; + + coord_t row_min = copy_border ? -border : 0; + coord_t row_max = int(this->size_.nrows()) + + (copy_border ? border : 0); + coord_t col_min = copy_border ? -border : 0; + size_t ncols = int(this->size_.ncols()) + + (copy_border ? (border * 2) : 0); + + for (coord_t row = row_min; row < row_max; ++row) + memcpy(new_array_[row] + col_min, this->array_[row] + col_min, + ncols * sizeof (T)); + + this->clear_data(); } - array_ += size_.border(); + + buffer_ = new_buffer_; + array_ = new_array_; + size_ = new_size_; + invariant_(); } @@ -213,6 +256,8 @@ size_.border().is_undefined())); } + + }; } // end of namespace oln Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 77) +++ oln/core/2d/image2d.hh (working copy) @@ -124,8 +124,8 @@ this->exact_ptr = this; } - image2d(coord_t nrows, coord_t ncols) : - super_type(size2d(nrows, ncols)) + image2d(coord_t nrows, coord_t ncols, size_t border = 2) : + super_type(size2d(nrows, ncols, border)) { this->exact_ptr = this; }

19 years, 1 month

proto-1.0 76: Add neighborhood and structuring element files to makefile.src

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * oln/makefile.src: Add neighborhood and structuring element files to makefile.src. makefile.src | 4 ++++ 1 files changed, 4 insertions(+) Index: oln/makefile.src --- oln/makefile.src (revision 75) +++ oln/makefile.src (working copy) @@ -23,6 +23,8 @@ core/2d/image2d.hh \ core/2d/point2d.hh \ core/2d/size2d.hh \ + core/2d/neighborhood2d.hh \ + core/2d/window2d.hh \ core/3d/array3d.hh \ core/3d/fwd_piter3d.hh \ core/3d/image3d.hh \ @@ -42,6 +44,8 @@ core/abstract/piter.hh \ core/abstract/point.hh \ core/abstract/size.hh \ + core/abstract/neighborhood.hh \ + core/abstract/window.hh \ core/coord.hh \ core/properties.hh \ core/value_box.hh \

19 years, 1 month

proto-1.0 75: Add neighborhood

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/core/tests/neighborhood2d: New. * oln/core/abstract/neighborhood.hh: New. * oln/core/2d/neighborhood2d.hh: New. * oln/core/properties.hh: Add `neighborhood' category. oln/core/2d/neighborhood2d.hh | 133 ++++++++++++++++++++++++++ oln/core/abstract/neighborhood.hh | 192 ++++++++++++++++++++++++++++++++++++++ oln/core/properties.hh | 1 tests/core/tests/neighborhood2d | 17 +++ 4 files changed, 343 insertions(+) Index: tests/core/tests/neighborhood2d --- tests/core/tests/neighborhood2d (revision 0) +++ tests/core/tests/neighborhood2d (revision 0) @@ -0,0 +1,17 @@ +#include <oln/core/2d/neighborhood2d.hh> + +#include <ntg/all.hh> + +#include <cassert> + +using namespace oln; +using namespace ntg; + +int main() +{ + neighborhood2d w1; + w1.add(dpoint2d(0, 5)); + w1.add(dpoint2d(0, 5)); + neighborhood2d w2 = neighb_c8(); + return 0; +} Index: oln/core/abstract/neighborhood.hh --- oln/core/abstract/neighborhood.hh (revision 0) +++ oln/core/abstract/neighborhood.hh (revision 0) @@ -0,0 +1,192 @@ +// 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_CORE_NEIGHBORHOOD_HH +# define OLENA_CORE_NEIGHBORHOOD_HH + +# include <mlc/types.hh> +# include <oln/core/properties.hh> +# include <oln/core/coord.hh> +# include <oln/core/abstract/dpoint.hh> +# include <vector> +# include <utility> +# include <iostream> + +namespace oln { + + // fwd decl + namespace abstract { + template<class Exact> + struct neighborhood; + } + + // category + template <typename E> + struct set_category< abstract::neighborhood<E> > + { + typedef category::neighborhood ret; + }; + + /// properties of any type in category::neighborhood + + template <typename type> + struct props_of <category::neighborhood, type> + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::neighborhood, dpoint_type); + mlc_decl_prop(category::neighborhood, size_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::neighborhood, " + << typeid(type).name() << ") = {" + << " size_type = " << typeid(size_type).name() << "," << std::endl + << " dpoint_type = " << typeid(dpoint_type).name() << " }" << std::endl; + } + + }; + + mlc_register_prop(category::neighborhood, dpoint_type); + mlc_register_prop(category::neighborhood, size_type); + + + namespace abstract { + + /*! + ** Structuring elements (set of dpoints). + ** + ** This abstract class defines several virtual methods for its + ** subclasses. Its goal is to deal with a set of 'move' points. + */ + template<class E> + class neighborhood : public mlc::any__best_memory<E> + { + + public: + + typedef oln_type_of(E, dpoint) dpoint_type; + + typedef E exact_type; + + static std::string + name() + { + return std::string("neighborhood<") + exact_type::name() + ">"; + } + + bool + has(const abstract::dpoint<dpoint_type>& dp) const + { + return this->exact().impl_has(dp.exact()); + } + + unsigned + card() const + { + return this->exact().impl_card(); + } + + exact_type& + add(const dpoint_type& dp) + { + return this->exact().impl_add(dp); + } + + dpoint_type + dp(unsigned i) const + { + return this->exact().impl_at(i); + } + + const dpoint_type + operator[](unsigned i) const + { + return this->exact().impl_at(i); + } + + protected: + + bool + impl_has(const dpoint_type& dp) const + { + return std::find(dp_.begin(), dp_.end(), dp) != dp_.end(); + } + + exact_type& + impl_add(const dpoint_type& dp) + { + if (!(impl_has(dp))) + { + this->dp_.push_back(dp); + this->dp_.push_back(-dp); + } + return this->exact(); + } + + unsigned + impl_card() const + { + return dp_.size(); + } + + const dpoint_type + impl_at(unsigned i) const + { + precondition(i < this->card()); + return dp_[i]; + } + + neighborhood() : dp_() + {}; + + neighborhood(unsigned size) : dp_() + { + dp_.reserve(size); + }; + + std::vector<dpoint_type> dp_; + + }; + } // end of abstract + +} // end of oln + +template<class E> +std::ostream& +operator<<(std::ostream& o, const oln::abstract::neighborhood<E>& se) +{ + unsigned c = se.card(); + o << "["; + for (unsigned i = 0; i < c; ++i) + o << se.dp(i); + o << "]"; + return o; +} + + +#endif // ! OLENA_CORE_NEIGHBORHOOD_HH Index: oln/core/2d/neighborhood2d.hh --- oln/core/2d/neighborhood2d.hh (revision 0) +++ oln/core/2d/neighborhood2d.hh (revision 0) @@ -0,0 +1,133 @@ +// 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_CORE_NEIGHBORHOOD2D_HH +# define OLENA_CORE_NEIGHBORHOOD2D_HH + +# include <oln/core/2d/dpoint2d.hh> +# include <oln/core/2d/size2d.hh> +# include <oln/core/coord.hh> +# include <oln/core/abstract/struct_elt.hh> + +namespace oln { + + class neighborhood2d; // forward declaration + + // category + template <> + struct set_category< neighborhood2d > { typedef category::struct_elt ret; }; + + // super_type + template <> + struct set_super_type< neighborhood2d > + { + typedef abstract::struct_elt< neighborhood2d > ret; + }; + + template <> + struct set_props< category::struct_elt, neighborhood2d > + : public props_of<category::struct_elt> + { + typedef dpoint2d dpoint_type; + typedef size2d size_type; + }; + + class neighborhood2d : public abstract::struct_elt<neighborhood2d> + { + + public: + + typedef abstract::struct_elt<neighborhood2d> super_type; + + /*! + ** \brief Construct a neighborhood of 2 dimensions. + */ + neighborhood2d() : super_type() + {} + + /*! + ** \brief Construct a neighborhood of 2 dimensions. + ** \arg size The number of element. + */ + neighborhood2d(unsigned size) : super_type(size) + {} + + /*! + ** \brief Construct a neighborhood of 2 dimensions from several points. + ** \arg n The number of element. + ** \arg crd The coordinates of the elements + */ + neighborhood2d(unsigned n, const coord_t crd[]) : super_type(n) + { + for (unsigned i = 0; i < 2 * n; i += 2) + this->add(dpoint_type(crd[i], crd[i+1])); + } + + neighborhood2d& + add(const dpoint_type& dp) + { + return this->exact().impl_add(dp); + } + + neighborhood2d& + add(coord_t row, coord_t col) + { + dpoint_type dp(row, col); + return add(dp); + } + + + /// Return the name of the type. + static std::string + name() + { + return std::string("neighborhood2d"); + } + + protected: + + }; + + inline const neighborhood2d& + neighb_c4() + { + static const coord_t crd[] = { 0,1, 1,0 }; + static const neighborhood2d neighb(2, crd); + return neighb; + } + + inline const neighborhood2d& + neighb_c8() + { + static const coord_t crd[] = { 0,1, 1,1, 1,0, 1,-1 }; + static const neighborhood2d neighb(4, crd); + return neighb; + } + +} // end of oln + +#endif // OLENA_CORE_NEIGHBORHOOD2D_HH Index: oln/core/properties.hh --- oln/core/properties.hh (revision 74) +++ oln/core/properties.hh (working copy) @@ -42,6 +42,7 @@ struct data_storage; struct image; struct struct_elt; + struct neighborhood; struct point; struct size; struct piter;

19 years, 1 month

proto-1.0 74: Add structuring elements

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/core/tests/window2d: New. * oln/core/abstract/struct_elt.hh: New. * oln/core/2d/window2d.hh: New. * oln/core/properties.hh: Add `struct_elt' category. oln/core/2d/window2d.hh | 172 ++++++++++++++++++++++++++++++++++++ oln/core/abstract/struct_elt.hh | 189 ++++++++++++++++++++++++++++++++++++++++ oln/core/properties.hh | 1 tests/core/tests/window2d | 17 +++ 4 files changed, 379 insertions(+) Index: tests/core/tests/window2d --- tests/core/tests/window2d (revision 0) +++ tests/core/tests/window2d (revision 0) @@ -0,0 +1,17 @@ +#include <oln/core/2d/window2d.hh> + +#include <ntg/all.hh> + +#include <cassert> + +using namespace oln; +using namespace ntg; + +int main() +{ + window2d w1; + w1.add(dpoint2d(0, 5)); + w1.add(dpoint2d(0, 5)); + window2d w2 = win_c8p(); + return 0; +} Index: oln/core/abstract/struct_elt.hh --- oln/core/abstract/struct_elt.hh (revision 0) +++ oln/core/abstract/struct_elt.hh (revision 0) @@ -0,0 +1,189 @@ +// 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_CORE_STRUCT_ELT_HH +# define OLENA_CORE_STRUCT_ELT_HH + +# include <mlc/types.hh> +# include <oln/core/properties.hh> +# include <oln/core/coord.hh> +# include <oln/core/abstract/dpoint.hh> +# include <vector> +# include <utility> +# include <iostream> + +namespace oln { + + // fwd decl + namespace abstract { + template<class Exact> + struct struct_elt; + } + + // category + template <typename E> + struct set_category< abstract::struct_elt<E> > + { + typedef category::struct_elt ret; + }; + + /// properties of any type in category::struct_elt + + template <typename type> + struct props_of <category::struct_elt, type> + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::struct_elt, dpoint_type); + mlc_decl_prop(category::struct_elt, size_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::struct_elt, " + << typeid(type).name() << ") = {" + << " size_type = " << typeid(size_type).name() << "," << std::endl + << " dpoint_type = " << typeid(dpoint_type).name() << " }" << std::endl; + } + + }; + + mlc_register_prop(category::struct_elt, dpoint_type); + mlc_register_prop(category::struct_elt, size_type); + + + namespace abstract { + + /*! + ** Structuring elements (set of dpoints). + ** + ** This abstract class defines several virtual methods for its + ** subclasses. Its goal is to deal with a set of 'move' points. + */ + template<class E> + class struct_elt : public mlc::any__best_memory<E> + { + + public: + + typedef oln_type_of(E, dpoint) dpoint_type; + + typedef E exact_type; + + static std::string + name() + { + return std::string("struct_elt<") + exact_type::name() + ">"; + } + + bool + has(const abstract::dpoint<dpoint_type>& dp) const + { + return this->exact().impl_has(dp.exact()); + } + + unsigned + card() const + { + return this->exact().impl_card(); + } + + exact_type& + add(const dpoint_type& dp) + { + return this->exact().impl_add(dp); + } + + dpoint_type + dp(unsigned i) const + { + return this->exact().impl_at(i); + } + + const dpoint_type + operator[](unsigned i) const + { + return this->exact().impl_at(i); + } + + protected: + + bool + impl_has(const dpoint_type& dp) const + { + return std::find(dp_.begin(), dp_.end(), dp) != dp_.end(); + } + + exact_type& + impl_add(const dpoint_type& dp) + { + if (!(impl_has(dp))) + this->dp_.push_back(dp); + return this->exact(); + } + + unsigned + impl_card() const + { + return dp_.size(); + } + + const dpoint_type + impl_at(unsigned i) const + { + precondition(i < this->card()); + return dp_[i]; + } + + struct_elt() : dp_() + {}; + + struct_elt(unsigned size) : dp_() + { + dp_.reserve(size); + }; + + std::vector<dpoint_type> dp_; + + }; + } // end of abstract + +} // end of oln + +template<class E> +std::ostream& +operator<<(std::ostream& o, const oln::abstract::struct_elt<E>& se) +{ + unsigned c = se.card(); + o << "["; + for (unsigned i = 0; i < c; ++i) + o << se.dp(i); + o << "]"; + return o; +} + + +#endif // ! OLENA_CORE_STRUCT_ELT_HH Index: oln/core/2d/window2d.hh --- oln/core/2d/window2d.hh (revision 0) +++ oln/core/2d/window2d.hh (revision 0) @@ -0,0 +1,172 @@ +// 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_CORE_WINDOW2D_HH +# define OLENA_CORE_WINDOW2D_HH + +# include <oln/core/2d/dpoint2d.hh> +# include <oln/core/2d/size2d.hh> +# include <oln/core/coord.hh> +# include <oln/core/abstract/struct_elt.hh> + +namespace oln { + + class window2d; // forward declaration + + // category + template <> + struct set_category< window2d > { typedef category::struct_elt ret; }; + + // super_type + template <> + struct set_super_type< window2d > + { + typedef abstract::struct_elt< window2d > ret; + }; + + template <> + struct set_props< category::struct_elt, window2d > + : public props_of<category::struct_elt> + { + typedef dpoint2d dpoint_type; + typedef size2d size_type; + }; + + class window2d : public abstract::struct_elt<window2d> + { + + public: + + typedef abstract::struct_elt<window2d> super_type; + + /*! + ** \brief Construct a window of 2 dimensions. + */ + window2d() : super_type() + {} + + /*! + ** \brief Construct a window of 2 dimensions. + ** \arg size The number of element. + */ + window2d(unsigned size) : super_type(size) + {} + + /*! + ** \brief Construct a window of 2 dimensions from several points. + ** \arg n The number of element. + ** \arg crd The coordinates of the elements + */ + window2d(unsigned n, const coord_t crd[]) : super_type(n) + { + for (unsigned i = 0; i < 2 * n; i += 2) + this->add(dpoint_type(crd[i], crd[i+1])); + } + + window2d& + add(const dpoint_type& dp) + { + return this->exact().impl_add(dp); + } + + window2d& + add(coord_t row, coord_t col) + { + dpoint_type dp(row, col); + return add(dp); + } + + + /// Return the name of the type. + static std::string + name() + { + return std::string("window2d"); + } + + protected: + + }; + + + // std win + + /*! + ** \brief Create a window (2 dimensions) of 4 elements. + ** \return The new window. + */ + inline const window2d& + win_c4_only() + { + static const coord_t crd[] = { -1,0, 0,-1, 0,1, 1,0 }; + static const window2d win(4, crd); + return win; + } + + /*! + ** \brief Create a window (2 dimensions) of 5 elements. + ** \return The new window. + ** + ** It's the same than win_c4_only() plus the 0,0 point. + */ + inline const window2d& + win_c4p() + { + static const coord_t crd[] = { -1,0, 0,-1, 0,0, 0,1, 1,0 }; + static const window2d win(5, crd); + return win; + } + + /*! + ** \brief Create a window (2 dimensions) of 8 elements. + ** \return The new window. + */ + inline const window2d& + win_c8_only() + { + static const coord_t crd[] = { -1,-1, -1,0, -1,1, 0,-1, 0,1, 1,-1, 1,0, 1,1 }; + static const window2d win(8, crd); + return win; + } + + /*! + ** \brief Create a window (2 dimensions) of 9 elements. + ** \return The new window. + ** + ** It's the same than win_c8_only more the 0,0 point. + */ + inline const window2d& + win_c8p() + { + static const coord_t crd[] = { -1,-1, -1,0, -1,1, 0,-1, 0,0, 0,1, 1,-1, 1,0, 1,1 }; + static const window2d win(9, crd); + return win; + } + +} // end of oln + +#endif // OLENA_CORE_WINDOW2D_HH Index: oln/core/properties.hh --- oln/core/properties.hh (revision 73) +++ oln/core/properties.hh (working copy) @@ -41,6 +41,7 @@ { struct data_storage; struct image; + struct struct_elt; struct point; struct size; struct piter;

19 years, 1 month

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches March 2005