Olena-patches March 2005

olena-patches@lrde.epita.fr

10 participants
59 discussions

proto-1.0 100: Changes in erosion-dilation

by Thierry GERAUD

2005-03-31 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * oln/core/abstract/image_like_.hh: Set concrete_type property. * oln/core/abstract/image_operator.hh: Add typedefs. * oln/morpho/dilation.hh (proc::dilation): New. (impl::dilation_type): Rename as... (dilation_ret): ...this. (dilation_type_classic): Rename as... (generic_dilation): ...this. * oln/morpho/erosion.hh: Likewise. Index: oln/core/abstract/image_like_.hh ====================================================… [View More]=============== --- oln/core/abstract/image_like_.hh (revision 99) +++ oln/core/abstract/image_like_.hh (working copy) @@ -54,9 +54,16 @@ typedef abstract::image_by_delegation<I, E> ret; }; + // props + template <typename I, typename E> + struct set_props < category::image, abstract::image_like_<I, E> > : public props_of<category::image> + { + typedef oln_type_of(I, concrete) concrete_type; + }; + namespace abstract { /// Mutable version of image_like_. Index: oln/core/abstract/image_operator.hh =================================================================== --- oln/core/abstract/image_operator.hh (revision 99) +++ oln/core/abstract/image_operator.hh (working copy) @@ -107,6 +107,7 @@ } box<O> output; + typedef O output_type; protected: image_operator() {} @@ -120,6 +121,7 @@ struct image_unary_operator : public image_operator<O, E> { box<const I> input; + typedef I input_type; protected: @@ -140,7 +142,10 @@ { box<const I1> input1; + typedef I1 input1_type; + box<const I2> input2; + typedef I2 input2_type; protected: Index: oln/morpho/dilation.hh =================================================================== --- oln/morpho/dilation.hh (revision 99) +++ oln/morpho/dilation.hh (working copy) @@ -31,13 +31,33 @@ # include <oln/basics.hh> # include <oln/morpho/stat.hh> # include <oln/core/abstract/image_operator.hh> -// # include <oln/morpho/fast_morpho.hh> # include <mlc/cmp.hh> namespace oln { namespace morpho { + + + namespace proc { + + /// Dilation as a procedure (do not use it; prefer morpho::dilation). + + template<typename I, typename S> + oln_type_of(I, concrete) dilation(const abstract::image& input, + const abstract::struct_elt<S>& se) + { + oln_type_of(I, concrete) output(input.size()); + oln_type_of(I, fwd_piter) p(input.size()); + for_all (p) + output[p] = morpho::max(input, p, se); + return output; + } + + } // end of namespace oln::morpho::proc + + + /*! ** \brief Processing dilation. ** @@ -89,60 +109,70 @@ ** \image latex oln_morpho_dilation.png */ - // fwd decl - namespace impl { - template <typename I, typename E> struct dilation_type; - } + // fwd decl + template <typename I, typename E> struct dilation_ret; } // category template <typename I, typename E> - struct set_category< morpho::impl::dilation_type<I,E> > { typedef category::image ret; }; + struct set_category< morpho::dilation_ret<I,E> > { typedef category::image ret; }; // super_type template <typename I, typename E> - struct set_super_type< morpho::impl::dilation_type<I,E> > + struct set_super_type< morpho::dilation_ret<I,E> > { - typedef abstract::image_unary_operator<I, I, morpho::impl::dilation_type<I, E> > ret; // FIXME: see below + typedef abstract::image_unary_operator<oln_type_of(I, concrete), I, morpho::dilation_ret<I, E> > ret; }; + + namespace morpho { - namespace impl { + /// Dilatation return. - template <typename I, typename E> - struct dilation_type : public abstract::image_unary_operator<I, I, dilation_type<I, E> > - // FIXME: abstract::image_unary_operator<oln_type_of(I, concrete), ... - { - typedef abstract::image_unary_operator<I, I, dilation_type<I, E> > super_type; + template <typename I, typename S> + struct dilation_ret : public abstract::image_unary_operator<oln_type_of(I, concrete), I, dilation_ret<I, S> > + { + typedef abstract::image_unary_operator<oln_type_of(I, concrete), I, dilation_ret<I, S> > super_type; + typedef typename super_type::output_type output_type; - const E se; + const S se; - dilation_type(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) : - super_type(input.exact()), - se(se.exact()) - {} + dilation_ret(const abstract::image& input, + const abstract::struct_elt<S>& se) : + super_type(input.exact()), + se(se.exact()) + { + } - }; + }; - template <typename I, typename E> - struct dilation_type_classic : public dilation_type<I, E> + + // Implementation: + + namespace impl { + + /// Dilation generic implementation. + + template <typename I, typename S> + struct generic_dilation : public dilation_ret<I, S> { - typedef dilation_type<I, E> super_type; + typedef dilation_ret<I, S> super_type; + typedef typename super_type::output_type output_type; - dilation_type_classic(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) : + generic_dilation(const abstract::image& input, + const abstract::struct_elt<S>& se) : super_type(input, se) - {} + { + } void impl_run() { mlc::is_true<mlc::type::eq<oln_type_of(I, size), - oln_type_of(E, size)>::ret>::ensure(); + oln_type_of(S, size)>::ret>::ensure(); - I tmp(input.size()); // FIXME: trick + output_type tmp(input.size()); // FIXME: trick output = tmp; oln_type_of(I, fwd_piter) p(input.size()); @@ -151,29 +181,20 @@ } }; - } + } // end of namespace oln::morpho::impl - template<typename I, typename E> - impl::dilation_type<I, E> - dilation(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) + + /// Dilation generic routine. + + template<typename I, typename S> + dilation_ret<I, S> dilation(const abstract::image& input, + const abstract::struct_elt<S>& se) { - impl::dilation_type_classic<I, E> tmp(input, se); + impl::generic_dilation<I, S> tmp(input, se); tmp.run(); return tmp; } - -// namespace fast { -// template<class I, class E> -// oln_concrete_type(I) -// dilation(const abstract::non_vectorial_image& input, -// const abstract::struct_elt<E>& se) -// { -// return fast_morpho<I, E, utils::histogram_max<oln_value_type(I)> > -// (input, se); -// } -// } } // end of morpho } // end of oln Index: oln/morpho/erosion.hh =================================================================== --- oln/morpho/erosion.hh (revision 99) +++ oln/morpho/erosion.hh (working copy) @@ -30,13 +30,33 @@ # include <oln/basics.hh> # include <oln/morpho/stat.hh> -// # include <oln/morpho/fast_morpho.hh> # include <oln/core/abstract/image_operator.hh> # include <mlc/cmp.hh> namespace oln { namespace morpho { + + + namespace proc { + + /// Erosion as a procedure (do not use it; prefer morpho::erosion). + + template<typename I, typename S> + oln_type_of(I, concrete) dilation(const abstract::image& input, + const abstract::struct_elt<S>& se) + { + oln_type_of(I, concrete) output(input.size()); + oln_type_of(I, fwd_piter) p(input.size()); + for_all (p) + output[p] = morpho::min(input, p, se); + return output; + } + + } // end of namespace oln::morpho::proc + + + /*! ** \brief Perform a morphological erosion. ** @@ -84,58 +104,66 @@ */ // fwd decl - namespace impl { - template <typename I, typename E> struct erosion_type; - } + template <typename I, typename E> struct erosion_ret; } // category template <typename I, typename E> - struct set_category< morpho::impl::erosion_type<I,E> > { typedef category::image ret; }; + struct set_category< morpho::erosion_ret<I,E> > { typedef category::image ret; }; // super_type template <typename I, typename E> - struct set_super_type< morpho::impl::erosion_type<I,E> > + struct set_super_type< morpho::erosion_ret<I,E> > { - typedef abstract::image_unary_operator<I, I, morpho::impl::erosion_type<I, E> > ret; // FIXME: see below + typedef abstract::image_unary_operator<oln_type_of(I, concrete), I, morpho::erosion_ret<I, E> > ret; }; + namespace morpho { - namespace impl { + /// Erosion return. - template <typename I, typename E> - struct erosion_type : abstract::image_unary_operator<I, I, erosion_type<I, E> > - // FIXME: abstract::image_unary_operator<oln_type_of(I, concrete), ... - { - typedef abstract::image_unary_operator<I, I, erosion_type<I, E> > super_type; - const E se; + template <typename I, typename E> + struct erosion_ret : public abstract::image_unary_operator<oln_type_of(I, concrete), I, erosion_ret<I, E> > + { + typedef abstract::image_unary_operator<oln_type_of(I, concrete), I, erosion_ret<I, E> > super_type; + typedef typename super_type::output_type output_type; - erosion_type(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) : - super_type(input), - se(se.exact()) - {} + const E se; + + erosion_ret(const abstract::image& input, + const abstract::struct_elt<E>& se) : + super_type(input), + se(se.exact()) + { + } + + }; - }; - template <typename I, typename E> - struct erosion_type_classic : public erosion_type<I, E> + namespace impl { + + /// Erosion generic implementation. + + template <typename I, typename S> + struct generic_erosion : public erosion_ret<I, S> { - typedef erosion_type<I, E> super_type; + typedef erosion_ret<I, S> super_type; + typedef typename super_type::output_type output_type; - erosion_type_classic(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) : + generic_erosion(const abstract::image& input, + const abstract::struct_elt<S>& se) : super_type(input, se) - {} + { + } void impl_run() { mlc::is_true<mlc::type::eq<oln_type_of(I, size), - oln_type_of(E, size)>::ret>::ensure(); + oln_type_of(S, size)>::ret>::ensure(); - I tmp(input.size()); // FIXME: trick + output_type tmp(input.size()); // FIXME: trick output = tmp; oln_type_of(I, fwd_piter) p(input.size()); @@ -144,67 +172,24 @@ } }; - } + } // end of namespace oln::morpho::impl - template<typename I, typename E> - impl::erosion_type<I, E> - erosion(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) + /// Erosion generic routine. + + template<typename I, typename S> + erosion_ret<I, S> erosion(const abstract::image& input, + const abstract::struct_elt<S>& se) { - impl::erosion_type_classic<I, E> tmp(input, se); + impl::generic_erosion<I, S> tmp(input, se); tmp.run(); return tmp; } - namespace fast { - /*! - ** \brief Perform a morphological erosion. - ** - ** Compute the morphological erosion of input using se - ** as structuring element. - ** - ** \param I Exact type of the input image. - ** \param E Exact type of the structuring element. - ** - ** - ** \arg input Input image. - ** \arg se Structuring element to use. - ** - ** \code - ** #include <oln/basics2d.hh> - ** #include <oln/morpho/erosion.hh> - ** #include <oln/level/compare.hh> - ** #include <ntg/all.hh> - ** int main() - ** { - ** typedef oln::image2d<ntg::bin> im_type; - ** - ** im_type im1(oln::load(IMG_IN "object.pbm")); - ** save(oln::morpho::fast::erosion(im1, oln::win_c8p()), - ** IMG_OUT "oln_morpho_fast_erosion.pbm"); - ** } - ** \endcode - ** - ** \image html object_pbm.png - ** \image latex object_pbm.png - ** => - ** \image html oln_morpho_fast_erosion.png - ** \image latex oln_morpho_fast_erosion.png - */ -// template<typename I, typename E> -// oln_concrete_type(I) -// erosion(const abstract::non_vectorial_image& input, -// const abstract::struct_elt<E>& se) -// { -// return fast_morpho<I, E, utils::histogram_min<oln_value_type(I)> > -// (input, se); -// } - } // end of fast - } // end of morpho + } // end of namespace oln::morpho -} // end of oln +} // end of namespace oln #endif // ! OLENA_MORPHO_EROSION_HH [View Less]

19 years, 12 months

proto-1.0 99: Change image hierarchy for operators

by Thierry GERAUD

(désolé ! le système de commit auto a chié) 2005-03-31 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * oln/core/abstract/image_like_.hh: New. * oln/core/abstract/image_operator.hh: New. * oln/core/abstract/image_by_delegation.hh: New. * oln/core/abstract/image_identity.hh: Move to... * oln/core/gen/identity.hh: here. * tests/core/tests/image_identity: Update. * oln/core/abstract/op.hh: Update. * oln/core/2d/image2d.hh: Update. * oln/core/box.hh (image()): Rename into... … [View More]* oln/core/box.hh (unbox()): this. * oln/utils/clone.hh: Update. * oln/basics.hh: Likewise. * oln/morpho/dilation.hh: Likewise. * oln/morpho/erosion.hh: Likewise. * oln/io/read_image_2d_pnm.hh: Cosmetic change. * oln/arith/min.hh: Likewise. * oln/arith/max.hh: Likewise. Index: tests/core/tests/image_identity =================================================================== --- tests/core/tests/image_identity (revision 98) +++ tests/core/tests/image_identity (working copy) @@ -1,47 +1,18 @@ -#include <oln/core/abstract/image_identity.hh> #include <oln/core/2d/image2d.hh> +#include <oln/core/gen/identity.hh> #include <ntg/all.hh> -template <typename I> -struct image_identity; -namespace oln { - - template <typename I> - struct set_category< image_identity > - { - typedef category::image ret; - }; - - template <typename I> - struct set_props < category::image, image_identity > - : public get_props < category::image, I > - { - typedef I delegated_type; - }; - -} - -template <typename I> -struct image_identity : public oln::abstract::image_identity<I, image_identity > -{ - typedef oln::abstract::image_identity<I, image_identity > super_type; - - image_identity(I& ima) : super_type(ima) - { - this->exact_ptr = (image_identity*)(void*)(this); - } -}; - - bool check() { - oln::image2d<ntg::int_u8> ima(10, 10); - image_identity<oln::image2d<ntg::int_u8> > _ima(ima); - image_identity<image_identity<oln::image2d<ntg::int_u8> > > __ima(_ima); - oln::point2d p(0, 0); + using namespace oln; + point2d p(0, 0); + image2d<ntg::int_u8> ima(10, 10); + internal::image_identity< image2d<ntg::int_u8> > _ima(ima); + internal::image_identity< internal::image_identity< image2d<ntg::int_u8> > > __ima(_ima); + __ima[p] = 'a'; ntg::int_u8 b = ima[p]; if (b == 'a') Index: oln/core/abstract/image_like_.hh =================================================================== --- oln/core/abstract/image_like_.hh (revision 0) +++ oln/core/abstract/image_like_.hh (revision 0) @@ -0,0 +1,99 @@ +// 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_LIKE__HH +# define OLENA_CORE_ABSTRACT_IMAGE_LIKE__HH + +# include <oln/core/abstract/image_by_delegation.hh> + + +namespace oln { + + + // fwd decl + namespace abstract { + template <typename I, typename E> struct image_like_; + } + + // category + + template <typename I, typename E> + struct set_category< abstract::image_like_<I, E> > { + typedef category::image ret; + }; + + // super type + + template <typename I, typename E> + struct set_super_type < abstract::image_like_<I, E> > + { + typedef abstract::image_by_delegation<I, E> ret; + }; + + + + + namespace abstract { + + /// Mutable version of image_like_. + + template <typename I, typename E> + struct image_like_ : public image_by_delegation<I, E> + { + typedef image_by_delegation<I, E> super_type; + + public: + + image_like_ () + { + } + + image_like_(abstract::image& image) : + super_type(image) + { + } + + const I& real() const + { + return this->image_.unbox(); + } + + I& real() + { + return this->image_.unbox(); + } + + }; + + } // end of namespace oln::abstract + + + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_LIKE__HH Index: oln/core/abstract/image_identity.hh =================================================================== --- oln/core/abstract/image_identity.hh (revision 98) +++ oln/core/abstract/image_identity.hh (working copy) @@ -1,124 +0,0 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory -// -// This file is part of the Olena Library. This library is free -// software; you can redistribute it and/or modify it under the terms -// of the GNU General Public License version 2 as published by the -// Free Software Foundation. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this library; see the file COPYING. If not, write to -// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -// MA 02111-1307, USA. -// -// As a special exception, you may use this file as part of a free -// software library without restriction. Specifically, if other files -// instantiate templates or use macros or inline functions from this -// file, or you compile this file and link it with other files to -// produce an executable, this file does not by itself cause the -// resulting executable to be covered by the GNU General Public -// License. This exception does not however invalidate any other -// reasons why the executable file might be covered by the GNU General -// Public License. - -#ifndef OLENA_CORE_ABSTRACT_IMAGE_IDENTITY_HH -# define OLENA_CORE_ABSTRACT_IMAGE_IDENTITY_HH - -# include <mlc/box.hh> - -# include <oln/core/properties.hh> -# include <oln/core/abstract/entry.hh> - - -namespace oln { - - - // fwd decl - namespace abstract { - template <typename I, typename E> struct image_identity; - } - - // category - template <typename I, typename E> - struct set_category< abstract::image_identity<I,E> > { - typedef category::image ret; - }; - - // props - template <typename I, typename E> - struct set_props < category::image, abstract::image_identity<I,E> > - : public get_props< category::image, I > - { - typedef I delegated_type; - }; - - - - namespace abstract { - - template <typename I, typename E> - struct image_identity : public abstract::image_entry<E> - { - protected: - - image_identity () {} - - image_identity(abstract::image& image) : image_(image.exact()) - {} - - image_identity(const image_identity& rhs) : image_(rhs.image()) - { - this->exact_ptr = (E*)(void*)(this); - } - - mlc::box image_; - - public: - - I& image () const - { - return const_cast<I&>(*image_); - } - - I& impl_delegate() { return *image_; } - const I& impl_delegate() const { return *image_; } - }; - - - template <typename I, typename E> - struct image_identity<const I, E>: public abstract::image_entry<E> - { - protected: - - image_identity() {} - - image_identity(const abstract::image& image_) : image_(image.exact()) - {} - - image_identity(const image_identity& rhs) : image_(rhs.image()) - { - this->exact_ptr = (E*)(void*)(this); - } - - mlc::box<const I> image_; - - public: - const I& image () const - { - return *image_; - } - - I& impl_delegate() { return *image_; } - const I& impl_delegate() const { return *image_; } - }; - - } - -} - - -#endif // ! OLENA_CORE_ABSTRACT_IMAGE_IDENTITY_HH Index: oln/core/abstract/image_operator.hh =================================================================== --- oln/core/abstract/image_operator.hh (revision 0) +++ oln/core/abstract/image_operator.hh (revision 0) @@ -0,0 +1,166 @@ +// 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_OPERATOR_HH +# define OLENA_CORE_ABSTRACT_IMAGE_OPERATOR_HH + +# include <oln/core/abstract/image_like_.hh> + +namespace oln { + + // fwd decls + namespace abstract { + template <typename O, typename E> struct image_operator; + template <typename O, typename I, typename E> struct image_unary_operator; + template <typename O, typename I1, typename I2, typename E> struct image_binary_operator; + } + + // category + template <typename O, typename E> + struct set_category< abstract::image_operator<O, E> > { typedef category::image ret; }; + template <typename O, typename I, typename E> + struct set_category< abstract::image_unary_operator<O, I, E> > { typedef category::image ret; }; + template <typename O, typename I1, typename I2, typename E> + struct set_category< abstract::image_binary_operator<O, I1, I2, E> > { typedef category::image ret; }; + + // super types + template <typename O, typename E> + struct set_super_type< abstract::image_operator<O, E> > { typedef abstract::image_like_<O, E> ret; }; + template <typename O, typename I, typename E> + struct set_super_type< abstract::image_unary_operator<O, I, E> > { typedef abstract::image_operator<O, E> ret; }; + template <typename O, typename I1, typename I2, typename E> + struct set_super_type< abstract::image_binary_operator<O, I1, I2, E> > { typedef abstract::image_operator<O, E> ret; }; + + + namespace abstract { + + + /// Class image_operator. + // FIXME: some methods here should be defined in a real OO abstraction + + template <typename O, typename E> + struct image_operator : public image_like_<O, E> + { + + /// run + + void run() + { + this->impl_precondition(); + this->impl_before_run(); + this->impl_run(); + this->impl_after_run(); + + this->image_ = this->output; + + this->impl_postcondition(); + } + + virtual void impl_run() + { + // impl_run is defined here so that base operators can be instantiated + std::cerr << "oops: nothing done!" << std::endl; + } + + virtual void impl_before_run() + { + // nothing + } + + virtual void impl_after_run() + { + // nothing + } + + virtual void impl_precondition() + { + // none + } + + virtual void impl_postcondition() + { + // none + } + + box<O> output; + + protected: + image_operator() {} + + }; + + + /// Class image_unary_operator. + + template <typename O, typename I, typename E> + struct image_unary_operator : public image_operator<O, E> + { + box<const I> input; + + protected: + + image_unary_operator() {} + + image_unary_operator(const abstract::image& input) : + input(input) + { + } + + }; + + + /// Class image_binary_operator. + + template <typename O, typename I1, typename I2, typename E> + struct image_binary_operator : public image_operator<O, E> + { + + box<const I1> input1; + box<const I2> input2; + + protected: + + image_binary_operator() {} + + image_binary_operator(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) : + input1(input1), + input2(input2) + { + } + + }; + + + } // end of namespace oln::abstract + + + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_OPERATOR_HH Index: oln/core/abstract/image_by_delegation.hh =================================================================== --- oln/core/abstract/image_by_delegation.hh (revision 0) +++ oln/core/abstract/image_by_delegation.hh (revision 0) @@ -0,0 +1,145 @@ +// 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_BY_DELEGATION_HH +# define OLENA_CORE_ABSTRACT_IMAGE_BY_DELEGATION_HH + +# include <oln/core/box.hh> +# include <oln/core/properties.hh> +# include <oln/core/abstract/entry.hh> + + +namespace oln { + + + // fwd decl + namespace abstract { + template <typename I, typename E> struct image_by_delegation; + } + + // category + + template <typename I, typename E> + struct set_category< abstract::image_by_delegation<I, E> > { + typedef category::image ret; + }; + + template <typename I, typename E> + struct set_category< abstract::image_by_delegation<const I, E> > { + typedef category::image ret; + }; + + // props + + template <typename I, typename E> + struct set_props < category::image, abstract::image_by_delegation<I, E> > + : public get_props< category::image, I > + { + typedef I delegated_type; + }; + + template <typename I, typename E> + struct set_props < category::image, abstract::image_by_delegation<const I, E> > + : public get_props< category::image, I > + { + typedef I delegated_type; + }; + + + + + namespace abstract { + + /// Mutable version of image_by_delegation + + template <typename I, typename E> + struct image_by_delegation : public image_entry<E> + { + protected: + + image_by_delegation () + { + this->exact_ptr = (E*)(void*)(this); + } + + image_by_delegation(abstract::image& image) : + image_(image.exact()) + { + this->exact_ptr = (E*)(void*)(this); + } + + image_by_delegation(const image_by_delegation& rhs) : + image_(rhs.image_) + { + this->exact_ptr = (E*)(void*)(this); + } + + box image_; + + public: + + I& impl_delegate() { return this->image_.unbox(); } + const I& impl_delegate() const { return this->image_.unbox(); } + }; + + /// Const version of image_by_delegation + + template <typename I, typename E> + struct image_by_delegation<const I, E> : public image_entry<E> + { + protected: + + image_by_delegation() + { + this->exact_ptr = (E*)(void*)(this); + } + + image_by_delegation(const abstract::image& ima) : + image_(ima.exact()) + { + this->exact_ptr = (E*)(void*)(this); + } + + image_by_delegation(const image_by_delegation& rhs) : + image_(rhs.image()) + { + this->exact_ptr = (E*)(void*)(this); + } + + box<const I> image_; + + public: + + const I& impl_delegate() const { return this->image_.unbox(); } + }; + + } + +} + + +#endif // ! OLENA_CORE_ABSTRACT_IMAGE_BY_DELEGATION_HH Index: oln/core/abstract/op.hh =================================================================== --- oln/core/abstract/op.hh (revision 98) +++ oln/core/abstract/op.hh (working copy) @@ -29,7 +29,7 @@ # define OLENA_CORE_ABSTRACT_OP_HH # include <oln/core/box.hh> -# include <oln/core/abstract/image_identity.hh> +# include <oln/core/abstract/image_like_.hh> namespace oln { @@ -44,15 +44,15 @@ // super_type template <typename O, typename E> - struct set_super_type< abstract::op<O,E> > { typedef abstract::image_identity<O, E> ret; }; + struct set_super_type< abstract::op<O,E> > { typedef abstract::image_like_<O, E> ret; }; namespace abstract { template <typename O, typename E> - struct op : public image_identity<O, E> + struct op : public image_like_<O, E> { - typedef image_identity<O, E> super_type; + typedef image_like_<O, E> super_type; op(O& ref) : super_type(ref) { Index: oln/core/2d/image2d.hh =================================================================== --- oln/core/2d/image2d.hh (revision 98) +++ oln/core/2d/image2d.hh (working copy) @@ -30,7 +30,7 @@ # include <mlc/traits.hh> -# include <oln/core/abstract/image_identity.hh> +# include <oln/core/abstract/image_like_.hh> # include <oln/core/abstract/image_with_data.hh> # include <oln/core/abstract/image_vectorialness.hh> # include <oln/core/2d/array2d.hh> @@ -155,9 +155,10 @@ }; template <typename I, typename E> - image2d& operator=(const abstract::image_identity<I, E>& rhs) + image2d& operator=(abstract::image_like_<I, E> rhs) { - return *this = rhs.image(); + *this = rhs.real(); + return *this; } image2d& operator=(const io::filename& rhs) Index: oln/core/box.hh =================================================================== --- oln/core/box.hh (revision 98) +++ oln/core/box.hh (working copy) @@ -117,15 +117,15 @@ /// Hooks. -// I& image() -// { -// return this->image_; -// } + I& unbox() + { + return this->image_; + } -// const I& image() const -// { -// return this->image_; -// } + const I& unbox() const + { + return this->image_; + } private: @@ -194,10 +194,10 @@ /// Hook. -// const I& image() const -// { -// return this->image_; -// } + const I& unbox() const + { + return this->image_; + } private: Index: oln/utils/clone.hh =================================================================== --- oln/utils/clone.hh (revision 98) +++ oln/utils/clone.hh (working copy) @@ -28,18 +28,15 @@ #ifndef OLN_UTILS_CLONE_HH # define OLN_UTILS_CLONE_HH -# include <oln/core/abstract/op.hh> -# include <oln/core/abstract/piter.hh> +# include <oln/basics.hh> namespace oln { // fwd decl namespace utils { - namespace impl { template <typename I> struct clone_type; } - } // category @@ -53,7 +50,7 @@ template <typename I> struct set_super_type < utils::impl::clone_type > { - typedef abstract::op<I, utils::impl::clone_type > ret; + typedef abstract::image_unary_operator<I, I, utils::impl::clone_type > ret; }; @@ -63,40 +60,41 @@ namespace impl { template <typename I> - struct clone_type : abstract::op<I, clone_type > + struct clone_type : public abstract::image_unary_operator<I, I, clone_type > + // FIXME: use concrete_type; Cf. erosion.hh { - typedef abstract::op<I, clone_type > super_type; + typedef abstract::image_unary_operator<I, I, clone_type > super_type; - box input_; - - clone_type(I& input) : - input_(input) + clone_type(const abstract::image& input) : + super_type(input) { } void impl_run() { - I ima(input_.size()); - oln_type_of(I, fwd_piter) p(input_.size()); + I tmp(input.size()); // FIXME: trick + output = tmp; + oln_type_of(I, fwd_piter) p(input.size()); for_all(p) - ima[p] = input_[p]; - - *this->image_ = ima; + output[p] = input[p]; } }; - } + } // end of namespace oln::utils::impl + template <typename I> - impl::clone_type clone(abstract::image& ima) + impl::clone_type clone(const abstract::image& ima) { impl::clone_type tmp(ima.exact()); tmp.run(); return tmp; } - } -} + } // end of namespace oln::utils +} // end of namespace oln + + #endif // ! OLN_UTILS_CLONE_HH Index: oln/basics.hh =================================================================== --- oln/basics.hh (revision 98) +++ oln/basics.hh (working copy) @@ -52,13 +52,13 @@ # include <oln/core/coord.hh> # include <oln/core/properties.hh> # include <oln/core/value_box.hh> +# include <oln/core/box.hh> # 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/box.hh> -# include <oln/core/abstract/op.hh> +# include <oln/core/abstract/image_operator.hh> # include <oln/core/abstract/piter.hh> # include <oln/core/abstract/witer.hh> Index: oln/morpho/dilation.hh =================================================================== --- oln/morpho/dilation.hh (revision 98) +++ oln/morpho/dilation.hh (working copy) @@ -30,6 +30,7 @@ # include <oln/basics.hh> # include <oln/morpho/stat.hh> +# include <oln/core/abstract/image_operator.hh> // # include <oln/morpho/fast_morpho.hh> # include <mlc/cmp.hh> @@ -103,34 +104,36 @@ template <typename I, typename E> struct set_super_type< morpho::impl::dilation_type<I,E> > { - typedef abstract::op<I, morpho::impl::dilation_type<I, E> > ret; + typedef abstract::image_unary_operator<I, I, morpho::impl::dilation_type<I, E> > ret; // FIXME: see below }; namespace morpho { namespace impl { - template <class I, class E> - struct dilation_type : abstract::op<I, dilation_type<I, E> > + template <typename I, typename E> + struct dilation_type : public abstract::image_unary_operator<I, I, dilation_type<I, E> > + // FIXME: abstract::image_unary_operator<oln_type_of(I, concrete), ... { - box<const I> input_; - const E se_; + typedef abstract::image_unary_operator<I, I, dilation_type<I, E> > super_type; + const E se; + dilation_type(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) : - input_(input.exact()), - se_(se.exact()) + const abstract::struct_elt<E>& se) : + super_type(input.exact()), + se(se.exact()) {} }; - template <class I, class E> - struct dilation_type_classic : dilation_type<I, E> + template <typename I, typename E> + struct dilation_type_classic : public dilation_type<I, E> { typedef dilation_type<I, E> super_type; dilation_type_classic(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) : + const abstract::struct_elt<E>& se) : super_type(input, se) {} @@ -138,25 +141,22 @@ { mlc::is_true<mlc::type::eq<oln_type_of(I, size), oln_type_of(E, size)>::ret>::ensure(); - I output(this->input_.size()); - // FIXME: see erosion.hh - this->input_.resize_border(this->se_.get_delta()); + I tmp(input.size()); // FIXME: trick + output = tmp; - oln_type_of(I, fwd_piter) p(this->input_.size()); - + oln_type_of(I, fwd_piter) p(input.size()); for_all (p) - output[p] = morpho::max(this->input_, p, this->se_); - *this->image_ = output; + output[p] = morpho::max(input, p, se); } }; } - template<class I, class E> + template<typename I, typename E> impl::dilation_type<I, E> dilation(const abstract::non_vectorial_image& input, - const abstract::struct_elt<E>& se) + const abstract::struct_elt<E>& se) { impl::dilation_type_classic<I, E> tmp(input, se); tmp.run(); Index: oln/morpho/erosion.hh =================================================================== --- oln/morpho/erosion.hh (revision 98) +++ oln/morpho/erosion.hh (working copy) @@ -31,7 +31,7 @@ # include <oln/basics.hh> # include <oln/morpho/stat.hh> // # include <oln/morpho/fast_morpho.hh> -# include <oln/core/abstract/op.hh> +# include <oln/core/abstract/image_operator.hh> # include <mlc/cmp.hh> namespace oln { @@ -98,29 +98,30 @@ template <typename I, typename E> struct set_super_type< morpho::impl::erosion_type<I,E> > { - typedef abstract::op<I, morpho::impl::erosion_type<I, E> > ret; + typedef abstract::image_unary_operator<I, I, morpho::impl::erosion_type<I, E> > ret; // FIXME: see below }; namespace morpho { namespace impl { - template <class I, class E> - struct erosion_type : abstract::op<I, erosion_type<I, E> > + template <typename I, typename E> + struct erosion_type : abstract::image_unary_operator<I, I, erosion_type<I, E> > + // FIXME: abstract::image_unary_operator<oln_type_of(I, concrete), ... { - box<const I> input_; - const E se_; + typedef abstract::image_unary_operator<I, I, erosion_type<I, E> > super_type; + const E se; erosion_type(const abstract::non_vectorial_image& input, const abstract::struct_elt<E>& se) : - input_(input.exact()), - se_(se.exact()) + super_type(input), + se(se.exact()) {} }; - template <class I, class E> - struct erosion_type_classic : erosion_type<I, E> + template <typename I, typename E> + struct erosion_type_classic : public erosion_type<I, E> { typedef erosion_type<I, E> super_type; @@ -133,26 +134,20 @@ { mlc::is_true<mlc::type::eq<oln_type_of(I, size), oln_type_of(E, size)>::ret>::ensure(); - I output(this->input_.size()); - // FIXME: not only resize but also set values in border! - // FIXME: code commented below cause only valid with bordered_image + I tmp(input.size()); // FIXME: trick + output = tmp; - this->input_.resize_border(this->se_.get_delta()); - - oln_type_of(I, fwd_piter) p(this->input_.size()); - + oln_type_of(I, fwd_piter) p(input.size()); for_all (p) - output[p] = morpho::min(this->input_, p, this->se_); - // FIXME: remove * below (oln::box) - *this->image_ = output; + output[p] = morpho::min(input, p, se); } }; } - template<class I, class E> + template<typename I, typename E> impl::erosion_type<I, E> erosion(const abstract::non_vectorial_image& input, const abstract::struct_elt<E>& se) @@ -197,7 +192,7 @@ ** \image html oln_morpho_fast_erosion.png ** \image latex oln_morpho_fast_erosion.png */ -// template<class I, class E> +// template<typename I, typename E> // oln_concrete_type(I) // erosion(const abstract::non_vectorial_image& input, // const abstract::struct_elt<E>& se) Index: oln/io/read_image_2d_pnm.hh =================================================================== --- oln/io/read_image_2d_pnm.hh (revision 98) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -74,8 +74,7 @@ namespace impl { template <typename I> - struct read_image_2d_raw : - public oln::abstract::op<I, read_image_2d_raw > + struct read_image_2d_raw : public oln::abstract::op<I, read_image_2d_raw > { typedef oln::abstract::op<I, read_image_2d_raw > super_type; Index: oln/arith/min.hh =================================================================== --- oln/arith/min.hh (revision 98) +++ oln/arith/min.hh (working copy) @@ -29,6 +29,7 @@ # define OLENA_ARITH_MIN_HH # include <oln/basics.hh> +# include <oln/core/abstract/op.hh> # include <ntg/all.hh> namespace oln { @@ -60,7 +61,7 @@ namespace impl { template <class I> - struct min_type : abstract::op<I, min_type > + struct min_type : public abstract::op<I, min_type > { box<const I> input1_; box<const I> input2_; @@ -80,7 +81,7 @@ for_all(p) output[p] = ntg::min(input1_[p].value(), input2_[p].value()); - *this->image_ = output; + this->image_ = output; } }; Index: oln/arith/max.hh =================================================================== --- oln/arith/max.hh (revision 98) +++ oln/arith/max.hh (working copy) @@ -29,6 +29,7 @@ # define OLENA_ARITH_MAX_HH # include <oln/basics.hh> +# include <oln/core/abstract/op.hh> # include <ntg/all.hh> namespace oln { @@ -60,7 +61,7 @@ namespace impl { template <class I> - struct max_type : abstract::op<I, max_type > + struct max_type : public abstract::op<I, max_type > { box<const I> input1_; box<const I> input2_; @@ -80,7 +81,7 @@ for_all(p) output[p] = ntg::max(input1_[p].value(), input2_[p].value()); - *this->image_ = output; // FIXME: remove * when image_ is oln::box + this->image_ = output; } }; [View Less]

19 years, 12 months

proto-1.0 98: Use oln::box

by Thierry GERAUD

hop : --- :from: Thierry Geraud <theo(a)lrde.epita.fr> :server: :subject: "proto-1.0 98: Use oln::box" :groups: - lrde.olena.patches --- Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> * oln/core/box.hh: New. * oln/core/abstract/image.hh (resize_border): Temporary method to pass make check. * oln/core/abstract/image_with_data.hh: Update. * oln/core/abstract/op.hh: Likewise. * oln/utils/clone.hh: Likewise. * oln/basics.hh: Likewise. * oln/morpho/… [View More]dilation.hh: Likewise. * oln/morpho/erosion.hh: Likewise. * oln/arith/min.hh: Likewise. * oln/arith/max.hh: Likewise. * oln/morpho/stat.hh: Add test (hold) to pass make check. arith/max.hh | 14 +- arith/min.hh | 14 +- basics.hh | 2 core/abstract/image.hh | 17 ++- core/abstract/image_with_data.hh | 2 core/abstract/op.hh | 1 core/box.hh | 212 +++++++++++++++++++++++++++++++++++++++ morpho/dilation.hh | 15 +- morpho/erosion.hh | 18 ++- morpho/stat.hh | 20 ++- utils/clone.hh | 18 +-- 11 files changed, 288 insertions(+), 45 deletions(-) Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 97) +++ oln/core/abstract/image.hh (working copy) @@ -303,6 +303,14 @@ return this->exact().impl_get(p); } + + // FIXME: patch! + + void resize_border(size_t new_border, bool copy_border = false) const + { + this->exact().impl_resize_border(new_border, copy_border); + } + protected: /*! \brief Constructor (protected, empty). @@ -382,9 +390,16 @@ const value_type impl_get(const point_type& p) const { this->exact().impl_get_extra(p); - return this->delegate().impl_get(p); + return this->delegate().get(p); } + // FIXME: patch + + void impl_resize_border(size_t new_border, bool copy_border) const + { + this->delegate().impl_resize_border(new_border, copy_border); + } + // extra code; default is "do nothing" void impl_size_extra(const size_type& s) const {} Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 97) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -179,7 +179,7 @@ return data_ != 0; } - void resize_border(size_t new_border, bool copy_border = false) const + void impl_resize_border(size_t new_border, bool copy_border) const { (const_cast<storage_type&>(*this->data_)).resize_border(new_border, copy_border); } Index: oln/core/abstract/op.hh --- oln/core/abstract/op.hh (revision 97) +++ oln/core/abstract/op.hh (working copy) @@ -28,6 +28,7 @@ #ifndef OLENA_CORE_ABSTRACT_OP_HH # define OLENA_CORE_ABSTRACT_OP_HH +# include <oln/core/box.hh> # include <oln/core/abstract/image_identity.hh> namespace oln { Index: oln/core/box.hh --- oln/core/box.hh (revision 0) +++ oln/core/box.hh (revision 0) @@ -0,0 +1,212 @@ +// 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_BOX_HH +# define OLENA_CORE_BOX_HH + +# include <oln/core/properties.hh> +# include <oln/core/abstract/entry.hh> + +namespace oln { + + + // fwd decl + template <typename I> struct box; + + // category + + template <typename I> + struct set_category< box > { + typedef category::image ret; + }; + + template <typename I> + struct set_category< box<const I> > { + typedef category::image ret; + }; + + // props + + template <typename I> + struct set_props < category::image, box > + : public get_props< category::image, I > + { + typedef I delegated_type; + }; + + template <typename I> + struct set_props < category::image, box<const I> > + : public get_props< category::image, I > + { + typedef I delegated_type; + }; + + + /// Class oln::box... + + template <typename I> + struct box : public abstract::image_entry< box > + { + public: + + box () : + image_() + { + this->exact_ptr = this; + } + + box(abstract::image& ima) : + image_(ima.exact()) + { + this->exact_ptr = this; + } + + box& operator=(abstract::image& rhs) + { + this->image_ = rhs.exact(); + return *this; + } + + box(const box& rhs) : + image_(const_cast<I&>(rhs.image_)) + { + this->exact_ptr = this; + } + + box operator=(const box& rhs) + { + this->image_ = const_cast<I&>(rhs.image_); + return *this; + } + + // FIXME: add versions for I2 (neq I) to produce explicit errors + + I& impl_delegate() + { + return this->image_; + } + + const I& impl_delegate() const + { + return this->image_; + } + + /// Hooks. + +// I& image() +// { +// return this->image_; +// } + +// const I& image() const +// { +// return this->image_; +// } + + private: + + /// attribute + mutable I image_; + + }; + + + template <typename I> + struct box<const I> : public abstract::image_entry< box<const I> > + { + public: + + box() : + image_() + { + this->exact_ptr = this; + } + + box(const abstract::image& ima) : + image_(const_cast<I&>(ima.exact())) + { + this->exact_ptr = this; + } + + box<const I> operator=(const abstract::image& rhs) + { + this->image_ = const_cast<I&>(rhs.exact()); + return *this; + } + + /// Classical copy ctor (image remains const). + box(const box<const I>& rhs) : + image_(const_cast<I&>(rhs.image_)) + { + this->exact_ptr = this; + } + + /// Classical op= (image remains const). + box<const I> operator=(const box<const I>& rhs) + { + this->image_ = const_cast<I&>(rhs.image_); + return *this; + } + + /// Copy ctor with promotion (image becomes const). + box(const box& rhs) : + image_(const_cast<I&>(rhs.image_)) + { + this->exact_ptr = this; + } + + /// Op= with promotion (image becomes const). + box<const I> operator=(const box& rhs) + { + this->image_ = const_cast<I&>(rhs.image_); + return *this; + } + + /// Delegation relies on a constant image. + const I& impl_delegate() const + { + return this->image_; + } + + /// Hook. + +// const I& image() const +// { +// return this->image_; +// } + + private: + + /// attribute + mutable I image_; + + }; + +} + + +#endif // ! OLENA_CORE_BOX_HH Index: oln/utils/clone.hh --- oln/utils/clone.hh (revision 97) +++ oln/utils/clone.hh (working copy) @@ -67,20 +67,20 @@ { typedef abstract::op<I, clone_type > super_type; - mlc::box input_; + box input_; - clone_type(I& input) : input_(input) - {} + clone_type(I& input) : + input_(input) + { + } void impl_run() { - I ima(input_->size()); - oln_type_of(I, fwd_piter) it(input_->size()); + I ima(input_.size()); + oln_type_of(I, fwd_piter) p(input_.size()); - for_all(it) - { - ima[it] = (*input_)[it]; - } + for_all(p) + ima[p] = input_[p]; *this->image_ = ima; } Index: oln/basics.hh --- oln/basics.hh (revision 97) +++ oln/basics.hh (working copy) @@ -43,7 +43,6 @@ # include <mlc/traits.hh> # include <mlc/any.hh> # include <mlc/types.hh> -# include <mlc/box.hh> // ntg:: @@ -58,6 +57,7 @@ # include <oln/core/abstract/point.hh> # include <oln/core/abstract/images.hh> # include <oln/core/abstract/entry.hh> +# include <oln/core/box.hh> # include <oln/core/abstract/op.hh> # include <oln/core/abstract/piter.hh> Index: oln/morpho/dilation.hh --- oln/morpho/dilation.hh (revision 97) +++ oln/morpho/dilation.hh (working copy) @@ -113,8 +113,8 @@ template <class I, class E> struct dilation_type : abstract::op<I, dilation_type<I, E> > { - mlc::box<const I> input_; - mlc::box<const E> se_; + box<const I> input_; + const E se_; dilation_type(const abstract::non_vectorial_image& input, const abstract::struct_elt<E>& se) : @@ -138,12 +138,15 @@ { mlc::is_true<mlc::type::eq<oln_type_of(I, size), oln_type_of(E, size)>::ret>::ensure(); - I output(this->input_->size()); - this->input_->resize_border(this->se_->get_delta()); - oln_type_of(I, fwd_piter) p(this->input_->size()); + I output(this->input_.size()); + // FIXME: see erosion.hh + this->input_.resize_border(this->se_.get_delta()); + + oln_type_of(I, fwd_piter) p(this->input_.size()); + for_all (p) - output[p] = morpho::max(*this->input_, p, *this->se_); + output[p] = morpho::max(this->input_, p, this->se_); *this->image_ = output; } }; Index: oln/morpho/stat.hh --- oln/morpho/stat.hh (revision 97) +++ oln/morpho/stat.hh (working copy) @@ -71,8 +71,9 @@ dp.start(); V val = input[p + dp]; for_all_remaining (dp) - if (val < input[p + dp].value()) - val = input[p + dp].value(); + if (input.hold(p + dp)) + if (val < input[p + dp].value()) + val = input[p + dp].value(); return val; } @@ -97,8 +98,9 @@ dp.start(); V val = input[p + dp]; for_all_remaining (dp) - if (val > input[p + dp].value()) - val = input[p + dp].value(); + if (input.hold(p + dp)) + if (val > input[p + dp].value()) + val = input[p + dp].value(); return val; } @@ -116,8 +118,9 @@ oln_type_of(E, size)>::ret>::ensure(); oln_type_of(E, fwd_witer) dp(se); for_all (dp) - if (input[p + dp] == true) - return true; + if (input.hold(p + dp)) + if (input[p + dp] == true) + return true; return false; } @@ -128,8 +131,9 @@ oln_type_of(E, size)>::ret>::ensure(); oln_type_of(E, fwd_witer) dp(se); for_all (dp) - if (input[p + dp] == false) - return false; + if (input.hold(p + dp)) + if (input[p + dp] == false) + return false; return true; } Index: oln/morpho/erosion.hh --- oln/morpho/erosion.hh (revision 97) +++ oln/morpho/erosion.hh (working copy) @@ -108,8 +108,8 @@ template <class I, class E> struct erosion_type : abstract::op<I, erosion_type<I, E> > { - mlc::box<const I> input_; - mlc::box<const E> se_; + box<const I> input_; + const E se_; erosion_type(const abstract::non_vectorial_image& input, const abstract::struct_elt<E>& se) : @@ -133,12 +133,18 @@ { mlc::is_true<mlc::type::eq<oln_type_of(I, size), oln_type_of(E, size)>::ret>::ensure(); - I output(this->input_->size()); - this->input_->resize_border(this->se_->get_delta()); - oln_type_of(I, fwd_piter) p(this->input_->size()); + I output(this->input_.size()); + // FIXME: not only resize but also set values in border! + // FIXME: code commented below cause only valid with bordered_image + + this->input_.resize_border(this->se_.get_delta()); + + oln_type_of(I, fwd_piter) p(this->input_.size()); + for_all (p) - output[p] = morpho::min(*this->input_, p, *this->se_); + output[p] = morpho::min(this->input_, p, this->se_); + // FIXME: remove * below (oln::box) *this->image_ = output; } }; Index: oln/arith/min.hh --- oln/arith/min.hh (revision 97) +++ oln/arith/min.hh (working copy) @@ -62,8 +62,8 @@ template <class I> struct min_type : abstract::op<I, min_type > { - mlc::box<const I> input1_; - mlc::box<const I> input2_; + box<const I> input1_; + box<const I> input2_; min_type(const abstract::non_vectorial_image& input1, const abstract::non_vectorial_image& input2) : @@ -73,12 +73,12 @@ void impl_run() { - precondition(input1_->size() == input2_->size()); - I output(input1_->size()); - oln_type_of(I, fwd_piter) p(input1_->size()); + precondition(input1_.size() == input2_.size()); + I output(input1_.size()); + oln_type_of(I, fwd_piter) p(input1_.size()); for_all(p) - output[p] = ntg::min((*input1_)[p].value(), (*input2_)[p].value()); + output[p] = ntg::min(input1_[p].value(), input2_[p].value()); *this->image_ = output; } @@ -87,6 +87,8 @@ } + // FIXME: replace non_vectorial_image by scalar_image + // FIXME: cause arithmetics is not defined for Booleans and labels... template <typename I> impl::min_type min(const abstract::non_vectorial_image& input1, const abstract::non_vectorial_image& input2) Index: oln/arith/max.hh --- oln/arith/max.hh (revision 97) +++ oln/arith/max.hh (working copy) @@ -62,8 +62,8 @@ template <class I> struct max_type : abstract::op<I, max_type > { - mlc::box<const I> input1_; - mlc::box<const I> input2_; + box<const I> input1_; + box<const I> input2_; max_type(const abstract::non_vectorial_image& input1, const abstract::non_vectorial_image& input2) : @@ -73,14 +73,14 @@ void impl_run() { - precondition(input1_->size() == input2_->size()); - I output(input1_->size()); - oln_type_of(I, fwd_piter) p(input1_->size()); + precondition(input1_.size() == input2_.size()); + I output(input1_.size()); + oln_type_of(I, fwd_piter) p(input1_.size()); for_all(p) - output[p] = ntg::max((*input1_)[p].value(), (*input2_)[p].value()); + output[p] = ntg::max(input1_[p].value(), input2_[p].value()); - *this->image_ = output; + *this->image_ = output; // FIXME: remove * when image_ is oln::box } }; [View Less]

19 years, 12 months

proto-1.0 65: Correct for_all macro

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/core/abstract/piter.hh: Correct for_all. piter.hh | 2 +- 1 files changed, 1 insertion(+), 1 deletion(-) Index: oln/core/abstract/piter.hh --- oln/core/abstract/piter.hh (revision 64) +++ oln/core/abstract/piter.hh (working copy) @@ -37,7 +37,7 @@ -# define for_all(P) for(p.start(); p.is_valid(); p.next()) +# define for_all(p) for(p.start(); p.is_valid(); p.next()) namespace oln {

19 years, 12 months

proto-1.0 97: Add concrete type

by Nicolas Widynski

Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> * oln/core/abstract/image.hh: Add concrete type. * oln/core/abstract/image_with_data.hh: Likewise. * oln/core/properties.hh: Likewise. abstract/image.hh | 2 ++ abstract/image_with_data.hh | 1 + properties.hh | 1 + 3 files changed, 4 insertions(+) Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 96) +++ oln/core/… [View More]

20 years

proto-1.0 95: Add dpoint3d and point3d implementations

by Christophe Berger

20 years

proto-1.0 96: Add dpoint3d and point3d implementations

by Christophe Berger

Index: ChangeLog from Christophe Berger <christophe(a)lrde.epita.fr> * oln/core/abstract/point.hh: Fix point type. * oln/core/3d/dpoint3d.hh: New. * oln/core/3d/point3d.hh: Add operators (+-) implementations. * oln/basics3d.hh: Add new header inclusion. * oln/makefile.src: Add new file. basics3d.hh | 1 core/3d/dpoint3d.hh | 131 +++++++++++++++++++++++++++++++++++++++++++++++++ core/3d/point3d.hh | 22 ++++++++ core/abstract/point.hh | 11 ++-- … [View More]makefile.src | 1 5 files changed, 163 insertions(+), 3 deletions(-) Index: oln/core/abstract/point.hh --- oln/core/abstract/point.hh (revision 95) +++ oln/core/abstract/point.hh (working copy) @@ -94,7 +94,7 @@ ** ** \return True if both points are the same, false otherwise. */ - bool operator==(const point& rhs) const + bool operator==(const exact_type& rhs) const { return this->exact().impl_eq(rhs.exact()); } @@ -104,7 +104,7 @@ ** ** \return True if both points are different, false otherwise. */ - bool operator!=(const point& rhs) const + bool operator!=(const exact_type& rhs) const { return ! this->operator==(rhs); } @@ -118,7 +118,7 @@ return this->exact().impl_plus(dp); } - const dpoint_type operator-(const point& rhs) const + const dpoint_type operator-(const exact_type& rhs) const { return this->exact().impl_minus(rhs); } @@ -126,6 +126,11 @@ protected: point() {} + + /*! \brief Cpy constructor (protected, empty). + */ + point(const exact_type& pt) {} + }; } // end of namespace abstract Index: oln/core/3d/dpoint3d.hh --- oln/core/3d/dpoint3d.hh (revision 0) +++ oln/core/3d/dpoint3d.hh (revision 0) @@ -0,0 +1,131 @@ +// 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_3D_DPOINT3D_HH +# define OLENA_CORE_3D_DPOINT3D_HH + +# include <iostream> + +# include <oln/core/coord.hh> + +// FIXME: there's an assumption here: we do not need inheritance for +// dpoints. so abstract::dpoint does not exist... + +// FIXME: doc! + +namespace oln { + + struct point3d; + + struct dpoint3d + { + dpoint3d() + { + } + + dpoint3d(coord_t slice_, coord_t row_, coord_t col_) : + slice_(slice_), + row_(row_), + col_(col_) + { + } + + dpoint3d(const dpoint3d& rhs) : + slice_(rhs.slice_), + row_(rhs.row_), + col_(rhs.col_) + { + } + + dpoint3d& operator=(const dpoint3d& rhs) + { + if (&rhs == this) + return *this; + this->slice_ = rhs.slice_; + this->row_ = rhs.row_; + this->col_ = rhs.col_; + return *this; + } + + bool operator==(const dpoint3d& rhs) const + { + return this->row_ == rhs.row_ && this->col_ == rhs.col_ && this->slice_ == rhs.slice_; + } + + bool operator!=(const dpoint3d& rhs) const + { + return ! this->operator==(rhs); + } + + const dpoint3d operator+(const dpoint3d& rhs) const + { + dpoint3d tmp(this->slice() + rhs.slice(), this->row() + rhs.row(), this->col() + rhs.col()); + return tmp; + } + + const point3d operator+(const point3d& rhs) const; + + const dpoint3d operator-() const + { + dpoint3d tmp(-this->slice(), -this->row(), -this->col()); + return tmp; + } + + const coord_t row() const { return row_; } + const coord_t col() const { return col_; } + const coord_t slice() const { return slice_; } + + coord_t& row() { return row_; } + coord_t& col() { return col_; } + coord_t& slice() { return slice_; } + + protected: + coord_t slice_, row_, col_; + }; + +} // end of namespace oln + + +std::ostream& operator<<(std::ostream& ostr, const oln::dpoint3d& dp) +{ + return ostr << '(' << dp.slice() << ',' << dp.row() << ',' << dp.col() << ')'; +} + +# include <oln/core/3d/point3d.hh> + +namespace oln { + + const point3d dpoint3d::operator+(const point3d& rhs) const + { + point3d tmp(this->slice() + rhs.slice(), this->row() + rhs.row(), this->col() + rhs.col()); + return tmp; + } + +} + + +#endif // ! OLENA_CORE_3D_DPOINT3D_HH Index: oln/core/3d/point3d.hh --- oln/core/3d/point3d.hh (revision 95) +++ oln/core/3d/point3d.hh (working copy) @@ -92,6 +92,8 @@ this->row_ == rhs.row_ and this->col_ == rhs.col_; } + const point3d impl_plus(const dpoint3d& rhs) const; + const dpoint3d impl_minus(const point3d& rhs) const; const coord_t slice() const { return slice_; } const coord_t row() const { return row_; } @@ -114,4 +116,24 @@ } +# include <oln/core/3d/dpoint3d.hh> + + +namespace oln { + + const point3d point3d::impl_plus(const dpoint3d& rhs) const + { + point3d tmp(this->slice() + rhs.slice(), this->row() + rhs.row(), this->col() + rhs.col()); + return tmp; + } + + const dpoint3d point3d::impl_minus(const point3d& rhs) const + { + dpoint3d tmp(this->slice() - rhs.slice(), this->row() - rhs.row(), this->col() - rhs.col()); + return tmp; + } + +} // end of namespace oln + + #endif // ! OLENA_CORE_3D_POINT3D_HH Index: oln/basics3d.hh --- oln/basics3d.hh (revision 95) +++ oln/basics3d.hh (working copy) @@ -33,6 +33,7 @@ # include <oln/core/3d/size3d.hh> # include <oln/core/3d/point3d.hh> +# include <oln/core/3d/dpoint3d.hh> # include <oln/core/3d/image3d.hh> #endif // ! OLENA_BASICS3D_HH Index: oln/makefile.src --- oln/makefile.src (revision 95) +++ oln/makefile.src (working copy) @@ -36,6 +36,7 @@ core/3d/fwd_piter3d.hh \ core/3d/image3d.hh \ core/3d/point3d.hh \ + core/3d/dpoint3d.hh \ core/3d/size3d.hh \ core/abstract/data_storage.hh \ core/abstract/dpoint.hh \ [View Less]

20 years

proto-1.0 94: Make the `any__best_memory' fast when using gcc-3

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * mlc/any.hh: Make the `any__best_memory' fast when using gcc-3. any.hh | 18 ++++++++++++++++++ 1 files changed, 18 insertions Index: mlc/any.hh --- mlc/any.hh (revision 93) +++ mlc/any.hh (working copy) @@ -108,20 +108,36 @@ // "best memory" version of 'any' + // FIXME: + // We should test with autotools if the compiler allows us to write a + // static_cast or not (diamond inheritance problem). gcc-2.95 gives a … [View More]

20 years

proto-1.0 95: Add missing image, fixes

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/convert/tests/value_to_point: Fix a wrong instruction. * oln/io/read_image_2d_pnm.hh: Move static variables inside an inline function to attributes. * img/object.pbm: New. Add missing image for dilation and erosion tests. img/object.pbm | 0 oln/io/read_image_2d_pnm.hh | 7 ++++--- tests/convert/tests/value_to_point | 1 - 3 files changed, 4 insertions, 4 deletions Index: … [View More]

20 years

proto-1.0 61: Add comparison traits in metalic

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/cmp.hh: Add comparison traits (greatereq, greater, neq, ...). cmp.hh | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 81 insertions(+), 1 deletion(-) Index: mlc/cmp.hh --- mlc/cmp.hh (revision 59) +++ mlc/cmp.hh (working copy) @@ -32,11 +32,16 @@ # include <mlc/bool.hh> -namespace mlc +namespace mlc { namespace type { + /*-----------------. + | … [View More]

20 years

2025

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