- Olena-patches

proto-1.0 168: Add features to nbhs and niters.
by Thierry GERAUD 27 Apr '05

27 Apr '05

2005-04-27 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * oln/funobj/accum.hh (min_accumulator_init): New class. * oln/core/abstract/niter.hh (for_all_n_of_p): Fix bug. (set_type<image,I,niter_type>): New type deduction. (set_type<image,I,fwd_niter_type>): Likewise. (set_type<image,I,bkd_niter_type>): Likewise. * oln/core/abstract/neighborhood.hh (iter, fwd_iter, bkd_iter): New properties. * oln/core/gen/regular_neighborhood.hh: Update. * oln/core/abstract/window.hh (operator-): New. * oln/core/pw/image.hh (grid_type): New property. (concrete_type): Likewise. Index: oln/convert/nbh_to_se.hh =================================================================== --- oln/convert/nbh_to_se.hh (revision 166) +++ oln/convert/nbh_to_se.hh (working copy) @@ -1,82 +0,0 @@ -// Copyright (C) 2002, 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_CONVERT_NBH_TO_SE_HH -# define OLENA_CONVERT_NBH_TO_SE_HH - -# include <oln/core/abstract/neighborhood.hh> -# include <oln/core/2d/dpoint2d.hh> - - -namespace oln { - namespace convert { - /*! Convert a neighborhood to a window. - ** - ** \see nbh_to_cse - */ - template<class N> - oln_nbh_type_of(N, window) - nbh_to_se(const N& nbh) // FIXME: UGLY oln::abstract::neighborhood<N>& nbh) - { - oln_nbh_type_of(N, window) output; - - for (unsigned i = 0; i < nbh.card(); i++) - output.add(nbh.dp(i)); - return output; - } - - void dpoint_zero(dpoint2d& dp) - { - dp.row() = 0; - dp.col() = 0; - } - - /*! Convert a neighborhood to a window and add the center. - ** - ** \see nbh_to_cs - */ - template<class N> - oln_nbh_type_of(N, window) - nbh_to_cse(const N& nbh) // FIXME: UGLY oln::abstract::neighborhood<N>& nbh) - { - oln_nbh_type_of(N, window) output; - - for (unsigned i = 0; i < nbh.card(); i++) - output.add(nbh.dp(i)); - - oln_nbh_type_of(N, dpoint) zero; - dpoint_zero(zero); - output.add(zero); - return output; - } - - - } // convert -} // oln - - -#endif // OLENA_CONVERT_NBH_TO_SE_HH Index: oln/funobj/accum.hh =================================================================== --- oln/funobj/accum.hh (revision 166) +++ oln/funobj/accum.hh (working copy) @@ -55,7 +55,7 @@ acc_ = t; return; } - if (t > acc_) + if (acc_ < t) acc_ = t; } @@ -73,6 +73,10 @@ }; + // FIXME: ... Max accumulator with initialization value. + + + /// Min accumulator. template <class T> @@ -109,6 +113,35 @@ }; + /// Min accumulator with initialization value. + + template <class T> + struct min_accumulator_init + { + + template <typename U> + min_accumulator_init(const U& init) : + acc_(init) + {} + + void operator()(T t) + { + if (t < acc_) + acc_ = t; + } + + operator T() const + { + return acc_; + } + + private: + + T acc_; + + }; + + } // end of namespace oln::funobj } // end of namespace oln Index: oln/core/abstract/niter.hh =================================================================== --- oln/core/abstract/niter.hh (revision 166) +++ oln/core/abstract/niter.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// Copyright (C) 2001-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 @@ -29,14 +29,14 @@ # define OLENA_CORE_ABSTRACT_NITER_HH # include <mlc/contract.hh> -# include <oln/core/typedefs.hh> +# include <oln/core/abstract/image.hh> # include <oln/core/abstract/iter.hh> # include <oln/core/abstract/point.hh> # include <oln/core/abstract/neighborhood.hh> # define for_all_n_of_p(n, p) \ - for(n.ensure_is_niter(), n.center_at(p), n.start(); n.is_valid(); n.next()) + for(n.ensure_is_niter(), n.start_at_p(p); n.is_valid(); n.next()) # define for_all_remaining_n(n) \ for(n.ensure_is_niter(); n.is_valid(); n.next()) @@ -146,6 +146,32 @@ } // end of namespace oln::abstract + + + // From image type to niters. + + template <typename I> + struct set_type < category::image, I, internal::typedef_::niter_type > + { + typedef oln_type_of(I, neighb) neighb_t; + typedef oln_nbh_type_of(neighb_t, iter) ret; + }; + + template <typename I> + struct set_type < category::image, I, internal::typedef_::fwd_niter_type > + { + typedef oln_type_of(I, neighb) neighb_t; + typedef oln_nbh_type_of(neighb_t, fwd_iter) ret; + }; + + template <typename I> + struct set_type < category::image, I, internal::typedef_::bkd_niter_type > + { + typedef oln_type_of(I, neighb) neighb_t; + typedef oln_nbh_type_of(neighb_t, bkd_iter) ret; + }; + + } // end of namespace oln Index: oln/core/abstract/neighborhood.hh =================================================================== --- oln/core/abstract/neighborhood.hh (revision 166) +++ oln/core/abstract/neighborhood.hh (working copy) @@ -50,6 +50,10 @@ typedef mlc::undefined_type dpoint_type; typedef mlc::undefined_type size_type; typedef mlc::undefined_type window_type; + + typedef mlc::undefined_type iter_type; + typedef mlc::undefined_type fwd_iter_type; + typedef mlc::undefined_type bkd_iter_type; }; @@ -61,14 +65,20 @@ typedef oln_nbh_type_of(N, dpoint) dpoint_type; typedef oln_nbh_type_of(N, size) size_type; typedef oln_nbh_type_of(N, window) window_type; + typedef oln_nbh_type_of(N, iter) iter_type; + typedef oln_nbh_type_of(N, fwd_iter) fwd_iter_type; + typedef oln_nbh_type_of(N, bkd_iter) bkd_iter_type; static void echo(std::ostream& ostr) { ostr << "props_of( oln::category::neighborhood, " << mlc_to_string(N) << " ) =" << std::endl << "{" << std::endl - << "\t dpoint_type = " << mlc_to_string(dpoint_type) << std::endl - << "\t size_type = " << mlc_to_string(size_type) << std::endl - << "\t window_type = " << mlc_to_string(window_type) << std::endl + << "\t dpoint_type = " << mlc_to_string(dpoint_type) << std::endl + << "\t size_type = " << mlc_to_string(size_type) << std::endl + << "\t window_type = " << mlc_to_string(window_type) << std::endl + << "\t iter_type = " << mlc_to_string(iter_type) << std::endl + << "\t fwd_iter_type = " << mlc_to_string(fwd_iter_type) << std::endl + << "\t bkd_iter_type = " << mlc_to_string(bkd_iter_type) << std::endl << "}" << std::endl; } @@ -77,6 +87,9 @@ mlc::is_ok< dpoint_type >::ensure(); mlc::is_ok< size_type >::ensure(); mlc::is_ok< window_type >::ensure(); + mlc::is_ok< iter_type >::ensure(); + mlc::is_ok< fwd_iter_type >::ensure(); + mlc::is_ok< bkd_iter_type >::ensure(); } }; Index: oln/core/abstract/window.hh =================================================================== --- oln/core/abstract/window.hh (revision 166) +++ oln/core/abstract/window.hh (working copy) @@ -28,6 +28,7 @@ #ifndef OLENA_CORE_ABSTRACT_WINDOW_HH # define OLENA_CORE_ABSTRACT_WINDOW_HH +# include <mlc/contract.hh> # include <oln/core/typedefs.hh> @@ -96,6 +97,13 @@ template<class W> struct window : public mlc::any<W> { + public: + + const W operator-() const + { + return this->exact().impl_op_minus(); + } + protected: window() @@ -104,6 +112,7 @@ ~window() { get_props<category::window, W>::ensure(); + mlc_check_method_impl(W, const W, op_minus, , const); } }; Index: oln/core/pw/image.hh =================================================================== --- oln/core/pw/image.hh (revision 166) +++ oln/core/pw/image.hh (working copy) @@ -36,6 +36,8 @@ # include <oln/core/pw/abstract/function.hh> // FIXME: remove +# include <oln/core/2d/grid2d.hh> +# include <oln/core/2d/image2d.hh> # include <oln/core/2d/fwd_piter2d.hh> # include <oln/core/2d/bkd_piter2d.hh> @@ -130,12 +132,14 @@ typedef mlc::no_type delegated_type; - // FIXME: AWFUL we do not know if it is 2d... + // FIXME: EXTREMELY AWFUL!!! we do not know if it is 2d... typedef is_a<abstract::image2d> image_dimension_type; + typedef grid2d grid_type; typedef fwd_piter2d piter_type; typedef fwd_piter2d fwd_piter_type; typedef bkd_piter2d bkd_piter_type; + typedef image2d<value_type> concrete_type; }; Index: oln/core/gen/regular_neighborhood.hh =================================================================== --- oln/core/gen/regular_neighborhood.hh (revision 166) +++ oln/core/gen/regular_neighborhood.hh (working copy) @@ -36,6 +36,8 @@ // fwd decl template <typename G> class regular_neighborhood; + template <typename G> class regular_fwd_niter; + template <typename G> class regular_bkd_niter; // super_type template <typename G> struct set_super_type< regular_neighborhood<G> > { typedef abstract::neighborhood< regular_neighborhood<G> > ret; }; @@ -61,6 +63,11 @@ typedef oln_grd_type_of(G, dpoint) dpoint_type; typedef oln_grd_type_of(G, size) size_type; typedef typename internal::to_window<G>::ret window_type; + + typedef regular_fwd_niter<G> iter_type; + typedef regular_fwd_niter<G> fwd_iter_type; + typedef regular_bkd_niter<G> bkd_iter_type; + };

1 0

proto-1.0 165: Bug fix of macros in mlc/contract.hh.
by Thierry GERAUD 27 Apr '05

27 Apr '05

2005-04-27 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * mlc/contract.hh (mlc_check_method_impl): Fix bug. (mlc_check_method_impl_2): Likewise. Index: mlc/contract.hh =================================================================== --- mlc/contract.hh (revision 165) +++ mlc/contract.hh (working copy) @@ -40,21 +40,22 @@ # define postcondition(expr) assert(expr) + # define mlc_check_method_impl(WHERE, RETURN, NAME, ARG, CONST) \ { \ typedef RETURN (WHERE::*meth)(ARG) CONST; \ - meth adr = &E::impl_##NAME; \ + meth adr = &WHERE::impl_##NAME; \ adr = 0; \ } \ struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n -# define mlc_check_method_impl_2(WHERE, RETURN, NAME, ARG1, ARG2, CONST) \ -{ \ - typedef RETURN (WHERE::*meth)(ARG1, ARG2) CONST; \ - meth adr = &E::impl_##NAME; \ - adr = 0; \ -} \ +# define mlc_check_method_impl_2(WHERE, RETURN, NAME, ARG1, ARG2, CONST) \ +{ \ + typedef RETURN (WHERE::*meth)(ARG1, ARG2) CONST; \ + meth adr = &WHERE::impl_##NAME; \ + adr = 0; \ +} \ struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n

1 1

proto-1.0 167: Bug fixes.
by Thierry GERAUD 27 Apr '05

27 Apr '05

2005-04-27 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> * oln/core/abstract/image_with_extension.hh (real): Fix signature ---such an image is mutable so 'real' should be const and should return non-const. * oln/core/gen/regular_fwd_niter.hh (friend): Fix bug. * oln/core/gen/regular_bkd_niter.hh: Likewise. * oln/core/gen/image_with_nbh.hh (concrete_type): Fix bug. (image_with_nbh()): New ctor. (image_with_nbh(size)): New ctor. (nbh_): Fix bug ---change type so that nbh is really owned. * oln/core/gen/regular_window.hh (operator-): Rename as... (impl_op_minus): ...this and fix bug. (dp): New method. 2005-04-20 Damien Thivolle <damien(a)lrde.epita.fr> * oln/morpho/reconstruction.hh: Remove a comment. Index: oln/core/abstract/image_with_extension.hh =================================================================== --- oln/core/abstract/image_with_extension.hh (revision 165) +++ oln/core/abstract/image_with_extension.hh (working copy) @@ -73,16 +73,11 @@ { } - const I& real() const + I& real() const { - return this->image_.unbox(); + return const_cast<I&>(this->image_.unbox()); } - I& real() - { - return this->image_.unbox(); - } - ~image_with_extension () { // FIXME : This class must check all properties Index: oln/core/gen/regular_fwd_niter.hh =================================================================== --- oln/core/gen/regular_fwd_niter.hh (revision 165) +++ oln/core/gen/regular_fwd_niter.hh (working copy) @@ -55,6 +55,7 @@ } friend class abstract::iter<self_type>; + friend class abstract::niter<self_type>; protected: @@ -70,7 +71,7 @@ bool impl_is_valid() const { - return this->pos_ != this->nbh_.card(); + return this->pos_ != int(this->nbh_.card()); } void impl_invalidate() Index: oln/core/gen/regular_bkd_niter.hh =================================================================== --- oln/core/gen/regular_bkd_niter.hh (revision 165) +++ oln/core/gen/regular_bkd_niter.hh (working copy) @@ -55,6 +55,7 @@ } friend class abstract::iter<self_type>; + friend class abstract::niter<self_type>; protected: Index: oln/core/gen/image_with_nbh.hh =================================================================== --- oln/core/gen/image_with_nbh.hh (revision 165) +++ oln/core/gen/image_with_nbh.hh (working copy) @@ -48,6 +48,7 @@ { typedef is_a<abstract::image_with_nbh> image_neighbness_type; typedef N neighb_type; + typedef image_with_nbh< oln_type_of(I, concrete), N> concrete_type; }; template <typename I, typename N> @@ -58,6 +59,16 @@ public: + image_with_nbh() + { + } + + image_with_nbh(const oln_type_of(I, size)& size) + { + I tmp(size); // FIXME: hack + this->image_ = tmp; + } + image_with_nbh(abstract::image& image, const abstract::neighborhood<N>& nbh) : super_type(image), @@ -65,6 +76,13 @@ { } + image_with_nbh(abstract::image& image, + const abstract::neighborhood<N>& nbh) : + super_type(image), + nbh_(nbh.exact()) + { + } + const N& impl_nbh_get() const { return nbh_; @@ -72,7 +90,7 @@ protected: - const N& nbh_; + N nbh_; }; Index: oln/core/gen/regular_window.hh =================================================================== --- oln/core/gen/regular_window.hh (revision 165) +++ oln/core/gen/regular_window.hh (working copy) @@ -97,11 +97,17 @@ return this->dp_[i]; } - const self_type operator-() const + dpoint_type& dp(unsigned i) { - self_type tmp; + precondition(i < this->card()); + return this->dp_[i]; + } + + const E impl_op_minus() const + { + E tmp = this->exact(); // FIXME: use clone(?) for (unsigned i = 0; i < this->card(); ++i) - tmp.add_(- this->dp_[i]); + tmp.dp(i) = - tmp.dp(i); return tmp; }

1 0

proto-1.0 165: Add hit or miss
by Damien Thivolle 20 Apr '05

20 Apr '05

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/morpho/reconstruction.hh: Remove a comment. * oln/morpho/hit_or_miss.hh: New. Hit or miss implementation. * oln/arith/ops.hh: Add comment to make it compile with g++-3.4. * oln/arith/min.hh: Add a template parameter. * oln/arith/max.hh: Add a template parameter. arith/max.hh | 38 +++++---- arith/min.hh | 38 +++++---- arith/ops.hh | 24 +++--- morpho/hit_or_miss.hh | 186 +++++++++++++++++++++++++++++++++++++++++++++++ morpho/reconstruction.hh | 2 5 files changed, 244 insertions(+), 44 deletions(-) Index: oln/morpho/reconstruction.hh --- oln/morpho/reconstruction.hh (revision 164) +++ oln/morpho/reconstruction.hh (working copy) @@ -45,8 +45,6 @@ # include <oln/utils/clone.hh> -// FIXME: ADD TESTS !!!! - namespace oln { Index: oln/morpho/hit_or_miss.hh --- oln/morpho/hit_or_miss.hh (revision 0) +++ oln/morpho/hit_or_miss.hh (revision 0) @@ -0,0 +1,186 @@ +// Copyright (C) 2001, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_HIT_OR_MISS_HH +# define OLENA_MORPHO_HIT_OR_MISS_HH + +# include <oln/core/gen/image_with_nbh.hh> +# include <oln/morpho/erosion.hh> +# include <oln/morpho/dilation.hh> +# include <oln/arith/min.hh> +# include <oln/utils/invert.hh> + +namespace oln { + + namespace tag { + + // No tags yet + + } // end of namespace oln::morpho::tag + + + namespace morpho { + template <typename I, typename W1, typename W2> struct hit_or_miss_ret; + } // end of namespace oln::morpho + + // super_type + + template <typename I, typename W1, typename W2> + struct set_super_type< morpho::hit_or_miss_ret<I, W1, W2> > + { + typedef oln_type_of(I, concrete) output_type; + + typedef morpho::hit_or_miss_ret<I, W1, W2> self_type; + typedef abstract::image_unary_operator<output_type, I, self_type > ret; + }; + + namespace morpho { + + // Reconstruction as a 'classical' procedure returning an image (do not + // use it; prefer morpho::hit_or_miss). + + namespace proc { + + // FIXME: ... + + } // end of namespace oln::morpho::proc + + + template <typename I, typename W1, typename W2> + struct hit_or_miss_ret : + // FIXME: oln_super_of_ + public oln::internal::get_super_type< hit_or_miss_ret<I, W1, W2> >::ret + { + typedef hit_or_miss_ret<I, W1, W2> self_type; + typedef typename oln::internal::get_super_type<self_type>::ret super_type; + const W1& win1; + const W2& win2; + + hit_or_miss_ret(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) : + super_type(input), + win1(win1.exact()), + win2(win2.exact()) + { + } + + }; + + + namespace impl { + + template <typename I, typename W1, typename W2> + struct generic_hit_or_miss : public hit_or_miss_ret<I, W1, W2> + { + typedef hit_or_miss_ret<I, W1, W2> super_type; + + generic_hit_or_miss(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) : + super_type(input, win1, win2) + { + } + + void impl_run() + { + this->output = arith::min(erosion(this->input, this->win1), + erosion(utils::invert(this->input), + this->win2)); + } + }; + + template <typename I, typename W1, typename W2> + hit_or_miss_ret<I, W1, W2> + hit_or_miss(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) + { + generic_hit_or_miss<I, W1, W2> tmp(input, win1, win2); + tmp.run(); + return tmp; + } + + } //end of namespace impl + + template <typename I, typename W1, typename W2> + hit_or_miss_ret<I, W1, W2> + hit_or_miss(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) + { + // FIXME: win1 inter win2 must be empty + return impl::hit_or_miss(input.exact(), win1.exact(), win2.exact()); + } + + + template<class I, class W1, class W2> + dilation_ret<hit_or_miss_ret<I, W1, W2>, W1> + hit_or_miss_opening(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) + { + return dilation(hit_or_miss(input, win1, win2), -win1); + } + + template<class I, class W1, class W2> + dilation_ret<hit_or_miss_ret<I, W2, W1>, W2> + hit_or_miss_opening_bg(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) + { + return hit_or_miss_opening(input, win2, win1); + } + + template<class I, class W1, class W2> + utils::image_inverted<dilation_ret<hit_or_miss_ret<utils::image_inverted, + W1, W2>, W1> > // !!! + hit_or_miss_closing(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) + { + return utils::invert(hit_or_miss_opening(utils::invert(input), + win1, win2)); + } + + template<class I, class W1, class W2> + utils::image_inverted<dilation_ret<hit_or_miss_ret<utils::image_inverted, + W2, W1>, W2> > // !!! + hit_or_miss_closing_bg(const abstract::image& input, + const abstract::regular_window<oln_type_of(I, grid), W1> win1, + const abstract::regular_window<oln_type_of(I, grid), W2> win2) + { + return hit_or_miss_closing(input, win2, win1); + } + + + + } // end of namespace morpho + +} // end of namespace oln + +#endif // ! OLENA_MORPHO_HIT_OR_MISS_HH Index: oln/arith/ops.hh --- oln/arith/ops.hh (revision 164) +++ oln/arith/ops.hh (working copy) @@ -131,18 +131,18 @@ -template <typename I, typename F> -void operator + (const oln::abstract::image&, - const oln::pw::abstract::function<F>&) -{ - struct OLENA_ERROR__args_are_not_compatible(); -} -template <typename F, typename I> -void operator + (const oln::pw::abstract::function<F>&, - const oln::abstract::image&) -{ - struct OLENA_ERROR__args_are_not_compatible(); -} +// template <typename I, typename F> +// void operator + (const oln::abstract::image&, +// const oln::pw::abstract::function<F>&) +// { +// struct OLENA_ERROR__args_are_not_compatible(); +// } +// template <typename F, typename I> +// void operator + (const oln::pw::abstract::function<F>&, +// const oln::abstract::image&) +// { +// struct OLENA_ERROR__args_are_not_compatible(); +// } // FIXME: to be continued... Index: oln/arith/min.hh --- oln/arith/min.hh (revision 164) +++ oln/arith/min.hh (working copy) @@ -38,38 +38,45 @@ namespace arith { // fwd decl namespace impl { - template <typename I> struct min_type; + template <typename I1, typename I2> struct min_type; } } // super_type - template <typename I> - struct set_super_type< arith::impl::min_type > + template <typename I1, typename I2> + struct set_super_type< arith::impl::min_type<I1, I2> > { - typedef abstract::image_binary_operator<I, I, I, arith::impl::min_type > ret; + typedef oln_type_of(I1, concrete) output_type; + typedef arith::impl::min_type<I1, I2> self_type; + typedef abstract::image_binary_operator<output_type, I1, I2, self_type> ret; }; namespace arith { namespace impl { - template <class I> - struct min_type : public abstract::image_binary_operator<I, I, I, min_type > + template <typename I1, typename I2> + struct min_type : + // FIXME: oln_super_of_ + public oln::internal::get_super_type< min_type<I1,I2> >::ret { - typedef abstract::image_binary_operator<I, I, I, min_type > super_type; + typedef typename oln::internal::get_super_type< min_type<I1,I2> >::ret + super_type; + typedef oln_type_of(I1, concrete) output_type; - min_type(const abstract::image& input1, - const abstract::image& input2) : + min_type(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) : super_type(input1.exact(), input2.exact()) {} void impl_run() { precondition(this->input1.size() == this->input2.size()); - I output(this->input1.size()); - oln_type_of(I, fwd_piter) p(this->input1.size()); + output_type output(this->input1.size()); + oln_type_of(I1, fwd_piter) p(this->input1.size()); + for_all_p (p) output[p] = ntg::min(this->input1[p].value(), this->input2[p].value()); @@ -80,11 +87,12 @@ } - template <typename I> - impl::min_type min(const abstract::image& input1, - const abstract::image& input2) + template <typename I1, typename I2> + impl::min_type<I1, I2> min(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) { - impl::min_type tmp(input1, input2); + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + impl::min_type<I1, I2> tmp(input1, input2); tmp.run(); return tmp; } Index: oln/arith/max.hh --- oln/arith/max.hh (revision 164) +++ oln/arith/max.hh (working copy) @@ -38,38 +38,45 @@ namespace arith { // fwd decl namespace impl { - template <typename I> struct max_type; + template <typename I1, typename I2> struct max_type; } } // super_type - template <typename I> - struct set_super_type< arith::impl::max_type > + template <typename I1, typename I2> + struct set_super_type< arith::impl::max_type<I1, I2> > { - typedef abstract::image_binary_operator<I, I, I, arith::impl::max_type > ret; + typedef oln_type_of(I1, concrete) output_type; + typedef arith::impl::max_type<I1, I2> self_type; + typedef abstract::image_binary_operator<output_type, I1, I2, self_type> ret; }; namespace arith { namespace impl { - template <class I> - struct max_type : public abstract::image_binary_operator<I, I, I, max_type > + template <typename I1, typename I2> + struct max_type : + // FIXME: oln_super_of_ + public oln::internal::get_super_type< max_type<I1,I2> >::ret { - typedef abstract::image_binary_operator<I, I, I, max_type > super_type; + typedef typename oln::internal::get_super_type< max_type<I1,I2> >::ret + super_type; + typedef oln_type_of(I1, concrete) output_type; - max_type(const abstract::image& input1, - const abstract::image& input2) : + max_type(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) : super_type(input1.exact(), input2.exact()) {} void impl_run() { precondition(this->input1.size() == this->input2.size()); - I output(this->input1.size()); - oln_type_of(I, fwd_piter) p(this->input1.size()); + output_type output(this->input1.size()); + oln_type_of(I1, fwd_piter) p(this->input1.size()); + for_all_p (p) output[p] = ntg::max(this->input1[p].value(), this->input2[p].value()); @@ -80,11 +87,12 @@ } - template <typename I> - impl::max_type max(const abstract::image& input1, - const abstract::image& input2) + template <typename I1, typename I2> + impl::max_type<I1, I2> max(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) { - impl::max_type tmp(input1, input2); + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + impl::max_type<I1, I2> tmp(input1, input2); tmp.run(); return tmp; }

1 0

proto-1.0 163: Fix a bug on binary images i/o
by Damien Thivolle 18 Apr '05

18 Apr '05

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/io/write_image_2d_pnm.hh (ntg::bin): Write padding bits at the end of each line. * oln/io/read_image_2d_pnm.hh (ntg::bin): Skip padding bits at the end of each line. read_image_2d_pnm.hh | 24 +++++++++++++++++++----- write_image_2d_pnm.hh | 40 ++++++++++++++++++++++------------------ 2 files changed, 41 insertions, 23 deletions Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 163) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -74,33 +74,43 @@ { point2d p; value_type c; - bool b = false; for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row()) - for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) + { + for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) // FIXME: SHOULD NOT BE .value() !!! - b = write_value_type(to_write_[p].value()); - while (b == false) - b = write_value_type(c); - bin_offset = 7; - bin_v = 0; + write_value_type(to_write_[p].value()); + write_padding(c); + } } + template <typename E> + void write_padding(const ntg::value<E>&) {} + + void write_padding(const ntg::bin&) + { + if (bin_offset != 7) + { + ostr_.write(&bin_v, 1); + bin_offset = 7; + bin_v = 0; + } + } + //FIXME: Should work with builtin types. template <typename E> - bool write_value_type(const ntg::real_value<E> &c) + void write_value_type(const ntg::real_value<E> &c) { typedef oln_io_type(ntg_nbits(E)) v_type; v_type v; v = ntg::cast::bound<E, v_type>(c.exact()); ostr_.write((char*)&v, sizeof (v_type)); - return true; } template <typename E> - bool write_value_type(const ntg::vect_value<E> &c) + void write_value_type(const ntg::vect_value<E> &c) { for (unsigned i = 0; i < 3; i++) { @@ -110,25 +120,19 @@ v = c[i]; ostr_.write((char*)&v, sizeof (v_type)); } - return true; } - bool write_value_type(const ntg::bin &c) + void write_value_type(const ntg::bin &c) { - bool ret = false; - if (bin_offset == -1) { - bin_v = ~bin_v; ostr_.write(&bin_v, 1); bin_offset = 7; bin_v = 0; - ret = true; } - if (c == value_type(0)) + if (c == value_type(1)) bin_v |= 1 << bin_offset; bin_offset--; - return ret; } }; Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 163) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -119,14 +119,28 @@ precond(c); for (p.row() = 0; p.row() < info_.rows && !istr_.eof(); ++p.row()) - for (p.col() = 0; p.col() < info_.cols && !istr_.eof(); ++p.col()) - { - read_value_type(c); - tmp[p] = c; - } + { + offset = -1; + for (p.col() = 0; p.col() < info_.cols && !istr_.eof(); ++p.col()) + { + read_value_type(c); + tmp[p] = c; + } + } this->output = tmp; } + +// template <typename E> +// void read_padding(const ntg::value<E>&) +// { +// } + +// void read_padding(const ntg::bin&) +// { +// offset = -1; +// } + //FIXME: Should work with builtin types. template <typename E>

2 2

proto-1.0 164:...
by Damien Thivolle 17 Apr '05

17 Apr '05

Encore un probleme avec vcs, les modifications du patch 163 n'ont pas ete commitees sur le repository, j'ai donc du le faire a la main... -- Damien Thivolle damien(a)lrde.epita.fr

1 0

proto-1.0 163: Add canvas in reconstruction
by Damien Thivolle 17 Apr '05

17 Apr '05

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/morpho/tests/reconstruction: New. * oln/convert/nbh_to_se.hh: Adapt to new neighborhoods. * oln/core/abstract/image_neighbness.hh (impl_get_nbh): Add missing method. * oln/morpho/reconstruction.hh: New hierarchy. * oln/morpho/splitse.hh: Adapt to new neighborhoods. * oln/morpho/reconstruction_by_erosion.inc: New. Implementation for reconstruction by erosion. * oln/morpho/reconstruction_canvas.inc: New. Canvas for reconstruction: sequential & hybrid. * oln/morpho/reconstruction_by_dilation.inc: New. Implementation for reconstruction by dilation. * img/marker.pbm: New. * img/mask.pbm: New. img/marker.pbm | 0 img/mask.pbm | 0 oln/convert/nbh_to_se.hh | 8 oln/core/abstract/image_neighbness.hh | 6 oln/morpho/reconstruction.hh | 514 +++++++----------------------- oln/morpho/reconstruction_by_dilation.inc | 142 ++++++++ oln/morpho/reconstruction_by_erosion.inc | 141 ++++++++ oln/morpho/reconstruction_canvas.inc | 238 +++++++++++++ oln/morpho/splitse.hh | 127 +++---- tests/morpho/tests/reconstruction | 66 +++ 10 files changed, 780 insertions, 462 deletions Index: tests/morpho/tests/reconstruction --- tests/morpho/tests/reconstruction (revision 0) +++ tests/morpho/tests/reconstruction (revision 0) @@ -0,0 +1,66 @@ +// -*- C++ -*- + +#include "data.hh" +#include <oln/basics2d.hh> +#include <ntg/all.hh> + +#include <oln/core/gen/image_with_nbh.hh> + +#include <oln/morpho/reconstruction.hh> + +#include <oln/io/read_image.hh> +#include <oln/io/write_image.hh> + +#include <oln/level/compare.hh> +#include <oln/utils/md5.hh> +#include <oln/utils/invert.hh> + +bool check() +{ + using namespace oln; + image2d<ntg::bin> marker; + image2d<ntg::bin> mask; + image2d<ntg::bin> res_dil_hyb; + image2d<ntg::bin> res_dil_seq; + image2d<ntg::bin> res_ero_hyb; + image2d<ntg::bin> res_ero_seq; + + utils::key::value_type data_key[16] = + { + 0x36, 0xa6, 0x2e, 0x7e, 0xbf, 0x21, 0xf6, 0x2b, + 0xbf, 0x57, 0x58, 0xdc, 0x9d, 0x72, 0x41, 0x8f + }; + utils::key key(data_key); + + marker = io::read(rdata("marker.pbm")); + mask = io::read(rdata("mask.pbm")); + + res_dil_hyb = morpho::reconstruction(tag::by_dilation(), + join(marker, neighb_c4()), + mask, + tag::hybrid()); + res_dil_seq = morpho::reconstruction(tag::by_dilation(), + join(marker, neighb_c4()), + mask, + tag::sequential()); + + res_ero_hyb = morpho::reconstruction(tag::by_erosion(), + utils::invert(join(marker, neighb_c4())), + utils::invert(mask), + tag::hybrid()); + res_ero_seq = morpho::reconstruction(tag::by_erosion(), + utils::invert(join(marker, neighb_c4())), + utils::invert(mask), + tag::sequential()); + + if (utils::md5(res_dil_hyb) != key) + return true; + if (!level::is_equal(res_dil_hyb, res_dil_seq)) + return true; + if (!level::is_equal(res_ero_hyb, res_ero_seq)) + return true; + if (!level::is_equal(res_dil_hyb, utils::invert(res_ero_seq))) + return true; + + return false; +} Index: oln/convert/nbh_to_se.hh --- oln/convert/nbh_to_se.hh (revision 162) +++ oln/convert/nbh_to_se.hh (working copy) @@ -40,12 +40,12 @@ */ template<class N> oln_nbh_type_of(N, window) - nbh_to_se(const oln::abstract::neighborhood<N>& nbh) + nbh_to_se(const N& nbh) // FIXME: UGLY oln::abstract::neighborhood<N>& nbh) { oln_nbh_type_of(N, window) output; for (unsigned i = 0; i < nbh.card(); i++) - output.add(nbh[i]); + output.add(nbh.dp(i)); return output; } @@ -61,12 +61,12 @@ */ template<class N> oln_nbh_type_of(N, window) - nbh_to_cse(const oln::abstract::neighborhood<N>& nbh) + nbh_to_cse(const N& nbh) // FIXME: UGLY oln::abstract::neighborhood<N>& nbh) { oln_nbh_type_of(N, window) output; for (unsigned i = 0; i < nbh.card(); i++) - output.add(nbh[i]); + output.add(nbh.dp(i)); oln_nbh_type_of(N, dpoint) zero; dpoint_zero(zero); Index: oln/core/abstract/image_neighbness.hh --- oln/core/abstract/image_neighbness.hh (revision 162) +++ oln/core/abstract/image_neighbness.hh (working copy) @@ -53,6 +53,12 @@ return this->exact().impl_nbh_get(); } + //FIXME: is it the right way ? + const neighb_type& impl_nbh_get() const + { + return this->exact().delegate().nbh_get(); + } + protected: image_with_nbh() {} Index: oln/morpho/reconstruction.hh --- oln/morpho/reconstruction.hh (revision 162) +++ oln/morpho/reconstruction.hh (working copy) @@ -49,453 +49,181 @@ namespace oln { - namespace morpho { - // fwd decl - template <typename I, typename E> struct reconstruction_ret; + namespace tag { - } + template <typename Op> struct oper {}; - // category - template <typename I, typename E> - struct set_category< morpho::reconstruction_ret<I,E> > { typedef category::image ret; }; + struct by_dilation : public oper< by_dilation > {}; + struct by_erosion : public oper< by_erosion > {}; - // super_type - template <typename I, typename E> - struct set_super_type< morpho::reconstruction_ret<I,E> > - { - typedef abstract::image_binary_operator<I, I, I, morpho::reconstruction_ret<I, E> > ret; - // FIXME: see below - }; + template <typename A> struct algo {}; - namespace morpho { + struct sequential : public algo< sequential > {}; + struct hybrid : public algo< hybrid > {}; - template <typename I, typename N> - struct reconstruction_ret : public abstract::image_binary_operator<I, I, I, reconstruction_ret<I, N> > - // FIXME: abstract::image_binary_operator<oln_type_of(I, concrete), ... - { - typedef abstract::image_binary_operator<I, I, I, reconstruction_ret<I, N> > super_type; + } // end of namespace oln::morpho::tag - const N nbh; - reconstruction_ret(const abstract::image& input1, - const abstract::image& input2, - const abstract::neighborhood<N>& nbh) : - super_type(input1.exact(), input2.exact()), - nbh(nbh.exact()) - {} - }; + namespace morpho { + template <typename I1, typename I2> struct reconstruction_ret; + } // end of namespace oln::morpho - namespace sequential { + // super_type - namespace impl { + template <typename I1, typename I2> + struct set_super_type< morpho::reconstruction_ret<I1, I2> > + { + typedef oln_type_of(I1, concrete) output_type; - template <typename I, typename N, typename E> - struct reconstruction_sequential_ret : public reconstruction_ret<I, N> - { - typedef reconstruction_ret<I, N> super_type; + typedef morpho::reconstruction_ret<I1,I2> self_type; + typedef abstract::image_binary_operator<output_type, I1, I2, self_type > ret; + }; - void fwd_loop_body() - { - static_cast<E*>((void*)this)->fwd_loop_body_impl(); - } + namespace morpho { - void bkd_loop_body() - { - static_cast<E*>((void*)this)->bkd_loop_body_impl(); - } + // Reconstruction as a 'classical' procedure returning an image (do not + // use it; prefer morpho::reconstruction). - void preconditions() - { - precondition(this->input1.size() == this->input2.size()); - static_cast<E*>((void*)this)->preconditions_impl(); - } + namespace proc { - void impl_run() - { - mlc::eq<oln_type_of(I, size), oln_type_of(N, size)>::ensure(); + // FIXME: ... - I output; - output = utils::clone(this->input1); - bool non_stability = true; - while (non_stability) - { - work.unbox() = utils::clone(output); - for_all_p (fwd_p) - fwd_loop_body(); - for_all_p (bkd_p) - bkd_loop_body(); + } // end of namespace oln::morpho::proc - non_stability = !(level::is_equal(work, output)); - output = work.unbox(); - } - this->output = output; - } - protected: - reconstruction_sequential_ret(const abstract::image& input1, //marker - const abstract::image& input2, //mask - const abstract::neighborhood<N>& nbh) - : super_type(input1, input2, nbh), - fwd_p(input1.size()), - bkd_p(input1.size()) - { - se_plus = get_plus_se_p(convert::nbh_to_cse(this->nbh)); - se_minus = get_minus_se_p(convert::nbh_to_cse(this->nbh)); - } + template <typename I1, typename I2> + struct reconstruction_ret : + // FIXME: oln_super_of_ + public oln::internal::get_super_type< reconstruction_ret<I1,I2> >::ret + { + typedef reconstruction_ret<I1, I2> self_type; + typedef typename oln::internal::get_super_type<self_type>::ret super_type; - oln_type_of(N, window) se_plus; - oln_type_of(N, window) se_minus; - oln_type_of(I, fwd_piter) fwd_p; - oln_type_of(I, bkd_piter) bkd_p; - box work; + box<const I1> marker; + box<const I2> mask; - }; + reconstruction_ret(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask), + marker(marker), + mask(mask) + { + } - template <typename I, typename N> - struct reconstruction_dilation_ret : - public reconstruction_sequential_ret<I, N, reconstruction_dilation_ret<I, N> > - { - typedef reconstruction_sequential_ret<I, N, reconstruction_dilation_ret<I, N> > super_type; + const oln_type_of(I1, neighb)& impl_nbh_get() const + { + return marker.nbh_get(); + } - reconstruction_dilation_ret(const abstract::image& input1, //marker - const abstract::image& input2, //mask - const abstract::neighborhood<N>& nbh) + }; - : super_type(input1, input2, nbh) - {} + } // end of namespace morpho - void fwd_loop_body_impl() - { - this->work[this->fwd_p] = ntg::min(morpho::max(this->work.unbox(), - this->fwd_p, - this->se_plus), - this->input2[this->fwd_p].value()); - } +} // end of namespace oln - void bkd_loop_body_impl() - { - this->work[this->bkd_p] = ntg::min(morpho::max(this->work.unbox(), - this->bkd_p, - this->se_minus), - this->input2[this->bkd_p].value()); - } +# include <oln/morpho/reconstruction_canvas.inc> - void preconditions_impl() - { - precondition(level::is_greater_or_equal(this->input2, this->input1)); - } +namespace oln { - }; + namespace morpho { + namespace impl { - template <typename I, typename N> - struct reconstruction_erosion_ret : - public reconstruction_sequential_ret<I, N, reconstruction_erosion_ret<I, N> > - { - typedef reconstruction_sequential_ret<I, N, reconstruction_erosion_ret<I, N> > super_type; + template<typename Op, typename A, typename I1, typename I2> + struct generic_reconstruction; - reconstruction_erosion_ret(const abstract::image& input1, //marker - const abstract::image& input2, //mask - const abstract::neighborhood<N>& nbh) + } // end of namespace impl - : super_type(input1, input2, nbh) - {} + } // end of namespace morpho - void fwd_loop_body_impl() - { - this->work[this->fwd_p] = ntg::max(morpho::min(this->work.unbox(), - this->fwd_p, - this->se_plus), - this->input2[this->fwd_p].value()); - } +} // end of namespace oln - void bkd_loop_body_impl() - { - this->work[this->bkd_p] = ntg::max(morpho::min(this->work.unbox(), - this->bkd_p, - this->se_minus), - this->input2[this->bkd_p].value()); - } +# include <oln/morpho/reconstruction_by_dilation.inc> +# include <oln/morpho/reconstruction_by_erosion.inc> - void preconditions_impl() - { - precondition(level::is_greater_or_equal(this->input1, this->input2)); - } +namespace oln { - }; + namespace morpho { - } + namespace impl { - template<class I, class N> - reconstruction_ret<I, N> - geodesic_reconstruction_dilation(const abstract::image & marker, - const abstract::image & mask, - const abstract::neighborhood<N>& nbh) - { - impl::reconstruction_dilation_ret<I, N> tmp(marker, mask, nbh); - tmp.run(); - return tmp; - } + // Generic implementation of reconstruction (routine). - template<class I, class N> - reconstruction_ret<I, N> - geodesic_reconstruction_erosion(const abstract::image & marker, - const abstract::image & mask, - const abstract::neighborhood<N>& nbh) + template<typename Op, typename A, typename I1, typename I2> + reconstruction_ret<I1,I2> + reconstruction(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) { - impl::reconstruction_erosion_ret<I, N> tmp(marker, mask, nbh); + generic_reconstruction<Op, A, I1, I2> tmp(marker, mask); tmp.run(); return tmp; } - }// sequential + } // end of namespace impl + /// Generic reconstruction (facade). - namespace hybrid { + template<typename Op, typename I1, typename I2, typename A> + reconstruction_ret<I1,I2> + reconstruction(const tag::oper<Op>& oper_, + const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask, + const tag::algo<A>& algo_) + { + return impl::reconstruction<Op,A>(marker.exact(), mask.exact()); + } - namespace impl { + // by dilation - template <typename I, typename N, typename E> - struct reconstruction_hybrid_ret : public reconstruction_ret<I, N> - { - typedef reconstruction_ret<I, N> super_type; + template<typename I1, typename I2, typename A> + reconstruction_ret<I1,I2> + reconstruction_by_dilation(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask, + const tag::algo<A>& algo_) + { + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + precondition(marker.size() == mask.size()); + return reconstruction(tag::by_dilation(), marker, mask, algo_); + } - bool exist_init() - { - // FIXME: to many changes => rewrite! -// typedef oln_type_of(N, window) se_type; -// oln_type_of(se_type, fwd_qiter) dp(se_minus); -// for_all (dp) -// { -// q = (oln_type_of(se_type, dpoint))dp + -// (oln_type_of(I, point))bkd_p; -// if (static_cast<E*>((void*)this)->exist_init_impl()) -// return true; -// } - return false; - } + template<typename I1, typename I2> + reconstruction_ret<I1,I2> + reconstruction_by_dilation(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) + { + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + precondition(marker.size() == mask.size()); + return reconstruction(tag::by_dilation(), marker, mask, tag::hybrid()); + } - void fwd_loop_body() - { - static_cast<E*>((void*)this)->fwd_loop_body_impl(); - } + // by erosion - void bkd_loop_body() - { - static_cast<E*>((void*)this)->bkd_loop_body_impl(); - } + template<typename I1, typename I2, typename A> + reconstruction_ret<I1,I2> + reconstruction_by_erosion(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask, + const tag::algo<A>& algo_) + { + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + precondition(marker.size() == mask.size()); + return reconstruction(tag::by_erosion(), marker, mask, algo_); + } - void fifo_loop_body() - { - static_cast<E*>((void*)this)->fifo_loop_body_impl(); - } + template<typename I1, typename I2> + reconstruction_ret<I1,I2> + reconstruction_by_erosion(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) + { + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + precondition(marker.size() == mask.size()); + return reconstruction(tag::by_erosion(), marker, mask, tag::hybrid()); + } - void preconditions() - { - precondition(this->input1.size() == this->input2.size()); - static_cast<E*>((void*)this)->preconditions_impl(); - } + } // end of namespace oln::morpho - void impl_run() - { - mlc::eq<oln_type_of(I, size), oln_type_of(N, size)>::ensure(); - preconditions(); +} // end of namespace oln - this->output.unbox() = utils::clone(this->input1); - - for_all_p (fwd_p) - fwd_loop_body(); - - for_all_p (bkd_p) - { - bkd_loop_body(); - if (exist_init()) - fifo.push(bkd_p); - } - // Propagation Step - while (!fifo.empty()) - { - p = fifo.front(); - fifo.pop(); - // FIXME: AWFUL commented cause too many changes! -// typedef oln_type_of(N, window) window_type; -// window_type w = convert::nbh_to_se(this->nbh); -// oln_wn_type_of(window_type, fwd_iter) q(w); - -// for_all_q_of_p (q) -// { -// if (this->output.hold(q)) -// fifo_loop_body(); -// } - } - } - - protected: - - reconstruction_hybrid_ret(const abstract::image& input1, //marker - const abstract::image& input2, //mask - const abstract::neighborhood<N>& nbh) - - : super_type(input1, input2, nbh), - fwd_p(input1.size()), - bkd_p(input1.size()) - { - se_plus = get_plus_se_p(convert::nbh_to_cse(this->nbh)); - se_minus = get_minus_se_p(convert::nbh_to_cse(this->nbh)); - } - - oln_type_of(N, window) se_plus; - oln_type_of(N, window) se_minus; - oln_type_of(I, fwd_piter) fwd_p; - oln_type_of(I, bkd_piter) bkd_p; - oln_type_of(I, point) p; - oln_type_of(I, point) q; - std::queue<oln_type_of(I, point) > fifo; - - - }; - - - template <typename I, typename N> - struct reconstruction_dilation_ret : - public reconstruction_hybrid_ret<I, N, reconstruction_dilation_ret<I, N> > - { - typedef reconstruction_hybrid_ret<I, N, reconstruction_dilation_ret<I, N> > super_type; - - reconstruction_dilation_ret(const abstract::image& input1, //marker - const abstract::image& input2, //mask - const abstract::neighborhood<N>& nbh) - - : super_type(input1, input2, nbh) - {} - - void fwd_loop_body_impl() - { - this->output[this->fwd_p] = ntg::min(morpho::max(this->output.unbox(), - this->fwd_p, - this->se_plus), - this->input2[this->fwd_p].value()); - } - - void bkd_loop_body_impl() - { - this->output[this->bkd_p] = ntg::min(morpho::max(this->output.unbox(), - this->bkd_p, - this->se_minus), - this->input2[this->bkd_p].value()); - } - - void fifo_loop_body_impl() - { - if ((this->output[this->q] < this->output[this->p]) && - (this->input2[this->q] != this->output[this->q])) - { - this->output[this->q] = ntg::min(this->output[this->p].value(), - this->input2[this->q].value()); - this->fifo.push(this->q); - } - } - - bool exist_init_impl() - { - return this->output.hold(this->q) && - (this->output[this->q] < this->output[this->bkd_p]) && - (this->output[this->q] < this->input2[this->q]); - } - - void preconditions_impl() - { - precondition(level::is_greater_or_equal(this->input2, this->input1)); - } - - }; - - - - template <typename I, typename N> - struct reconstruction_erosion_ret : - public reconstruction_hybrid_ret<I, N, reconstruction_erosion_ret<I, N> > - { - typedef reconstruction_hybrid_ret<I, N, reconstruction_erosion_ret<I, N> > super_type; - - reconstruction_erosion_ret(const abstract::image& input1, //marker - const abstract::image& input2, //mask - const abstract::neighborhood<N>& nbh) - - : super_type(input1, input2, nbh) - {} - - void fwd_loop_body_impl() - { - this->output[this->fwd_p] = ntg::max(morpho::min(this->output.unbox(), - this->fwd_p, - this->se_plus), - this->input2[this->fwd_p].value()); - } - - void bkd_loop_body_impl() - { - this->output[this->bkd_p] = ntg::max(morpho::min(this->output.unbox(), - this->bkd_p, - this->se_minus), - this->input2[this->bkd_p].value()); - } - - void fifo_loop_body_impl() - { - if ((this->output[this->q] > this->output[this->p]) && - (this->input2[this->q] != this->output[this->q])) - { - this->output[this->q] = ntg::max(this->output[this->p].value(), - this->input2[this->q].value()); - this->fifo.push(this->q); - } - } - - bool exist_init_impl() - { - return this->output.hold(this->q) && - (this->output[this->q] > this->output[this->bkd_p]) && - (this->output[this->q] > this->input2[this->q]); - } - - void preconditions_impl() - { - precondition(level::is_greater_or_equal(this->input1, this->input2)); - } - - }; - - } - - template<class I, class N> - reconstruction_ret<I, N> - geodesic_reconstruction_dilation(const abstract::image & marker, - const abstract::image & mask, - const abstract::neighborhood<N>& nbh) - { - impl::reconstruction_dilation_ret<I, N> tmp(marker, mask, nbh); - tmp.run(); - return tmp; - } - - template<class I, class N> - reconstruction_ret<I, N> - geodesic_reconstruction_erosion(const abstract::image & marker, - const abstract::image & mask, - const abstract::neighborhood<N>& nbh) - { - impl::reconstruction_erosion_ret<I, N> tmp(marker, mask, nbh); - tmp.run(); - return tmp; - } - }// hybrid - - } - -} - #endif // ! OLENA_MORPHO_RECONSTRUCTION_HH Index: oln/morpho/splitse.hh --- oln/morpho/splitse.hh (revision 162) +++ oln/morpho/splitse.hh (working copy) @@ -34,6 +34,10 @@ # include <oln/core/2d/size2d.hh> # include <oln/core/3d/size3d.hh> +# include <oln/core/abstract/window.hh> +# include <oln/core/abstract/window.hh> + + namespace oln { namespace morpho { @@ -76,22 +80,21 @@ template<class W> W - get_plus_win_only(const abstract::window<W>& win) + get_plus_win_only(const W& win) // FIXME: abstract::window<W>& win) { - oln_wn_type_of(W, fwd_iter) q(win.exact()); W out; - // FIXME: too many changes: rewrite! -// for_all (q) -// { -// unsigned n; -// for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) -// if (dp.nth(n) < 0) { -// out.add(dp); -// break; -// } else if (dp.nth(n) > 0) { -// break; -// } -// } + for (unsigned i = 0; i < win.card(); ++i) + { + const oln_wn_type_of(W, dpoint)& dp = win.get_dp()[i]; + unsigned n; + for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) + if (dp.nth(n) < 0) { + out.add(dp); + break; + } else if (dp.nth(n) > 0) { + break; + } + } return out; } @@ -110,26 +113,24 @@ */ template<class W> W - get_plus_win_p(const abstract::window<W>& win) + get_plus_win_p(const W& win) // abstract::window<W>& win) { - oln_wn_type_of(W, fwd_iter) q(win.exact()); W out; - - // FIXME: too many changes: rewrite! -// for_all (dp) -// { -// unsigned n; -// for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) -// if (dp.nth(n) < 0) { -// out.add(dp); -// break; -// } else if (dp.nth(n) > 0) { -// break; -// } -// // All p.nth(n) are 0. -// if (n == dim_traits<oln_wn_type_of(W, size)>::dim) -// out.add(dp); -// } + for (unsigned i = 0; i < win.card(); ++i) + { + const oln_wn_type_of(W, dpoint)& dp = win.get_dp()[i]; + unsigned n; + for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) + if (dp.nth(n) < 0) { + out.add(dp); + break; + } else if (dp.nth(n) > 0) { + break; + } + // All p.nth(n) are 0. + if (n == dim_traits<oln_wn_type_of(W, size)>::dim) + out.add(dp); + } return out; } @@ -147,23 +148,21 @@ */ template<class W> W - get_minus_win_only(const abstract::window<W>& win) + get_minus_win_only(const W& win) // abstract::window<W>& win) { - oln_wn_type_of(W, fwd_iter) q(win.exact()); W out; - - // FIXME: too many changes: rewrite! -// for_all (dp) -// { -// unsigned n; -// for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) -// if (dp.nth(n) > 0) { -// out.add(dp); -// break; -// } else if (dp.nth(n) < 0) { -// break; -// } -// } + for (unsigned i = 0; i < win.card(); ++i) + { + const oln_wn_type_of(W, dpoint)& dp = win.get_dp()[i]; + unsigned n; + for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) + if (dp.nth(n) > 0) { + out.add(dp); + break; + } else if (dp.nth(n) < 0) { + break; + } + } return out; } @@ -182,26 +181,24 @@ */ template<class W> W - get_minus_win_p(const abstract::window<W>& win) + get_minus_win_p(const W& win) // abstract::window<W>& win) { - oln_wn_type_of(W, fwd_iter) q(win.exact()); W out; - - // FIXME: too many changes: rewrite! -// for_all (dp) -// { -// unsigned n; -// for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) -// if (dp.nth(n) > 0) { -// out.add(dp); -// break; -// } else if (dp.nth(n) < 0) { -// break; -// } -// // All p.nth(n) are 0. -// if (n == dim_traits<oln_wn_type_of(W, size)>::dim) -// out.add(dp); -// } + for (unsigned i = 0; i < win.card(); ++i) + { + const oln_wn_type_of(W, dpoint)& dp = win.get_dp()[i]; + unsigned n; + for (n = 0; n < dim_traits<oln_wn_type_of(W, size)>::dim; ++n) + if (dp.nth(n) > 0) { + out.add(dp); + break; + } else if (dp.nth(n) < 0) { + break; + } + // All p.nth(n) are 0. + if (n == dim_traits<oln_wn_type_of(W, size)>::dim) + out.add(dp); + } return out; } Index: oln/morpho/reconstruction_by_erosion.inc --- oln/morpho/reconstruction_by_erosion.inc (revision 0) +++ oln/morpho/reconstruction_by_erosion.inc (revision 0) @@ -0,0 +1,141 @@ +// 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 filek 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. + +namespace oln { + + namespace morpho { + + namespace impl { + + // Sequential version + + template<typename I1, typename I2> + struct generic_reconstruction <tag::by_erosion, tag::sequential, I1, I2> + : public generic_reconstruction_canvas<I1, I2, tag::sequential, + generic_reconstruction<tag::by_erosion, tag::sequential, I1, I2> > + { + typedef generic_reconstruction<tag::by_erosion, + tag::sequential, I1,I2> self_type; + typedef generic_reconstruction_canvas<I1, I2, tag::sequential, + self_type> super_type; + + generic_reconstruction(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask) + { + } + + + void impl_bkd_loop_body() + { + this->output[this->bkd_p] = ntg::max(morpho::min(this->output, + this->bkd_p, + this->win_minus), + this->mask[this->bkd_p].value()); + } + + void impl_fwd_loop_body() + { + this->output[this->fwd_p] = ntg::max(morpho::min(this->output, + this->fwd_p, + this->win_plus), + this->mask[this->fwd_p].value()); + } + + void impl_preconditions() + { + precondition(level::is_greater_or_equal(this->marker, this->mask)); + } + + }; + + // Hybrid version + + template<typename I1, typename I2> + struct generic_reconstruction <tag::by_erosion, tag::hybrid, I1, I2> + : public generic_reconstruction_canvas<I1, I2, tag::hybrid, + generic_reconstruction<tag::by_erosion, tag::hybrid, I1, I2> > + { + typedef generic_reconstruction<tag::by_erosion, + tag::hybrid, I1,I2> self_type; + typedef generic_reconstruction_canvas<I1, I2, tag::hybrid, + self_type> super_type; + + generic_reconstruction(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask) + { + } + + + + void impl_bkd_loop_body() + { + this->output[this->bkd_p] = ntg::max(morpho::min(this->work, + this->bkd_p, + this->win_minus), + this->mask[this->bkd_p].value()); + } + + void impl_fwd_loop_body() + { + this->output[this->fwd_p] = ntg::max(morpho::min(this->work, + this->fwd_p, + this->win_plus), + this->mask[this->fwd_p].value()); + } + + void impl_fifo_loop_body() + { + if ((this->output[this->q] > this->output[this->p]) && + (this->mask[this->q] != this->output[this->q])) + { + this->output[this->q] = ntg::min(this->output[this->p].value(), + this->mask[this->q].value()); + this->fifo.push(this->q); + } + } + + bool impl_exist_init() + { + return this->output.hold(this->q) && + (this->output[this->q] > this->output[this->bkd_p]) && + (this->output[this->q] > this->mask[this->q]); + } + + void impl_preconditions() + { + precondition(level::is_greater_or_equal(this->marker, this->mask)); + } + + }; + + } + + } + +} Index: oln/morpho/reconstruction_canvas.inc --- oln/morpho/reconstruction_canvas.inc (revision 0) +++ oln/morpho/reconstruction_canvas.inc (revision 0) @@ -0,0 +1,238 @@ +// 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 filek 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. + + +namespace oln { + + namespace morpho { + + namespace impl { + + template <typename I1, typename I2, typename A, typename E> + struct generic_reconstruction_canvas; + + template <typename I1, typename I2, typename E> + struct generic_reconstruction_canvas<I1, I2, tag::sequential, E> : + public reconstruction_ret<I1, I2> + { + typedef reconstruction_ret<I1, I2> super_type; + typedef oln_type_of(I1, neighb) nbh_type; + typedef oln_type_of(I1, concrete) output_type; + + E& exact__() + { + return *(E*)(void*)(this); + } + + void bkd_loop_body() + { + this->exact__().impl_bkd_loop_body(); + } + void fwd_loop_body() + { + this->exact__().impl_fwd_loop_body(); + } + + void preconditions() + { + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + precondition(this->marker.size() == this->mask.size()); + this->exact__().impl_preconditions(); + } + + void init() + { + // no call to impl_init here because this canvas can't be generalized yet. + this->output = utils::clone(this->marker); + this->work = utils::clone(this->marker); + + win_plus = get_plus_win_p(convert::nbh_to_cse(this->marker.nbh_get())); + win_minus = get_minus_win_p(convert::nbh_to_cse(this->marker.nbh_get())); + } + + bool is_stable() + { + // same explanation as above + return level::is_equal(this->work, this->output); + } + + void impl_run() + { + this->preconditions(); + this->init(); + for (;;) + { + for_all_p (fwd_p) + this->fwd_loop_body(); + for_all_p (bkd_p) + this->bkd_loop_body(); + if (this->is_stable()) + return; + work = utils::clone(this->output); + } + } + + protected: + + generic_reconstruction_canvas(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask), + bkd_p(marker.size()), + fwd_p(marker.size()) + { + } + + + oln_type_of(I1, bkd_piter) bkd_p; + oln_type_of(I1, fwd_piter) fwd_p; + + oln_nbh_type_of(nbh_type, window) win_plus; + oln_nbh_type_of(nbh_type, window) win_minus; + + box<oln_type_of(I1, concrete)> work; + }; + + template <typename I1, typename I2, typename E> + struct generic_reconstruction_canvas<I1, I2, tag::hybrid, E> : + public reconstruction_ret<I1, I2> + { + typedef reconstruction_ret<I1, I2> super_type; + typedef oln_type_of(I1, neighb) nbh_type; + typedef oln_nbh_type_of(nbh_type, window) window_type; + typedef oln_type_of(I1, concrete) output_type; + + E& exact__() + { + return *(E*)(void*)(this); + } + + + bool exist_init() + { + for (unsigned i = 0; i < win_minus.card(); ++i) + { + q = win_minus.get_dp()[i] + (oln_type_of(I1, point))bkd_p; + if (this->exact__().impl_exist_init()) + return true; + } + return false; + } + + void bkd_loop_body() + { + this->exact__().impl_bkd_loop_body(); + } + void fwd_loop_body() + { + this->exact__().impl_fwd_loop_body(); + } + + void fifo_loop_body() + { + this->exact__().impl_fifo_loop_body(); + } + + void preconditions() + { + mlc::eq<oln_type_of(I1, grid), oln_type_of(I2, grid)>::ensure(); + precondition(this->marker.size() == this->mask.size()); + this->exact__().impl_preconditions(); + } + + void init() + { + output_type tmp(this->marker.size()); + + this->output = tmp; + this->work = utils::clone(this->marker); + + win_plus = get_plus_win_p(convert::nbh_to_cse(this->marker.nbh_get())); + win_minus = get_minus_win_p(convert::nbh_to_cse(this->marker.nbh_get())); + } + + void impl_run() + { + this->preconditions(); + this->init(); + + for_all_p (fwd_p) + this->fwd_loop_body(); + + for_all_p (bkd_p) + { + bkd_loop_body(); + if (exist_init()) + fifo.push(bkd_p); + } + // Propagation Step + while (!fifo.empty()) + { + p = fifo.front(); + fifo.pop(); + + window_type win = convert::nbh_to_se(this->marker.nbh_get()); + for (unsigned i = 0; i < win.card(); ++i) + { + q = win.get_dp()[i] + p; + + if (this->output.hold(q)) + fifo_loop_body(); + } + } + } + + protected: + + generic_reconstruction_canvas(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask), + bkd_p(marker.size()), + fwd_p(marker.size()) + { + } + + + oln_type_of(I1, bkd_piter) bkd_p; + oln_type_of(I1, fwd_piter) fwd_p; + + oln_type_of(I1, point) p; + oln_type_of(I1, point) q; + + window_type win_plus; + window_type win_minus; + + box<oln_type_of(I1, concrete)> work; + + std::queue<oln_type_of(I1, point) > fifo; + + }; + + } // end of namespace impl + + } // end of namespace morpho + +} // end of namespace oln Index: oln/morpho/reconstruction_by_dilation.inc --- oln/morpho/reconstruction_by_dilation.inc (revision 0) +++ oln/morpho/reconstruction_by_dilation.inc (revision 0) @@ -0,0 +1,142 @@ +// 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 filek 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. + +namespace oln { + + namespace morpho { + + namespace impl { + + // Sequential version + + template<typename I1, typename I2> + struct generic_reconstruction <tag::by_dilation, tag::sequential, I1, I2> + : public generic_reconstruction_canvas<I1, I2, tag::sequential, + generic_reconstruction<tag::by_dilation, tag::sequential, I1, I2> > + { + typedef generic_reconstruction<tag::by_dilation, + tag::sequential, I1,I2> self_type; + typedef generic_reconstruction_canvas<I1, I2, tag::sequential, + self_type> super_type; + + generic_reconstruction(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask) + { + } + + + void impl_bkd_loop_body() + { + this->output[this->bkd_p] = ntg::min(morpho::max(this->output, + this->bkd_p, + this->win_minus), + this->mask[this->bkd_p].value()); + } + + void impl_fwd_loop_body() + { + this->output[this->fwd_p] = ntg::min(morpho::max(this->output, + this->fwd_p, + this->win_plus), + this->mask[this->fwd_p].value()); + } + + void impl_preconditions() + { + precondition(level::is_greater_or_equal(this->mask, this->marker)); + } + + }; + + + // Hybrid version + + template<typename I1, typename I2> + struct generic_reconstruction <tag::by_dilation, tag::hybrid, I1, I2> + : public generic_reconstruction_canvas<I1, I2, tag::hybrid, + generic_reconstruction<tag::by_dilation, tag::hybrid, I1, I2> > + { + typedef generic_reconstruction<tag::by_dilation, + tag::hybrid, I1,I2> self_type; + typedef generic_reconstruction_canvas<I1, I2, tag::hybrid, + self_type> super_type; + + generic_reconstruction(const abstract::image_with_nbh<I1>& marker, + const abstract::image<I2>& mask) : + super_type(marker, mask) + { + } + + + + void impl_bkd_loop_body() + { + this->output[this->bkd_p] = ntg::min(morpho::max(this->work, + this->bkd_p, + this->win_minus), + this->mask[this->bkd_p].value()); + } + + void impl_fwd_loop_body() + { + this->output[this->fwd_p] = ntg::min(morpho::max(this->work, + this->fwd_p, + this->win_plus), + this->mask[this->fwd_p].value()); + } + + void impl_fifo_loop_body() + { + if ((this->output[this->q] < this->output[this->p]) && + (this->mask[this->q] != this->output[this->q])) + { + this->output[this->q] = ntg::min(this->output[this->p].value(), + this->mask[this->q].value()); + this->fifo.push(this->q); + } + } + + bool impl_exist_init() + { + return this->output.hold(this->q) && + (this->output[this->q] < this->output[this->bkd_p]) && + (this->output[this->q] < this->mask[this->q]); + } + + void impl_preconditions() + { + precondition(level::is_greater_or_equal(this->mask, this->marker)); + } + + }; + + } + + } + +} Index: img/marker.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/marker.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/mask.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/mask.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream

1 1

proto-1.0 162: Add invert
by Damien Thivolle 16 Apr '05

16 Apr '05

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/utils/tests/invert: New. * oln/funobj/invert.hh: Invert functor. * oln/core/abstract/image_by_delegation.hh (image): Add missing method. * oln/core/box.hh: Comment code that prevents from compiling with g++-3.4. * oln/core/pw/image.hh: Likewise. * oln/utils/invert.hh: Inverted images implentation. * oln/morpho/erosion.hh: Add a forward declaration to allow compilation with g++-3.4. oln/core/abstract/image_by_delegation.hh | 2 oln/core/box.hh | 6 + oln/core/pw/image.hh | 28 ++++---- oln/funobj/invert.hh | 82 ++++++++++++++++++++++++ oln/morpho/erosion.hh | 26 ++++--- oln/utils/invert.hh | 103 +++++++++++++++++++++++++++++++ tests/utils/tests/invert | 38 +++++++++++ 7 files changed, 258 insertions, 27 deletions Index: tests/utils/tests/invert --- tests/utils/tests/invert (revision 0) +++ tests/utils/tests/invert (revision 0) @@ -0,0 +1,38 @@ +#include "data.hh" + +#include <ntg/all.hh> + +#include <oln/basics2d.hh> +#include <oln/utils/invert.hh> +#include <oln/io/read_image.hh> +#include <oln/level/compare.hh> + + +bool check() +{ + oln::image2d<ntg::bin> ima_bin; + oln::image2d<ntg::int_u8> ima_int; + oln::image2d<ntg::rgb_8> ima_rgb; + + ima_bin = oln::io::read(rdata("16x16.pbm")); + ima_int = oln::io::read(rdata("16x16.pgm")); + ima_rgb = oln::io::read(rdata("16x16.ppm")); + + if (oln::level::is_equal(ima_bin, + oln::utils::invert(oln::utils::invert(ima_bin))) && + oln::level::is_equal(ima_int, + oln::utils::invert(oln::utils::invert(ima_int))) && + oln::level::is_equal(ima_rgb, + oln::utils::invert(oln::utils::invert(ima_rgb)))) + { + std::cout << "OK" << std::endl; + return false; + } + else + { + std::cout << "FAIL" << std::endl; + return true; + } +} + + Index: oln/funobj/invert.hh --- oln/funobj/invert.hh (revision 0) +++ oln/funobj/invert.hh (revision 0) @@ -0,0 +1,82 @@ +// 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_FUNOBJ_INVERT_HH +# define OLENA_FUNOBJ_INVERT_HH + +# include <mlc/contract.hh> + +# include <ntg/all.hh> + +namespace oln { + + namespace funobj { + + struct invert + { + template <typename V> + V operator()(const ntg::vect_value<V>& v) const + { + V ret; + + for (unsigned i = 0; i < ntg_nb_comp(V); i++) + ret[i] = ntg_max_val(ntg_comp_type(V)) - v[i]; + return ret; + } + + template <typename V> + V operator()(const ntg::real_value<V>& v) const + { + V ret; + + ret = ntg_max_val(V) - v; + return ret; + } + + template <typename V> + V operator()(const ntg::enum_value<V>& v) const + { + V ret; + ntg_integer_type(V) max_val = ntg_max_val(V); + ntg_integer_type(V) value = v.exact(); + + ret = max_val - value; + return ret; + } + + invert() {} + + }; + + } // end of namespace funobj + +} // end of namespace oln + + +#endif // ! OLENA_FUNOBJ_INVERT_HH + + Index: oln/core/abstract/image_by_delegation.hh --- oln/core/abstract/image_by_delegation.hh (revision 161) +++ oln/core/abstract/image_by_delegation.hh (working copy) @@ -96,6 +96,7 @@ public: + I& image() { return this->image_.unbox(); } I& impl_delegate() { return this->image_.unbox(); } const I& impl_delegate() const { return this->image_.unbox(); } }; @@ -128,6 +129,7 @@ public: + const I& image() const { return this->image_.unbox(); } const I& impl_delegate() const { return this->image_.unbox(); } }; Index: oln/core/box.hh --- oln/core/box.hh (revision 161) +++ oln/core/box.hh (working copy) @@ -1,3 +1,4 @@ + // Copyright (C) 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free @@ -130,7 +131,8 @@ template <typename II> void operator=(const abstract::image<II>& rhs) { - mlc::false_type::ensure(); + // FIXME: Does not work with g++-3.4. +// mlc::false_type::ensure(); } // FIXME: add versions for I2 (neq I) to produce explicit errors @@ -218,7 +220,7 @@ return *this; } - /// Delegation relies on a constant image. + /// Delegation relies on a constant image. const I& impl_delegate() const { return this->image_; Index: oln/core/pw/image.hh --- oln/core/pw/image.hh (revision 161) +++ oln/core/pw/image.hh (working copy) @@ -46,7 +46,7 @@ // fwd decl namespace pw { template <typename I> struct image; - } + } // super type template <typename I> @@ -192,7 +192,7 @@ void impl_resize_border(size_t new_border, bool copy_border) const { } - + }; @@ -256,22 +256,22 @@ - + // FIXME: Does not work with g++-3.4. /// Specialization of image_for_all_p that gives a compile-time error. - template <typename I> - void image_for_all_p(const abstract::image&) - { - struct OLENA_ERROR__arg_of__image_for_all_p__should_not_be_an_image(); - } +// template <typename I> +// void image_for_all_p(const abstract::image&) +// { +// struct OLENA_ERROR__arg_of__image_for_all_p__should_not_be_an_image(); +// } - /// Specialization of image_for_all_p that gives a compile-time error. +// /// Specialization of image_for_all_p that gives a compile-time error. - template <typename P> - void image_for_all_p(const abstract::point&) - { - struct OLENA_ERROR__arg_of__image_for_all_p__should_not_be_a_point(); - } +// template <typename P> +// void image_for_all_p(const abstract::point&) +// { +// struct OLENA_ERROR__arg_of__image_for_all_p__should_not_be_a_point(); +// } Index: oln/utils/invert.hh --- oln/utils/invert.hh (revision 0) +++ oln/utils/invert.hh (revision 0) @@ -0,0 +1,103 @@ +// 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_UTILS_INVERT_HH +# define OLENA_CORE_UTILS_INVERT_HH + +# include <oln/core/abstract/image_by_delegation.hh> +# include <oln/funobj/invert.hh> + +namespace oln { + + namespace utils { + template <typename I> struct image_inverted; + } + + // super type + + template <typename I> + struct set_super_type < utils::image_inverted > + { typedef abstract::image_by_delegation<const I, utils::image_inverted > ret; }; + + // props + + template <typename I> + struct set_props < category::image, utils::image_inverted > + { + typedef oln_type_of(I, concrete) concrete_type; + }; + + + + namespace utils { + + template <typename I> + struct image_inverted : + public abstract::image_by_delegation<const I, image_inverted > + { + typedef abstract::image_by_delegation<const I, image_inverted > super_type; + typedef oln_type_of(I, value) value_type; + typedef oln_type_of(I, point) point_type; + + public: + + image_inverted() + { + } + + image_inverted(const abstract::image& image) : + super_type(image) + { + } + + I& real() const + { + return this->image_.unbox(); + } + + const value_type impl_get(const point_type& p) const + { + const static oln::funobj::invert& obj = oln::funobj::invert(); + return obj(this->image_[p].value()); + } + + }; + + template <typename I> + image_inverted invert(const abstract::image& input) + { + image_inverted tmp(input); + return tmp; + } + + } // end of namespace utils + +} // end of namespace oln + +#endif // ! OLENA_CORE_UTILS_INVERT_HH + Index: oln/morpho/erosion.hh --- oln/morpho/erosion.hh (revision 161) +++ oln/morpho/erosion.hh (working copy) @@ -45,6 +45,10 @@ namespace morpho { template <typename I> struct erosion_ret; + + template<typename I, typename W> + erosion_ret erosion(const abstract::image& input, + const abstract::window<W>& win); } // super_type @@ -126,13 +130,13 @@ void impl_run() { - oln_type_of(super_type, output) tmp(input.size()); // FIXME: trick - output = tmp; + oln_type_of(super_type, output) tmp(this->input.size()); // FIXME: trick + this->output = tmp; // FIXME: output.resize(input.size); - oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, fwd_piter) p(this->input.size()); for_all_p (p) - output[p] = morpho::min(input, p, win); + this->output[p] = morpho::min(this->input, p, this->win); } }; @@ -146,10 +150,10 @@ tmp.run(); return tmp; } - + /// Rectangle2d implementation of erosion (type). template <typename I> @@ -171,11 +175,11 @@ box<oln_type_of(super_type, output)> temp; // FIXME: box? // FIXME: output_type temp; - win_hline2d hline(win.width); - win_vline2d vline(win.height); - - temp = morpho::erosion(input, hline); - output = morpho::erosion(temp, vline); + win_hline2d hline(this->win.width); + win_vline2d vline(this->win.height); + + temp = oln::morpho::erosion(this->input, hline); + this->output = oln::morpho::erosion(temp, vline); } }; @@ -190,9 +194,9 @@ return tmp; } - + } // end of namespace oln::morpho::impl

1 0

proto-1.0 161: tests/morpho/tests/elementary_dilation: Typo
by Roland Levillain 15 Apr '05

15 Apr '05

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 4 ++++ tests/morpho/tests/elementary_dilation | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * tests/morpho/tests/elementary_dilation: Typo. 2005-04-15 Roland Levillain <roland(a)lrde.epita.fr> Index: olena/tests/morpho/tests/elementary_dilation --- olena/tests/morpho/tests/elementary_dilation (revision 160) +++ olena/tests/morpho/tests/elementary_dilation (working copy) @@ -21,7 +21,7 @@ im_type ima; ima = oln::io::read(rdata("16x16.pbm")); - if (oln::utils::md5(oln::morpho::elementary_erosiont(ima) != key) + if (oln::utils::md5(oln::morpho::elementary_dilation(ima) != key) return true; return false;

1 0

proto-1.0 160: Add tests for elementary dilation/erosion
by Roland Levillain 15 Apr '05

15 Apr '05

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 7 +++++++ tests/morpho/tests/elementary_dilation | 28 ++++++++++++++++++++++++++++ tests/morpho/tests/elementary_erosion | 28 ++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add tests for elementary dilation/erosion. * tests/morpho/tests/elementary_dilation, * tests/morpho/tests/elementary_erosion: New tests. 2005-04-15 Roland Levillain <roland(a)lrde.epita.fr> Index: olena/tests/morpho/tests/elementary_erosion --- olena/tests/morpho/tests/elementary_erosion (revision 0) +++ olena/tests/morpho/tests/elementary_erosion (revision 0) @@ -0,0 +1,28 @@ + // -*- C++ -*- +#include "data.hh" +#include <oln/utils/md5.hh> + +#include <oln/io/read_image.hh> +#include <oln/basics2d.hh> +#include <oln/morpho/elementary_erosion.hh> +#include <oln/level/compare.hh> +#include <ntg/all.hh> + +bool check() +{ + // MD5 sum of object.pbm's elementary erosion result. + // FIXME: Replace this fake with the actual result. + oln::utils::key::value_type data_key[16] = + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + oln::utils::key key(data_key); + + typedef oln::image2d<ntg::bin> im_type; + im_type ima; + ima = oln::io::read(rdata("16x16.pbm")); + + if (oln::utils::md5(oln::morpho::elementary_erosion(ima) != key) + return true; + + return false; +} Index: olena/tests/morpho/tests/elementary_dilation --- olena/tests/morpho/tests/elementary_dilation (revision 0) +++ olena/tests/morpho/tests/elementary_dilation (revision 0) @@ -0,0 +1,28 @@ + // -*- C++ -*- +#include "data.hh" +#include <oln/utils/md5.hh> + +#include <oln/io/read_image.hh> +#include <oln/basics2d.hh> +#include <oln/morpho/elementary_dilation.hh> +#include <oln/level/compare.hh> +#include <ntg/all.hh> + +bool check() +{ + // MD5 sum of object.pbm's elementary dilation result. + // FIXME: Replace this fake with the actual result. + oln::utils::key::value_type data_key[16] = + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + oln::utils::key key(data_key); + + typedef oln::image2d<ntg::bin> im_type; + im_type ima; + ima = oln::io::read(rdata("16x16.pbm")); + + if (oln::utils::md5(oln::morpho::elementary_erosiont(ima) != key) + return true; + + return false; +}

1 0