Olena-patches April 2007

olena-patches@lrde.epita.fr

7 participants
47 discussions

932: Fix pnm.hh : image loading (pbm, pgm ...).

by Ugo Jardonnet

Enjoy!! Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Fix pnm.hh : image loading (pbm, pgm ...). * oln/morpho/reconstruction.hh: Up. * oln/io/pnm.hh: Fixed. io/pnm.hh | 50 +++++++++++++++++++++++------------------------ morpho/reconstruction.hh | 14 ++++++------- 2 files changed, 32 insertions(+), 32 deletions(-) Index: oln/morpho/reconstruction.hh --- oln/morpho/reconstruction.hh (revision 931) +++ oln/morpho/reconstruction.hh (working copy) @@ -41,7 +41,7 @@ template <typename I , typename J> void - reconstruction(const Mutable_Image& marker, + reconstruction(const Image_with_Nbh& marker, const Binary_Image<J>& mask); # ifndef OLN_INCLUDE_ONLY @@ -51,8 +51,8 @@ template <typename I> bool - stability(const Image_with_Nbh& marker, - const Image_with_Nbh& tmp) + stability(Image_with_Nbh& marker, + I& tmp) { oln_piter(I) p(marker.points()); for_all(p) // FIXME : Concept doesn't own .image()? add != is better @@ -89,22 +89,22 @@ reconstruction_(const Image_with_Nbh& marker, const Binary_Image<J>& mask) { - oln_plain(I) tmp = level::clone(marker); + image2d<int> tmp = level::clone(exact(marker).image()); while ( not stability(marker, tmp) ) { - level::fill(exact(marker).image(), exact(tmp).image()); //add fill version better. + level::fill(marker, tmp); tmp = reconstruction_loop(marker, mask); } - level::fill(exact(marker).image(), exact(tmp).image()); + level::fill(marker, tmp); } } // end of namespace oln::morpho::impl template <typename I , typename J> void - reconstruction(const Mutable_Image& marker, + reconstruction(const Image_with_Nbh& marker, const Binary_Image<J>& mask) { impl::reconstruction_(exact(marker), exact(mask)); Index: oln/io/pnm.hh --- oln/io/pnm.hh (revision 931) +++ oln/io/pnm.hh (working copy) @@ -147,7 +147,7 @@ template <typename I> void load_pnm_ascii(std::ifstream& file, I& ima) { - oln_fwd_piter(I) p(ima.topo()); + oln_fwd_piter(I) p(ima.points()); for_all(p) { oln_value(I) value; @@ -163,10 +163,10 @@ template <typename I> void load_pnm_raw_2d(std::ifstream& file, I& ima) { - int col = ima.col(); - size_t len = ima.bbox().ncols(); - for (int row = ima.pmin().row(); row <= ima.pmax().row(); ++row) - file.read((char*)(ima.adr_at(row, col)), + int col = ima.max_col(); + size_t len = ima.bbox().pmax().col(); + for (int row = ima.min_row(); row <= ima.max_row(); ++row) + file.read((char*)(ima.at(row, col)), len * sizeof(oln_value(I))); } @@ -196,26 +196,26 @@ } -// image2d<unsigned char> load_pgm(const std::string& filename) -// { -// std::ifstream file(filename.c_str()); -// if (not file) -// { -// std::cerr << "error: file '" << filename -// << "' not found!"; -// abort(); -// } -// char type; -// int nrows, ncols; -// internal::read_pnm_header('2', '5', file, type, nrows, ncols); -// image2d<unsigned char> ima(nrows, ncols); -// if (type == '4') -// internal::load_pnm_raw_2d(file, ima); -// else -// // type == '1' -// internal::load_pnm_ascii(file, ima); -// return ima; -// } + image2d<unsigned char> load_pgm(const std::string& filename) + { + std::ifstream file(filename.c_str()); + if (not file) + { + std::cerr << "error: file '" << filename + << "' not found!"; + abort(); + } + char type; + int nrows, ncols; + internal::read_pnm_header('2', '5', file, type, nrows, ncols); + image2d<unsigned char> ima(nrows, ncols); + if (type == '4') + internal::load_pnm_raw_2d(file, ima); + else + // type == '1' + internal::load_pnm_ascii(file, ima); + return ima; + } } // end of namespace oln::io

17 years, 8 months

931: Add the explicit 'inplace' mechanism.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/olena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add the explicit 'inplace' mechanism. * oln/core/internal/op_image_plus_nbh.hh: Rename as... * oln/core/internal/op_image_extended_by_nbh.hh: ...this. * oln/core/gen/inplace.hh: New. * oln/debug/fill.hh, * oln/debug/iota.hh, * oln/level/paste.hh, * oln/level/apply_inplace.hh, * oln/core/gen/safe_image.hh: Update. * oln/core/gen/op.hh (plus): Rename as... (extended_by): ...this; less ambiguous. (oln_decl_inplace_image_op): New. * oln/core/internal/op_image_such_as_fp2b.hh: Fix temp hack; precisely, replace inheritance by delegation. * oln/core/internal/image_base.hh (oln_possible_lvalue): New. (possible_lvalue_from_): New. * oln/core/gen/neighb.hh, * oln/core/internal/image_ops.hh, * oln/core/internal/op_image_restricted_to_pset.hh, * oln/draw/bresenham.hh: Update. * TODO: Update. TODO | 6 - oln/core/gen/inplace.hh | 97 +++++++++++++++++++++++ oln/core/gen/neighb.hh | 4 oln/core/gen/op.hh | 21 ++++ oln/core/gen/safe_image.hh | 25 ++++- oln/core/internal/image_base.hh | 13 +++ oln/core/internal/image_ops.hh | 36 +++++++- oln/core/internal/op_image_extended_by_nbh.hh | 26 +++--- oln/core/internal/op_image_restricted_to_pset.hh | 5 - oln/core/internal/op_image_such_as_fp2b.hh | 37 +++++++- oln/debug/fill.hh | 18 +++- oln/debug/iota.hh | 16 +++ oln/draw/bresenham.hh | 23 ++++- oln/level/apply_inplace.hh | 49 +++++++---- oln/level/paste.hh | 10 ++ 15 files changed, 319 insertions(+), 67 deletions(-) Index: TODO --- TODO (revision 930) +++ TODO (working copy) @@ -26,19 +26,13 @@ draw routines -window types such as lines, rectangles, and so on - meta-window type; for instance, ball, segment, etc. -provide "- win" for morpho::opening and morpho::closing. - const promotions for op_<L,O,R> types + result is Mutable only if the underlying type is not 'const' in image_identity.hh use 'current' -provide arith::minus et al. with explicit output type - use Generalized_Point when possible Index: oln/debug/fill.hh --- oln/debug/fill.hh (revision 930) +++ oln/debug/fill.hh (working copy) @@ -29,6 +29,7 @@ # define OLN_DEBUG_FILL_HH # include <oln/core/concept/image.hh> +# include <oln/core/gen/inplace.hh> namespace oln @@ -38,17 +39,26 @@ { template <typename I, typename V> - void fill(Mutable_Image& input, const V values[]); + void fill(Mutable_Image& in_out, const V values[]); + + template <typename I, typename V> + void fill(inplace_ in_out, const V values[]); # ifndef OLN_INCLUDE_ONLY template <typename I> - void fill(Mutable_Image& input, const oln_value(I)& value) + void fill(Mutable_Image& in_out, const oln_value(I)& value) { - oln_piter(I) p(input.points()); + oln_piter(I) p(in_out.points()); for_all(p) - input(p) = value; + in_out(p) = value; + } + + template <typename I, typename V> + void fill(inplace_ in_out, const V values[]) + { + fill(in_out.unwrap(), values); } # endif // ! OLN_INCLUDE_ONLY Index: oln/debug/iota.hh --- oln/debug/iota.hh (revision 930) +++ oln/debug/iota.hh (working copy) @@ -29,6 +29,7 @@ # define OLN_DEBUG_IOTA_HH # include <oln/core/concept/image.hh> +# include <oln/core/gen/inplace.hh> namespace oln @@ -37,6 +38,14 @@ namespace debug { + template <typename I> + void iota(Mutable_Image& in_out); + + template <typename I> + void iota(inplace_ in_out); + + +# ifndef OLN_INCLUDE_ONLY template <typename I> void iota(Mutable_Image& in_out) @@ -47,6 +56,13 @@ in_out(p) = v++; } + template <typename I> + void iota(inplace_ in_out) + { + iota(in_out.unwrap()); + } + +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln::debug Index: oln/core/gen/neighb.hh --- oln/core/gen/neighb.hh (revision 930) +++ oln/core/gen/neighb.hh (working copy) @@ -31,7 +31,7 @@ # include <oln/core/internal/dpoints_impl.hh> # include <oln/core/internal/neighborhood_base.hh> -# include <oln/core/internal/op_image_plus_nbh.hh> +# include <oln/core/internal/op_image_extended_by_nbh.hh> namespace oln @@ -39,7 +39,7 @@ // Op. - oln_decl_op_plus(Image, Neighborhood); + oln_decl_op_extended_by(Image, Neighborhood); Index: oln/core/gen/inplace.hh --- oln/core/gen/inplace.hh (revision 0) +++ oln/core/gen/inplace.hh (revision 0) @@ -0,0 +1,97 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_GEN_INPLACE_HH +# define OLN_CORE_GEN_INPLACE_HH + +# include <oln/core/concept/image.hh> + + +namespace oln +{ + + + template <typename I> + class inplace_ : private mlc::assert_< mlc_is_a(I, Mutable_Image) > + { + typedef inplace_ current; + public: + + inplace_(I& ima); + + I& unwrap() const; // explicit + operator I() const; // implicit + + private: + I ima_; + }; + + + + template <typename I> + inplace_ + inplace(const Mutable_Image& ima); + + + +# ifndef OLN_INCLUDE_ONLY + + template <typename I> + inplace_::inplace_(I& ima) + : ima_(ima) + { + } + + template <typename I> + I& + inplace_::unwrap() const + { + current* this_ = const_cast<current*>(this); + return this_->ima_; + } + + template <typename I> + inplace_::operator I() const + { + return this->unwrap(); + } + + template <typename I> + inplace_ + inplace(const Mutable_Image& ima) + { + I& ima_ = const_cast<I&>(exact(ima)); + inplace_ tmp(ima_); + return tmp; + } + +# endif // ! OLN_INCLUDE_ONLY + +} // end of namespace oln + + +#endif // ! OLN_CORE_GEN_INPLACE_HH Index: oln/core/gen/op.hh --- oln/core/gen/op.hh (revision 930) +++ oln/core/gen/op.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/internal/category_of.hh> # include <oln/core/concept/function.hh> # include <oln/core/concept/value.hh> +# include <oln/core/gen/inplace.hh> @@ -74,7 +75,23 @@ struct e_n_d___w_i_t_h___a___s_e_m_i___c_o_l_u_m_n -# define oln_decl_op_plus(Lconcept, Rconcept) oln_decl_op_( plus, Lconcept, +, Rconcept) + +# define oln_decl_inplace_image_op(OpName, OpSym, Rconcept) \ + \ + template <typename L, typename R> \ + inplace_< op_<L, OpName, R> > \ + operator OpSym (inplace_<L> lhs, Rconcept<R>& rhs) \ + { \ + mlc::assert_< mlc_is_a(L, Mutable_Image) >::check(); \ + op_<L, OpName, R> tmp(exact(lhs), exact(rhs)); \ + return inplace(tmp); \ + } \ + \ + struct e_n_d___w_i_t_h___a___s_e_m_i___c_o_l_u_m_n + + + +# define oln_decl_op_extended_by(Lconcept, Rconcept) oln_decl_op_( extended_by, Lconcept, +, Rconcept) # define oln_decl_op_such_as(Lconcept, Rconcept) oln_decl_op_( such_as, Lconcept, |, Rconcept) # define oln_decl_op_restricted_to(Lconcept, Rconcept) oln_decl_op_( restricted_to, Lconcept, |, Rconcept) # define oln_decl_op_over(Lconcept, Rconcept) oln_decl_op_( over, Lconcept, /, Rconcept) @@ -89,7 +106,7 @@ /// \{ /// Operator Names. - struct plus; + struct extended_by; struct such_as; struct restricted_to; struct over; Index: oln/core/gen/safe_image.hh --- oln/core/gen/safe_image.hh (revision 930) +++ oln/core/gen/safe_image.hh (working copy) @@ -30,6 +30,7 @@ # include <oln/core/internal/image_base.hh> # include <oln/core/gen/infty_pset.hh> +# include <oln/core/gen/inplace.hh> namespace oln @@ -100,11 +101,10 @@ template <typename I> - safe_image safe(Mutable_Image& ima) - { - safe_image tmp(ima); - return tmp; - } + safe_image safe(Mutable_Image& ima); + + template <typename I> + inplace_< safe_image > safe(inplace_ ima); @@ -192,6 +192,21 @@ return this->data_->value; } + template <typename I> + safe_image safe(Mutable_Image& ima) + { + safe_image tmp(ima); + return tmp; + } + + template <typename I> + inplace_< safe_image > safe(inplace_ ima) + { + safe_image tmp_ = safe(ima.unwrap()); + inplace_< safe_image > tmp(tmp_); + return tmp; + } + # endif // ! OLN_INCLUDE_ONLY } // end of namespace oln Index: oln/core/internal/op_image_such_as_fp2b.hh --- oln/core/internal/op_image_such_as_fp2b.hh (revision 930) +++ oln/core/internal/op_image_such_as_fp2b.hh (working copy) @@ -48,8 +48,7 @@ template <typename I, typename F> struct super_trait_< internal::current > { - typedef op_< const oln_pset(I), such_as, F > S; - typedef internal::special_op_< stc::is<Image>, I, restricted_to, stc::is<Point_Set>, const S > ret; + typedef internal::image_extension_< op_<I, such_as, F> > ret; }; @@ -61,6 +60,15 @@ template <typename I, typename F> struct vtypes< internal::current > { + typedef op_< const oln_pset(I), such_as, F > S__; + typedef op_< I, restricted_to, const S__ > delegatee; + + typedef internal::singleton<delegatee> data; + + typedef oln_point(I) point; + typedef oln_possible_lvalue(I) lvalue; + typedef op_<oln_plain(I), such_as, F> plain; + typedef op_<pl::rec, such_as, F> skeleton; }; @@ -74,8 +82,11 @@ { public: - stc_using(point); - stc_using(box); + stc_using(delegatee); + stc_using(data); + + delegatee& impl_image(); + const delegatee& impl_image() const; protected: special_op_(); @@ -92,8 +103,24 @@ template <typename I, typename F> current::special_op_(I& ima, F& f) - : super(ima, (ima.points() | f)) { + this->data_ = new data( ima | (ima.points() | f) ); + } + + template <typename I, typename F> + typename current::delegatee& + current::impl_image() + { + assert(this->has_data()); + return this->data_->value; + } + + template <typename I, typename F> + const typename current::delegatee& + current::impl_image() const + { + assert(this->has_data()); + return this->data_->value; } # endif // ! OLN_INCLUDE_ONLY Index: oln/core/internal/image_ops.hh --- oln/core/internal/image_ops.hh (revision 930) +++ oln/core/internal/image_ops.hh (working copy) @@ -32,21 +32,25 @@ # include <oln/core/internal/op_image_restricted_to_pset.hh> # include <oln/core/internal/op_image_such_as_fp2b.hh> # include <oln/core/internal/op_fp2v_over_pset.hh> +# include <oln/core/gen/literal.hh> namespace oln { + // FIXME: when L is Image the "non-const" version should feature Mutable_Image + // Image | Point_Set ( ima restricted_to pset ) oln_decl_op_restricted_to(Image, Point_Set); - + oln_decl_inplace_image_op(restricted_to, |, Point_Set); // Image | Function_p2b ( ima such_as "f : p -> b" // is ima restricted_to (ima.points such_as f) ) oln_decl_op_such_as(Image, Function_p2b); + oln_decl_inplace_image_op(such_as, |, Function_p2b); @@ -70,7 +74,16 @@ return tmp; } - // FIXME: Add "literal / point set"... + // Specialisation "literal T over Point_Set". + + template <typename V, typename S> + op_<const lit_p2v_<oln_point(S), V>, over, const S> + operator / (const literal_<V>& value, const Point_Set<S>& pts) + { + lit_p2v_<oln_point(S), V> lit(value); + op_<const lit_p2v_<oln_point(S), V>, over, const S> tmp(lit, exact(pts)); + return tmp; + } @@ -89,7 +102,7 @@ template <typename I, typename B, typename P> op_<I, such_as, const fun_p2b_ > - operator | (Image& ima, B (*f)(P)) + operator | (Mutable_Image& ima, B (*f)(P)) { typedef oln_strip_(P) P_; mlc::assert_< mlc_is_a(P_, Point) >::check(); // FIXME: Add err msg. @@ -98,6 +111,13 @@ return tmp; } + template <typename I, typename B, typename P> + inplace_< op_<I, such_as, const fun_p2b_ > > + operator | (inplace_ ima, B (*f)(P)) + { + return inplace(ima.unwrap() | f); + } + // Specialization "Image such_as ima : P -> B". @@ -113,7 +133,7 @@ template <typename I, typename J> op_<I, such_as, const fun_p2b_< Binary_Image<J> > > - operator | (Image& ima, const Binary_Image<J>& f_ima_b) + operator | (Mutable_Image& ima, const Binary_Image<J>& f_ima_b) { precondition(f_ima_b.points() >= ima.points()); mlc::assert_equal_< oln_point(I), oln_point(J) >::check(); @@ -121,8 +141,12 @@ return tmp; } - - // FIXME: What about Mutable_Image so that "ima | something" can be left-value? + template <typename I, typename J> + inplace_< op_<I, such_as, const fun_p2b_< Binary_Image<J> > > > + operator | (inplace_ ima, const Binary_Image<J>& f_ima_b) + { + return inplace(ima.unwrap() | f_ima_b); + } } // end of namespace oln Index: oln/core/internal/op_image_restricted_to_pset.hh --- oln/core/internal/op_image_restricted_to_pset.hh (revision 930) +++ oln/core/internal/op_image_restricted_to_pset.hh (working copy) @@ -52,12 +52,11 @@ template <typename I, typename S> struct vtypes< internal::current > { - typedef op_<I, restricted_to, S> Exact; - typedef stc_type(I, point) point__; - typedef I delegatee; typedef internal::pair<I,S> data; + typedef oln_possible_lvalue(I) lvalue; + typedef S pset; typedef op_<oln_plain(I), restricted_to, S> plain; Index: oln/core/internal/image_base.hh --- oln/core/internal/image_base.hh (revision 930) +++ oln/core/internal/image_base.hh (working copy) @@ -36,6 +36,10 @@ # include <oln/core/gen/box.hh> +# define oln_possible_lvalue(I) \ + typename internal::possible_lvalue_from_::ret + + namespace oln { @@ -266,6 +270,15 @@ }; + template <typename I> + struct possible_lvalue_from_ + { + typedef typename mlc::if_< mlc_is_const(I), + stc::not_delegated, + stc_find_type(I, lvalue) >::ret ret; + }; + + /// single_image_morpher_<Exact> template <typename Exact> Index: oln/core/internal/op_image_extended_by_nbh.hh --- oln/core/internal/op_image_extended_by_nbh.hh (revision 929) +++ oln/core/internal/op_image_extended_by_nbh.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef OLN_CORE_INTERNAL_OP_IMAGE_PLUS_NBH_HH -# define OLN_CORE_INTERNAL_OP_IMAGE_PLUS_NBH_HH +#ifndef OLN_CORE_INTERNAL_OP_IMAGE_EXTENDED_BY_NBH_HH +# define OLN_CORE_INTERNAL_OP_IMAGE_EXTENDED_BY_NBH_HH # include <oln/core/concept/neighborhood.hh> # include <oln/core/internal/image_base.hh> @@ -39,7 +39,7 @@ { # define current \ - special_op_< stc::is<Image>, I, plus, stc::is<Neighborhood>, N > + special_op_< stc::is<Image>, I, extended_by, stc::is<Neighborhood>, N > // Instant value. oln_decl_instant_value(nbh); @@ -54,7 +54,7 @@ template <typename I, typename N> struct super_trait_< internal::current > { - typedef internal::image_extension_< op_<I, plus, N> > ret; + typedef internal::image_extension_< op_<I, extended_by, N> > ret; }; @@ -62,19 +62,21 @@ template <typename I, typename N> struct vtypes< internal::current > { - typedef op_<I, plus, N> Exact; + typedef op_<I, extended_by, N> Exact; typedef I delegatee; typedef internal::pair<I,N> data; typedef N nbh; + typedef oln_possible_lvalue(I) lvalue; + // FIXME: Wrong! typedef niter_has_< dpoints_fwd_piter_<oln_point(I)>, oln_pset(I) > fwd_niter; typedef niter_has_< dpoints_bkd_piter_<oln_point(I)>, oln_pset(I) > bkd_niter; - typedef op_<oln_plain(I), plus, N> plain; - typedef op_<pl::rec, plus, N> skeleton; + typedef op_<oln_plain(I), extended_by, N> plain; + typedef op_<pl::rec, extended_by, N> skeleton; }; @@ -86,10 +88,10 @@ template <typename I, typename N> class current : - public internal::image_extension_< op_<I, plus, N> >, + public internal::image_extension_< op_<I, extended_by, N> >, private mlc::assert_< mlc_is_not_a(I, Image_with_Nbh) > // FIXME: Add err msg. { - typedef internal::image_extension_< op_<I, plus, N> > super; + typedef internal::image_extension_< op_<I, extended_by, N> > super; public: stc_using(nbh); stc_using(data); @@ -202,7 +204,7 @@ bool init_(internal::current* this_, const D& dat) { precondition(not this_->has_data()); - this_->data__() = new typename op_<I, plus, N>::data; + this_->data__() = new typename op_<I, extended_by, N>::data; bool ima_ok = init(this_->data__()->first, with, dat); bool nbh_ok = init(this_->data__()->second, with, dat); postcondition(ima_ok); @@ -216,7 +218,7 @@ bool prepare(internal::current& target, with_t, const D& dat) { precondition(not target.has_data()); - target.data__() = new typename op_<I, plus, N>::data; + target.data__() = new typename op_<I, extended_by, N>::data; bool ima_ok = prepare(target.data__()->first, with, dat); bool nbh_ok = init(target.data__()->second, with, dat); postcondition(ima_ok); @@ -231,4 +233,4 @@ } // end of namespace oln -#endif // ! OLN_CORE_INTERNAL_OP_IMAGE_PLUS_NBH_HH +#endif // ! OLN_CORE_INTERNAL_OP_IMAGE_EXTENDED_BY_NBH_HH Index: oln/draw/bresenham.hh --- oln/draw/bresenham.hh (revision 930) +++ oln/draw/bresenham.hh (working copy) @@ -29,8 +29,8 @@ # define OLN_DRAW_BRESENHAM_HH # include <oln/core/concept/image.hh> +# include <oln/core/gen/inplace.hh> # include <oln/core/2d/line2d.hh> -# include <oln/core/gen/single_value_image.hh> # include <oln/level/paste.hh> @@ -48,6 +48,11 @@ const oln_point(I)& begin, const oln_point(I)& end, const oln_value(I)& value); + template <typename I> + void bresenham(inplace_ in_out, + const oln_point(I)& begin, const oln_point(I)& end, + const oln_value(I)& value); + # ifndef OLN_INCLUDE_ONLY @@ -59,15 +64,13 @@ const oln_point(I)& begin, const oln_point(I)& end, const oln_value(I)& value) { - line2d line(begin, end); - single_value_image<line2d, oln_value(I)> line_image(line, value); - level::paste(line_image, in_out); - // FIXME: Make it as simple as level::paste(line2d(begin, end) + value, in_out); + level::paste(literal(value) / line2d(begin, end), in_out); } } // end of namespace oln::draw::impl - // Facade. + + // Facades. template <typename I> void bresenham(Mutable_Image& in_out, @@ -77,6 +80,14 @@ impl::bresenham_(exact(in_out), begin, end, value); } + template <typename I> + void bresenham(inplace_ in_out, + const oln_point(I)& begin, const oln_point(I)& end, + const oln_value(I)& value) + { + bresenham(in_out.unwrap(), begin, end, value); + } + # endif // ! OLN_INCLUDE_ONLY } // end of namespace oln::draw Index: oln/level/paste.hh --- oln/level/paste.hh (revision 930) +++ oln/level/paste.hh (working copy) @@ -29,6 +29,7 @@ # define OLN_LEVEL_PASTE_HH # include <oln/core/concept/image.hh> +# include <oln/core/gen/inplace.hh> namespace oln @@ -42,6 +43,9 @@ template <typename I, typename J> void paste(const Image& data, /* in */ Mutable_Image<J>& destination); + template <typename I, typename J> + void paste(const Image& data, /* in */ inplace_<J> destination); + # ifndef OLN_INCLUDE_ONLY @@ -73,6 +77,12 @@ impl::paste_(exact(data), exact(destination)); } + template <typename I, typename J> + void paste(const Image& data, /* in */ inplace_<J> destination) + { + paste(data, destination.unwrap()); + } + # endif // ! OLN_INCLUDE_ONLY } // end of namespace oln::level Index: oln/level/apply_inplace.hh --- oln/level/apply_inplace.hh (revision 930) +++ oln/level/apply_inplace.hh (working copy) @@ -30,6 +30,7 @@ # include <oln/core/concept/image.hh> # include <oln/core/gen/fun.hh> +# include <oln/core/gen/inplace.hh> namespace oln @@ -41,12 +42,19 @@ /// Fwd decls. template <typename F, typename I> - void - apply_inplace(const Function_v2v<F>& f, Mutable_Image& input); + void apply_inplace(const Function_v2v<F>& f, Mutable_Image& in_out); template <typename R, typename A, typename I> - void - apply_inplace(R (*f)(A), Mutable_Image& input); + void apply_inplace(R (*f)(A), Mutable_Image& in_out); + + + // for images created on the fly + + template <typename F, typename I> + void apply_inplace(const Function_v2v<F>& f, inplace_ in_out); + + template <typename R, typename A, typename I> + void apply_inplace(R (*f)(A), inplace_ in_out); # ifndef OLN_INCLUDE_ONLY @@ -57,13 +65,12 @@ // Generic version. template <typename F, typename I> - void - apply_inplace_(const F& f, Mutable_Image& input) + void apply_inplace_(const F& f, Mutable_Image& in_out) { - oln_piter(I) p(input.points()); + oln_piter(I) p(in_out.points()); for_all(p) - input(p) = f(input(p)); - // FIXME: input(p) = static_cast<oln_value(I)>( f_( static_cast<oln_argument(F)>(input(p)) ) ); + in_out(p) = f(in_out(p)); + // FIXME: in_out(p) = static_cast<oln_value(I)>( f_( static_cast<oln_argument(F)>(in_out(p)) ) ); } @@ -73,20 +80,30 @@ /// Facades. template <typename F, typename I> - void - apply_inplace(const Function_v2v<F>& f, Mutable_Image& input) + void apply_inplace(const Function_v2v<F>& f, Mutable_Image& in_out) + { + impl::apply_inplace_(exact(f), exact(in_out)); + } + + template <typename R, typename A, typename I> + void apply_inplace(R (*f)(A), Mutable_Image& in_out) + { + impl::apply_inplace_(functorize_v2v(f), exact(in_out)); + } + + template <typename F, typename I> + void apply_inplace(const Function_v2v<F>& f, inplace_ in_out) { - impl::apply_inplace_(exact(f), exact(input)); + apply_inplace(f, in_out.unwrap()); } template <typename R, typename A, typename I> - void - apply_inplace(R (*f)(A), Mutable_Image& input) + void apply_inplace(R (*f)(A), inplace_ in_out) { - impl::apply_inplace_(functorize_v2v(f), exact(input)); + apply_inplace(f, in_out.unwrap()); } -# endif +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln::level

17 years, 8 months

930: Add constness check.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/metalic Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add constness check. * mlc/cmp.hh (mlc_is_const, is_const_): New. cmp.hh | 15 +++++++++++++++ 1 files changed, 15 insertions(+) Index: mlc/cmp.hh --- mlc/cmp.hh (revision 929) +++ mlc/cmp.hh (working copy) @@ -64,6 +64,8 @@ # define mlc_is_builtin(T) mlc::is_builtin_< T > # define mlc_is_not_builtin(T) mlc::is_not_builtin_< T > +# define mlc_is_const(T) mlc::is_const_< T > + /// \} @@ -216,6 +218,19 @@ /// \} + /// Check whether a type is const. + /// \{ + template <typename T> + struct is_const_ : public bexpr_<false> + { + }; + + template <typename T> + struct is_const_ <const T> : public bexpr_<true> + { + }; + /// \} + /// Check whether a type is a builtin type. /// \{

17 years, 8 months

929: Add local_sup/inf. Fix clone. Update Reconstruction.

by Ugo Jardonnet

Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Add local_sup/inf. Fix clone. Update Reconstruction. * oln/morpho/reconstruction.hh, * oln/morpho/cc_tarjan.hh: Updated. * oln/level/local_sup.hh: New. * oln/level/local_inf.hh: New. * oln/level/clone.hh: Fixed. level/clone.hh | 14 +-- level/local_inf.hh | 219 +++++++++++++++++++++++++++++++++++++++++++++++ level/local_sup.hh | 219 +++++++++++++++++++++++++++++++++++++++++++++++ morpho/cc_tarjan.hh | 10 +- morpho/reconstruction.hh | 70 +++++++++++---- 5 files changed, 507 insertions(+), 25 deletions(-) Index: oln/morpho/reconstruction.hh --- oln/morpho/reconstruction.hh (revision 928) +++ oln/morpho/reconstruction.hh (working copy) @@ -30,7 +30,8 @@ # include <oln/core/concept/image.hh> # include <oln/accumulator/max.hh> - +# include <oln/level/clone.hh> +# include <oln/level/fill.hh> namespace oln { @@ -38,36 +39,75 @@ namespace morpho { + template <typename I , typename J> + void + reconstruction(const Mutable_Image& marker, + const Binary_Image<J>& mask); + +# ifndef OLN_INCLUDE_ONLY + namespace impl { - template <typename I , typename J> - void // FIXME : slow version. - reconstruction_(const Image_with_Nbh& marker, + template <typename I> + bool + stability(const Image_with_Nbh& marker, + const Image_with_Nbh& tmp) + { + oln_piter(I) p(marker.points()); + for_all(p) // FIXME : Concept doesn't own .image()? add != is better + if (exact(marker).image()(p) != exact(tmp).image()(p)) + return false; + return true; + } + + template <typename I> + oln_plain(I) + reconstruction_loop(const Image_with_Nbh& marker, const Binary_Image& mask) { - // first - oln_fwd_piter(I) p(input.points()); - for_all(p) - marker(p) = local(max, marker, p) and mask(p); // FIXME : local_sup. + oln_plain(I) output; + prepare(output, with, marker); + accumulator::max_<oln_value(I)> max; - // second - oln_bkd_piter(I) p(input.points()); + // first pass + oln_fwd_piter(I) p(marker.points()); for_all(p) - marker(p) = local(max, marker, p) and mask(p); // FIXME : local_inf. + output(p) = local_sup(max, marker, p) and mask(p); + + // second pass + oln_bkd_piter(I) p2(marker.points()); + for_all(p2) + output(p2) = local_inf(max, marker, p2) and mask(p2); + + return output; + } + + template <typename I , typename J> + void // FIXME : Slow impl. + reconstruction_(const Image_with_Nbh& marker, + const Binary_Image<J>& mask) + { + oln_plain(I) tmp = level::clone(marker); + + while ( not stability(marker, tmp) ) + { + level::fill(exact(marker).image(), exact(tmp).image()); //add fill version better. + tmp = reconstruction_loop(marker, mask); + } + + level::fill(exact(marker).image(), exact(tmp).image()); } } // end of namespace oln::morpho::impl template <typename I , typename J> void - reconstruction(const Image_with_Nbh& marker, + reconstruction(const Mutable_Image& marker, const Binary_Image<J>& mask) { - impl::reconstruction_(exact(mask), exact(marker)); - } - + impl::reconstruction_(exact(marker), exact(mask)); } # endif // ! OLN_INCLUDE_ONLY Index: oln/morpho/cc_tarjan.hh --- oln/morpho/cc_tarjan.hh (revision 928) +++ oln/morpho/cc_tarjan.hh (working copy) @@ -29,8 +29,6 @@ # define OLN_MORPHO_CC_TARJAN_HH # include <oln/core/concept/image.hh> -# include <oln/debug/print.hh> - namespace oln { @@ -38,6 +36,12 @@ namespace morpho { + template <typename I> + oln_plain_value(I, unsigned) + cc_tarjan(const Binary_Image& input); + +# ifndef OLN_INCLUDE_ONLY + namespace impl { template <typename I> @@ -134,6 +138,8 @@ return impl::cc_tarjan_(exact(input)); } +# endif // ! OLN_INCLUDE_ONLY + } // end of namespace oln::morpho } // end of namespace oln Index: oln/level/local_sup.hh --- oln/level/local_sup.hh (revision 0) +++ oln/level/local_sup.hh (revision 0) @@ -0,0 +1,219 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may +// use this file as part of a free software library without +// restriction. Specifically, if other files instantiate templates or +// use macros or inline functions from this file, or you compile this +// file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be +// covered by the GNU General Public License. This exception does not +// however invalidate any other reasons why the executable file might +// be covered by the GNU General Public License. + +#ifndef OLN_LEVEL_LOCAL_SUP_HH +# define OLN_LEVEL_LOCAL_SUP_HH + +# include <oln/core/concept/image.hh> +# include <oln/core/concept/window.hh> +# include <oln/core/concept/accumulator.hh> +# include <oln/accumulator/or.hh> +# include <oln/accumulator/and.hh> + +namespace oln +{ + + namespace level + { + + template <typename A, typename I> + typename A::result + local_sup(const Accumulator<A>& f, const Image& input, const oln_point(I)& p); + + template <typename A, typename I, typename W> + typename A::result + local_sup(const Accumulator<A>& f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win); + + +# ifndef OLN_INCLUDE_ONLY + + namespace impl + { + + /// Neigborhood. + + // Generic version with neighborhood. + + template <typename A, typename I> + typename A::result + local_sup_(const A& f, + const Image_with_Nbh& input, + const oln_point(I)& p) + { + f.init_with(input(p)); + oln_niter(I) n(p, input); + for_all(n) + if (n > p) + f(input(n)); + return f.value(); + } + + // Optimised version for OR operator with neighborhood. + + template <typename B, typename I> + B + local_sup_(const oln::accumulator::or_& f, + const Image_with_Nbh& input, + const oln_point(I)& p) + { + f.init_with(input(p)); + if (f.value() == true) + return true; + oln_niter(I) n(p, input); + for_all(n) + if (n > p) + { + f(input(n)); // FIXME: Change to f.take(input(n))? + if (f.value() == true) + return true; + } + return f.value(); + } + + // Optimised version for AND operator with neighborhood. + + template <typename B, typename I> + B + local_sup_(const accumulator::and_ f, + const Image_with_Nbh& input, + const oln_point(I)& p) + { + f.init_with(input(p)); + oln_niter(I) n(p, input); + for_all(n) + if (n > p) + { + f(input(n)); // FIXME: Change to f.take(input(n))? + if (f.value() == false) + return false; + } + return f.value(); + } + + // FIXME: Generic version with nbh given as argument? + + + + /// On Window. + + // Generic version with window. + + template <typename A, typename I, typename W> + typename A::result + local_sup_(const A& f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + f.init_with(input(p)); + oln_qiter(W) q(p, win); + for_all(q) + if (q > p) + if (input.owns_(q)) + f(input(q)); + return f.value(); + } + + // Optimised version for OR operator with window. + + template <typename B, typename I, typename W> + B + local_sup_(const oln::accumulator::or_& f, + const Binary_Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + f.init_with(input(p)); + if (f.value() == true) + return true; + oln_qiter(W) q(p, win); + for_all(q) + if (q > p) + { + if (input.owns_(q)) + f(input(q)); + if (f.value() == true) + return true; + } + return f.value(); + } + + // Optimised version for AND operator with window. + + template <typename B, typename I, typename W> + B + local_sup_(const accumulator::and_ f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + f.init_with(input(p)); + oln_qiter(W) q(p, win); + for_all(q) + if (q > p) + { + if (input.owns_(q)) + f(input(q)); + if (f.value() == false) + return false; + } + return f.value(); + } + + } // end of namespace oln::level::impl + + + // Facades. + + template <typename A, typename I> + typename A::result + local_sup(const Accumulator<A>& f, const Image& input, const oln_point(I)& p) + { + mlc::assert_< mlc_is_a(I, Image_with_Nbh) >::check(); + return impl::local_sup_(exact(f), exact(input), p); + } + + template <typename A, typename I, typename W> + typename A::result + local_sup(const Accumulator<A>& f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + return impl::local_sup_(exact(f), exact(input), p, exact(win)); + } + +#endif // ! OLN_INCLUDE_ONLY + + } // end of namespace oln::level + +} // end of namespace oln + +#endif // ! OLN_LEVEL_LOCAL_SUP_HH Index: oln/level/local_inf.hh --- oln/level/local_inf.hh (revision 0) +++ oln/level/local_inf.hh (revision 0) @@ -0,0 +1,219 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may +// use this file as part of a free software library without +// restriction. Specifically, if other files instantiate templates or +// use macros or inline functions from this file, or you compile this +// file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be +// covered by the GNU General Public License. This exception does not +// however invalidate any other reasons why the executable file might +// be covered by the GNU General Public License. + +#ifndef OLN_LEVEL_LOCAL_INF_HH +# define OLN_LEVEL_LOCAL_INF_HH + +# include <oln/core/concept/image.hh> +# include <oln/core/concept/window.hh> +# include <oln/core/concept/accumulator.hh> +# include <oln/accumulator/or.hh> +# include <oln/accumulator/and.hh> + +namespace oln +{ + + namespace level + { + + template <typename A, typename I> + typename A::result + local_inf(const Accumulator<A>& f, const Image& input, const oln_point(I)& p); + + template <typename A, typename I, typename W> + typename A::result + local_inf(const Accumulator<A>& f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win); + + +# ifndef OLN_INCLUDE_ONLY + + namespace impl + { + + /// Neigborhood. + + // Generic version with neighborhood. + + template <typename A, typename I> + typename A::result + local_inf_(const A& f, + const Image_with_Nbh& input, + const oln_point(I)& p) + { + f.init_with(input(p)); + oln_niter(I) n(p, input); + for_all(n) + if (n < p) + f(input(n)); + return f.value(); + } + + // Optimised version for OR operator with neighborhood. + + template <typename B, typename I> + B + local_inf_(const oln::accumulator::or_& f, + const Image_with_Nbh& input, + const oln_point(I)& p) + { + f.init_with(input(p)); + if (f.value() == true) + return true; + oln_niter(I) n(p, input); + for_all(n) + if (n < p) + { + f(input(n)); // FIXME: Change to f.take(input(n))? + if (f.value() == true) + return true; + } + return f.value(); + } + + // Optimised version for AND operator with neighborhood. + + template <typename B, typename I> + B + local_inf_(const accumulator::and_ f, + const Image_with_Nbh& input, + const oln_point(I)& p) + { + f.init_with(input(p)); + oln_niter(I) n(p, input); + for_all(n) + if (n < p) + { + f(input(n)); // FIXME: Change to f.take(input(n))? + if (f.value() == false) + return false; + } + return f.value(); + } + + // FIXME: Generic version with nbh given as argument? + + + + /// On Window. + + // Generic version with window. + + template <typename A, typename I, typename W> + typename A::result + local_inf_(const A& f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + f.init_with(input(p)); + oln_qiter(W) q(p, win); + for_all(q) + if (q < p) + if (input.owns_(q)) + f(input(q)); + return f.value(); + } + + // Optimised version for OR operator with window. + + template <typename B, typename I, typename W> + B + local_inf_(const oln::accumulator::or_& f, + const Binary_Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + f.init_with(input(p)); + if (f.value() == true) + return true; + oln_qiter(W) q(p, win); + for_all(q) + if (q < p) + { + if (input.owns_(q)) + f(input(q)); + if (f.value() == true) + return true; + } + return f.value(); + } + + // Optimised version for AND operator with window. + + template <typename B, typename I, typename W> + B + local_inf_(const accumulator::and_ f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + f.init_with(input(p)); + oln_qiter(W) q(p, win); + for_all(q) + if (q < p) + { + if (input.owns_(q)) + f(input(q)); + if (f.value() == false) + return false; + } + return f.value(); + } + + } // end of namespace oln::level::impl + + + // Facades. + + template <typename A, typename I> + typename A::result + local_inf(const Accumulator<A>& f, const Image& input, const oln_point(I)& p) + { + mlc::assert_< mlc_is_a(I, Image_with_Nbh) >::check(); + return impl::local_inf_(exact(f), exact(input), p); + } + + template <typename A, typename I, typename W> + typename A::result + local_inf(const Accumulator<A>& f, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + return impl::local_inf_(exact(f), exact(input), p, exact(win)); + } + +#endif // ! OLN_INCLUDE_ONLY + + } // end of namespace oln::level + +} // end of namespace oln + +#endif // ! OLN_LEVEL_LOCAL_INF_HH Index: oln/level/clone.hh --- oln/level/clone.hh (revision 928) +++ oln/level/clone.hh (working copy) @@ -29,9 +29,7 @@ #ifndef OLN_LEVEL_CLONE_HH # define OLN_LEVEL_CLONE_HH -# include <oln/core/abstract/image.hh> -# include <oln/core/abstract/iterator.hh> - +# include <oln/core/concept/image.hh> namespace oln { @@ -41,7 +39,7 @@ /// Fwd decl. template <typename I> - oln_plain(I) clone(const abstract::image& input); + oln_plain(I) clone(const Image& input); # ifndef OLN_INCLUDE_ONLY @@ -51,10 +49,10 @@ /// Generic version. template <typename I> - oln_plain(I) clone(const abstract::image& input) + oln_plain(I) clone(const Image& input) { - oln_plain(I) output(input.topo()); - oln_piter(I) p(input.topo()); + oln_plain(I) output(input.points()); + oln_piter(I) p(input.points()); for_all(p) output(p) = input(p); return output; @@ -65,7 +63,7 @@ /// Facade. template <typename I> - oln_plain(I) clone(const abstract::image& input) + oln_plain(I) clone(const Image& input) { return impl::clone(input); }

17 years, 8 months

928: Add some 2d window types and refactor window impl hierarchy.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/olena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add some 2d window types and refactor window impl hierarchy. * oln/core/2d/vline2d.hh, * oln/core/2d/hline2d.hh, * oln/core/2d/rectangle2d.hh, * oln/core/internal/window.hh: New. * oln/core/concept/window.hh (op_unary_minus_): New. * oln/core/gen/dpoints_piter.hh: Cosmetic change. * oln/core/gen/window.hh (window_): Rename as... (gen_window): ...this and inherit from internal::window_. (fwd_qiter, bkd_qiter, take, impl_op_unary_minus_): Move to... (internal::window_): ...here. * oln/core/2d/window2d.hh (window2d): Replace window_ by gen_window. * oln/core/internal/window_base.hh (point): New. * oln/morpho/closing.hh, * oln/morpho/opening.hh: Fix. * oln/morpho/erosion.hh (erosion_on_function_): New version on rectangle2d. core/2d/hline2d.hh | 94 ++++++++++++++++++++++++++++++++++ core/2d/rectangle2d.hh | 116 +++++++++++++++++++++++++++++++++++++++++++ core/2d/vline2d.hh | 101 +++++++++++++++++++++++++++++++++++++ core/2d/window2d.hh | 27 ++++------ core/concept/window.hh | 11 +++- core/gen/dpoints_piter.hh | 2 core/gen/window.hh | 55 +++++--------------- core/internal/window.hh | 116 +++++++++++++++++++++++++++++++++++++++++++ core/internal/window_base.hh | 7 +- morpho/closing.hh | 2 morpho/erosion.hh | 23 +++++++- morpho/opening.hh | 2 12 files changed, 492 insertions(+), 64 deletions(-) Index: oln/core/concept/window.hh --- oln/core/concept/window.hh (revision 927) +++ oln/core/concept/window.hh (working copy) @@ -47,6 +47,8 @@ stc_typename(fwd_qiter); stc_typename(bkd_qiter); + Exact op_unary_minus_() const; + protected: Window(); @@ -61,7 +63,14 @@ { } -# endif + template <typename Exact> + Exact + Window<Exact>::op_unary_minus_() const + { + return exact(this)->impl_op_unary_minus_(); + } + +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln Index: oln/core/2d/vline2d.hh --- oln/core/2d/vline2d.hh (revision 0) +++ oln/core/2d/vline2d.hh (revision 0) @@ -0,0 +1,101 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_2D_VLINE2D_HH +# define OLN_CORE_2D_VLINE2D_HH + +# include <oln/core/internal/window.hh> +# include <oln/core/2d/dpoint2d.hh> + + +namespace oln +{ + + // Fwd decl. + class vline2d; + + + // Super type. + template <> + struct super_trait_< vline2d > + { + typedef internal::window_<vline2d> ret; + }; + + + // Virtual types. + template <> + struct vtypes< vline2d > + { + typedef point2d point; + }; + + + /// 2D vertical line window. + + class vline2d : public internal::window_< vline2d > + { + public: + + vline2d(unsigned half_length); + vline2d(int drow_min, int drow_max); + + private: + void init_(int drow_min, int drow_max); + void take(); // safety; w/o impl, it provides from calling super::take(dp). + + }; // end of class oln::vline2d + + + +# ifndef OLN_INCLUDE_ONLY + + vline2d::vline2d(unsigned half_length) + { + precondition(half_length > 0); + this->init_(- half_length, half_length); + } + + vline2d::vline2d(int drow_min, int drow_max) + { + precondition(drow_max > drow_min); + this->init_(drow_min, drow_max); + } + + void + vline2d::init_(int drow_min, int drow_max) + { + for (int drow = drow_min; drow <= drow_max; ++drow) + this->internal::window_<vline2d>::take(dpoint2d(drow, 0)); + } + +# endif // ! OLN_INCLUDE_ONLY + +} // end of namespace oln + + +#endif // ! OLN_CORE_2D_VLINE2D_HH Index: oln/core/2d/hline2d.hh --- oln/core/2d/hline2d.hh (revision 0) +++ oln/core/2d/hline2d.hh (revision 0) @@ -0,0 +1,94 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_2D_HLINE2D_HH +# define OLN_CORE_2D_HLINE2D_HH + +# include <oln/core/internal/window.hh> +# include <oln/core/2d/dpoint2d.hh> + + +namespace oln +{ + + // Fwd decl. + class hline2d; + + + // Super type. + template <> + struct super_trait_< hline2d > + { + typedef internal::window_<hline2d> ret; + }; + + + // Virtual types. + template <> + struct vtypes< hline2d > + { + typedef point2d point; + }; + + + /// 2D horizontal line window. + + class hline2d : public internal::window_< hline2d > + { + public: + + hline2d(unsigned half_length); + + private: + void init_(int dcol_min, int dcol_max); + void take(); // safety; w/o impl, it provides from calling super::take(dp). + + }; // end of class oln::hline2d + + + +# ifndef OLN_INCLUDE_ONLY + + hline2d::hline2d(unsigned half_length) + { + precondition(half_length > 0); + this->init_(- half_length, + half_length); + } + + void + hline2d::init_(int dcol_min, int dcol_max) + { + for (int dcol = dcol_min; dcol <= dcol_max; ++dcol) + this->internal::window_<hline2d>::take(dpoint2d(0, dcol)); + } + +# endif // ! OLN_INCLUDE_ONLY + +} // end of namespace oln + + +#endif // ! OLN_CORE_2D_HLINE2D_HH Index: oln/core/2d/rectangle2d.hh --- oln/core/2d/rectangle2d.hh (revision 0) +++ oln/core/2d/rectangle2d.hh (revision 0) @@ -0,0 +1,116 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_2D_RECTANGLE2D_HH +# define OLN_CORE_2D_RECTANGLE2D_HH + +# include <oln/core/internal/window.hh> +# include <oln/core/2d/dpoint2d.hh> + + +namespace oln +{ + + // Fwd decl. + class rectangle2d; + + + // Super type. + template <> + struct super_trait_< rectangle2d > + { + typedef internal::window_<rectangle2d> ret; + }; + + + // Virtual types. + template <> + struct vtypes< rectangle2d > + { + typedef point2d point; + }; + + + /// 2D rectangular window. + + class rectangle2d : public internal::window_< rectangle2d > + { + public: + + // FIXME: Use instant-init facilities. + rectangle2d(unsigned half_height, unsigned half_width); + + unsigned half_height() const; + unsigned half_width() const; + + private: + void init_(int drow_min, int dcol_min, + int drow_max, int dcol_max); + void take(); // safety; w/o impl, it provides from calling super::take(dp). + + unsigned half_height_, half_width_; + + }; // end of class oln::rectangle2d + + + +# ifndef OLN_INCLUDE_ONLY + + rectangle2d::rectangle2d(unsigned half_height, unsigned half_width) + { + precondition(half_height > 0 and half_width > 0 ); + this->half_height_ = half_height; + this->half_width_ = half_width; + this->init_(- half_height, - half_width, + + half_height, + half_width); + } + + unsigned rectangle2d::half_height() const + { + return this->half_height_; + } + + unsigned rectangle2d::half_width() const + { + return this->half_width_; + } + + void + rectangle2d::init_(int drow_min, int dcol_min, + int drow_max, int dcol_max) + { + for (int drow = drow_min; drow <= drow_max; ++drow) + for (int dcol = dcol_min; dcol <= dcol_max; ++dcol) + this->internal::window_<rectangle2d>::take(dpoint2d(drow, dcol)); + } + +# endif // ! OLN_INCLUDE_ONLY + +} // end of namespace oln + + +#endif // ! OLN_CORE_2D_RECTANGLE2D_HH Index: oln/core/2d/window2d.hh --- oln/core/2d/window2d.hh (revision 927) +++ oln/core/2d/window2d.hh (working copy) @@ -29,46 +29,43 @@ # define OLN_CORE_2D_WINDOW2D_HH # include <oln/core/gen/window.hh> -# include <oln/core/2d/dpoint2d.hh> +# include <oln/core/2d/rectangle2d.hh> namespace oln { // FIXME: window2d should be an actual type, not an alias... - typedef window_<dpoint2d> window2d; + typedef gen_window<dpoint2d> window2d; - window2d mk_square(unsigned odd_len); + rectangle2d mk_square(unsigned odd_len); # ifndef OLN_INCLUDE_ONLY - window2d mk_square(unsigned odd_len) + rectangle2d mk_square(unsigned odd_len) { precondition(odd_len % 2 = 1); - window2d tmp; - int half_len = odd_len / 2; - for (int drow = - half_len; drow <= half_len; ++drow) - for (int dcol = - half_len; dcol <= half_len; ++dcol) - tmp.take(dpoint2d(drow, dcol)); + unsigned half_len = odd_len / 2; + rectangle2d tmp(half_len, half_len); return tmp; } -# endif +# endif // ! OLN_INCLUDE_ONLY - extern const window2d win3x3; - extern const window2d win5x5; + extern const rectangle2d win3x3; + extern const rectangle2d win5x5; # ifndef OLN_INCLUDE_ONLY - const window2d win3x3 = mk_square(3); - const window2d win5x5 = mk_square(5); + const rectangle2d win3x3 = mk_square(3); + const rectangle2d win5x5 = mk_square(5); -# endif +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln Index: oln/core/gen/dpoints_piter.hh --- oln/core/gen/dpoints_piter.hh (revision 927) +++ oln/core/gen/dpoints_piter.hh (working copy) @@ -187,7 +187,7 @@ { } -# endif +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln Index: oln/core/gen/window.hh --- oln/core/gen/window.hh (revision 927) +++ oln/core/gen/window.hh (working copy) @@ -28,9 +28,7 @@ #ifndef OLN_CORE_GEN_WINDOW_HH # define OLN_CORE_GEN_WINDOW_HH -# include <oln/core/internal/window_base.hh> -# include <oln/core/internal/dpoints_impl.hh> -# include <oln/core/gen/dpoints_piter.hh> +# include <oln/core/internal/window.hh> namespace oln @@ -38,72 +36,47 @@ // Fwd decl. - template <typename Dp> class window_; + template <typename Dp> class gen_window; // Super type. template <typename Dp> - struct super_trait_< window_<Dp> > + struct super_trait_< gen_window<Dp> > { - typedef window_<Dp> current__; - typedef internal::window_base_<current__> ret; + typedef gen_window<Dp> current__; + typedef internal::window_<current__> ret; }; - /// Virtual types. + // Virtual types. template <typename Dp> - struct vtypes< window_<Dp> > + struct vtypes< gen_window<Dp> > { - typedef stc_type(Dp, point) point; - typedef dpoints_fwd_piter_<point> fwd_qiter; - typedef dpoints_bkd_piter_<point> bkd_qiter; + typedef oln_point(Dp) point; }; - /// Generic classical windoworhood class. + /// Generic classical window class. template <typename Dp> - class window_ : public internal::window_base_< window_<Dp> >, - public internal::dpoints_impl_<Dp> + class gen_window : public internal::window_< gen_window<Dp> > { public: - window_(); + gen_window(); - window_<Dp>& take(const Dp& dp); - - window_<Dp> impl_op_unary_minus_() const; - - }; // end of class oln::window_<Dp> + }; // end of class oln::gen_window<Dp> # ifndef OLN_INCLUDE_ONLY template <typename Dp> - window_<Dp>::window_() - { - } - - template <typename Dp> - window_<Dp>& - window_<Dp>::take(const Dp& dp) - { - this->take_( dp); - return *this; - } - - template <typename Dp> - window_<Dp> - window_<Dp>::impl_op_unary_minus_() const + gen_window<Dp>::gen_window() { - window_<Dp> tmp; - for (unsigned i = 0; i < this->size(); ++i) - tmp.take(- this->v_[i]); - return tmp; } -# endif +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln Index: oln/core/internal/window.hh --- oln/core/internal/window.hh (revision 0) +++ oln/core/internal/window.hh (revision 0) @@ -0,0 +1,116 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_INTERNAL_WINDOW_HH +# define OLN_CORE_INTERNAL_WINDOW_HH + +# include <oln/core/internal/window_base.hh> +# include <oln/core/internal/dpoints_impl.hh> +# include <oln/core/gen/dpoints_piter.hh> + + +namespace oln +{ + + + // Fwd decl. + namespace internal { template <typename Exact> class window_; } + + + // Super type. + template <typename Exact> + struct super_trait_< internal::window_<Exact> > + { + typedef internal::window_base_<Exact> ret; + }; + + + // Virtual types. + template <typename Exact> + struct vtypes< internal::window_<Exact> > + { + typedef stc_deferred(point) point__; + typedef stc::final< oln_dpoint(point__) > dpoint; + typedef stc::final< dpoints_fwd_piter_<point__> > fwd_qiter; + typedef stc::final< dpoints_bkd_piter_<point__> > bkd_qiter; + }; + + namespace internal + { + + /// Base implementation class for regular window classes. + + template <typename Exact> + class window_ : public window_base_<Exact>, + public dpoints_impl_< stc_deferred(dpoint) > + { + typedef window_base_<Exact> super; + public: + + stc_using(point); + typedef typename point::dpoint dpoint; + + window_(); + Exact& take(const dpoint& dp); + Exact impl_op_unary_minus_() const; + + }; // end of class oln::internal::window_<Exact> + + +# ifndef OLN_INCLUDE_ONLY + + template <typename Exact> + window_<Exact>::window_() + { + } + + template <typename Exact> + Exact& + window_<Exact>::take(const typename window_<Exact>::dpoint& dp) + { + this->take_( dp); + return exact(*this); + } + + template <typename Exact> + Exact + window_<Exact>::impl_op_unary_minus_() const + { + Exact tmp; + for (unsigned i = 0; i < this->size(); ++i) + tmp.take(- this->v_[i]); + return tmp; + } + + } // end of namespace oln::internal + +# endif // ! OLN_INCLUDE_ONLY + +} // end of namespace oln + + +#endif // ! OLN_CORE_INTERNAL_WINDOW_HH Index: oln/core/internal/window_base.hh --- oln/core/internal/window_base.hh (revision 927) +++ oln/core/internal/window_base.hh (working copy) @@ -66,15 +66,18 @@ namespace internal { - /// Base class for implementation of windows class. + /// Base class for implementation of window classes. template <typename Exact> class window_base_ : public Window<Exact> { + public: + stc_typename(point); + protected: window_base_(); - }; // end of class oln::window_base_<Exact> + }; // end of class oln::internal::window_base_<Exact> Index: oln/morpho/closing.hh --- oln/morpho/closing.hh (revision 927) +++ oln/morpho/closing.hh (working copy) @@ -57,7 +57,7 @@ closing_(const Image& input, const Window<W>& win) { oln_plain(I) tmp = morpho::dilation(input, win); - return morpho::erosion(tmp, win); // FIXME : inverse(win). + return morpho::erosion(tmp, - win); } // FIXME: Add a fast version. Index: oln/morpho/opening.hh --- oln/morpho/opening.hh (revision 927) +++ oln/morpho/opening.hh (working copy) @@ -57,7 +57,7 @@ opening_(const Image& input, const Window<W>& win) { oln_plain(I) ero = morpho::erosion(input, win); - return morpho::dilation(ero, win); // FIXME : inverse(win). + return morpho::dilation(ero, - win); } // FIXME: Add a fast version. Index: oln/morpho/erosion.hh --- oln/morpho/erosion.hh (revision 927) +++ oln/morpho/erosion.hh (working copy) @@ -34,6 +34,11 @@ # include <oln/accumulator/min.hh> # include <oln/accumulator/and.hh> +// FIXME: Add guard. +# include <oln/core/2d/rectangle2d.hh> +# include <oln/core/2d/hline2d.hh> +# include <oln/core/2d/vline2d.hh> + namespace oln { @@ -53,7 +58,7 @@ namespace impl { - // Generic version. + // Generic versions. template <typename I, typename W> oln_plain(I) @@ -73,7 +78,21 @@ return level::apply_local(accu_and, input, win); } - // FIXME: Add a fast version. + + // FIXME: Add guard here. + // Versions for rectangles. + + template <typename I> + oln_plain(I) + erosion_on_function_(const Image_2D& input, const rectangle2d& win) + { + hline2d hl(win.half_width()); + vline2d hv(win.half_height()); + oln_plain(I) tmp = erosion(input, hl); + return erosion(tmp, hv); + } + + // FIXME: Add other fast versions. // Impl facade.

17 years, 8 months

927: Add the type of stack of images.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/olena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add the type of stack of images. * tests/core/stack.cc, * oln/core/gen/image_stack.hh, * oln/core/internal/value_proxy.hh: New. * tests/core/Makefile.am (check_PROGRAMS): Add stack. * oln/core/concept/image.hh (inplace): New. * oln/core/equipment.hh (oln_psite): New. * oln/core/internal/instant_value.hh: Cosmetic change. * oln/stc/scoop.hh (stc_is_found_type): New. oln/core/concept/image.hh | 10 + oln/core/equipment.hh | 1 oln/core/gen/image_stack.hh | 210 +++++++++++++++++++++++++++++++++++++ oln/core/internal/instant_value.hh | 2 oln/core/internal/value_proxy.hh | 119 ++++++++++++++++++++ oln/stc/scoop.hh | 2 tests/core/Makefile.am | 2 tests/core/stack.cc | 59 ++++++++++ 8 files changed, 404 insertions(+), 1 deletion(-) Index: tests/core/stack.cc --- tests/core/stack.cc (revision 0) +++ tests/core/stack.cc (revision 0) @@ -0,0 +1,59 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/// Test stack. + +#include <cassert> +#include <oln/core/2d/image2d.hh> +#include <oln/core/gen/image_stack.hh> +#include <oln/level/fill.hh> + + +xtd::vec<2,int> coords(const oln::point2d& p) +{ + return p.vec(); +} + + +int main() +{ + using namespace oln; + + typedef image2d<int> I; + I ima_0(3, 3), ima_1(3, 3); + level::fill(stack(ima_0, ima_1).inplace(), coords); + { + I::piter p(ima_0.points()); + for_all(p) + assert(ima_0(p) = p.row()); + } + { + I::piter p(ima_1.points()); + for_all(p) + assert(ima_1(p) = p.col()); + } +} Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 926) +++ tests/core/Makefile.am (working copy) @@ -33,6 +33,7 @@ pw_value \ rle_image \ sparse_image \ + stack \ subset \ window2d @@ -50,6 +51,7 @@ pw_value_SOURCES = pw_value.cc rle_image_SOURCES = rle_image.cc sparse_image_SOURCES = sparse_image.cc +stack_SOURCES = stack.cc subset_SOURCES = subset.cc window2d_SOURCES = window2d.cc Index: oln/core/concept/image.hh --- oln/core/concept/image.hh (revision 926) +++ oln/core/concept/image.hh (working copy) @@ -191,6 +191,9 @@ lvalue operator()(const psite& p); void write_(const psite& p, const value& v); + // final. + Exact& inplace(); + protected: Mutable_Image(); }; @@ -526,6 +529,13 @@ { } + template <typename Exact> + Exact& + Mutable_Image<Exact>::inplace() + { + return exact(*this); + } + // ----------------------------------- Point_Wise_Accessible_Image<Exact> template <typename Exact> Index: oln/core/equipment.hh --- oln/core/equipment.hh (revision 926) +++ oln/core/equipment.hh (working copy) @@ -127,6 +127,7 @@ # define oln_plain(T) oln_typename_shortcut__(T, plain) # define oln_point(T) oln_typename_shortcut__(T, point) # define oln_pset(T) oln_typename_shortcut__(T, pset) +# define oln_psite(T) oln_typename_shortcut__(T, psite) // q stc_decl_associated_type( qiter ); Index: oln/core/gen/image_stack.hh --- oln/core/gen/image_stack.hh (revision 0) +++ oln/core/gen/image_stack.hh (revision 0) @@ -0,0 +1,210 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_GEN_IMAGE_STACK_HH +# define OLN_CORE_GEN_IMAGE_STACK_HH + +# include <oln/core/internal/image_base.hh> +# include <oln/core/internal/value_proxy.hh> + +# include <mlc/int.hh> +# include <xtd/vec.hh> + + +namespace oln +{ + +# define current image_stack<n_, I> + +# define super internal::multiple_image_morpher_< current > + + + // Fwd decl. + template <unsigned n_, typename I> class image_stack; + + + // Super type. + template <unsigned n_, typename I> + struct super_trait_< current > + { + typedef super ret; + }; + + + /// Virtual types. + template <unsigned n_, typename I> + struct vtypes< current > + { + typedef I delegatee; + typedef behavior::identity behavior; + + typedef internal::singleton< xtd::vec<n_,I> > data; + + typedef mlc::uint_<n_> n; + + typedef xtd::vec<n_, oln_value(I)> value; + typedef value rvalue; + + typedef typename mlc::if_< stc_is_found_type(I, lvalue), + internal::value_proxy_< current >, + stc::not_delegated >::ret lvalue; + + typedef oln_plain_value(I, value) plain; + typedef image_stack< n_, pl::rec > skeleton; + }; + + + /// Class for a stack of n images. + + template <unsigned n_, typename I> + class image_stack : public super + { + public: + + stc_using(psite); + stc_using(rvalue); + stc_using(lvalue); + stc_using(value); + stc_using(data); + stc_using(delegatee); + + image_stack(); + image_stack(const xtd::vec<n_,I>& imas); + + // FIXME: Force this type to be read-only? + rvalue impl_read(const psite& p) const; + lvalue impl_read_write(const psite& p); + void impl_write(const psite& p, const value& v); + + delegatee& impl_image(unsigned i); + const delegatee& impl_image(unsigned i) const; + + }; // end of current + + + + template <typename I> + image_stack<2,I> stack(I& ima_0, I& ima_1); + + template <typename I> + image_stack<3,I> stack(I& ima_0, I& ima_1, I& ima_2); + + +# ifndef OLN_INCLUDE_ONLY + + template <unsigned n_, typename I> + current::image_stack() + { + } + + template <unsigned n_, typename I> + current::image_stack(const xtd::vec<n_,I>& imas) + { + for (unsigned i = 0; i < n_; ++i) + precondition(imas[i].has_data()); + this->data_ = new data(imas); + } + + template <unsigned n_, typename I> + typename current::rvalue + current::impl_read(const typename current::psite& p) const + { + assert(this->has_data()); + rvalue tmp; + for (unsigned i = 0; i < n_; ++i) + tmp[i] = this->data_->value[i](p); + return tmp; + } + + template <unsigned n_, typename I> + typename current::lvalue + current::impl_read_write(const typename current::psite& p) + { + assert(this->has_data()); + lvalue tmp(*this, p); + return tmp; + } + + template <unsigned n_, typename I> + void + current::impl_write(const typename current::psite& p, + const typename current::value& v) + { + assert(this->has_data()); + for (unsigned i = 0; i < n_; ++i) + this->data_->value[i](p) = v[i]; + } + + template <unsigned n_, typename I> + typename current::delegatee& + current::impl_image(unsigned i) + { + precondition(i < n_); + assert(this->has_data()); + return this->data_->value[i]; + } + + template <unsigned n_, typename I> + const typename current::delegatee& + current::impl_image(unsigned i) const + { + precondition(i < n_); + assert(this->has_data()); + return this->data_->value[i]; + } + + template <typename I> + image_stack<2,I> stack(I& ima_0, I& ima_1) + { + xtd::vec<2,I> v; + v[0] = ima_0; + v[1] = ima_1; + image_stack<2,I> tmp(v); + return tmp; + } + + template <typename I> + image_stack<3,I> stack(I& ima_0, I& ima_1, I& ima_2) + { + xtd::vec<3,I> v; + v[0] = ima_0; + v[1] = ima_1; + v[2] = ima_2; + image_stack<3,I> tmp(v); + return tmp; + } + + +# endif // ! OLN_INCLUDE_ONLY + +# undef super +# undef current + +} // end of namespace oln + + +#endif // ! OLN_CORE_GEN_IMAGE_STACK_HH Index: oln/core/internal/value_proxy.hh --- oln/core/internal/value_proxy.hh (revision 0) +++ oln/core/internal/value_proxy.hh (revision 0) @@ -0,0 +1,119 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_INTERNAL_VALUE_PROXY_HH +# define OLN_CORE_INTERNAL_VALUE_PROXY_HH + +# include <ostream> +# include <oln/core/concept/value.hh> + + +namespace oln +{ + + namespace internal + { + + + template <typename I> + class value_proxy_ + { + public: + + // ctor + value_proxy_(I& ima, const oln_psite(I)& p); + + // assignment => write + template <typename T> + value_proxy_& operator=(const T& val); + + // conversion => read + template <typename T> + operator T() const; + + // explicit read + oln_value(I) value() const; + + private: + + I& ima_; + oln_psite(I) p_; + }; + + + template <typename I> + std::ostream& operator<<(std::ostream& ostr, const value_proxy_& v); + + +# ifndef OLN_INCLUDE_ONLY + + template <typename I> + value_proxy_::value_proxy_(I& ima, const oln_psite(I)& p) + : ima_(ima), + p_(p) + { + } + + template <typename I> + template <typename T> + value_proxy_& + value_proxy_::operator=(const T& val) + { + ima_.write_(this->p_, val); + return *this; + } + + template <typename I> + template <typename T> + value_proxy_::operator T() const + { + T tmp = this->ima_.read_(this->p_); + return tmp; + } + + template <typename I> + oln_value(I) + value_proxy_::value() const + { + oln_value(I) tmp = this->ima_.read_(this->p_); + return tmp; + } + + template <typename I> + std::ostream& operator<<(std::ostream& ostr, const value_proxy_& v) + { + return ostr << v.value(); + } + +# endif // ! OLN_INCLUDE_ONLY + + } // end of namespace oln::internal + +} // end of namespace oln + + +#endif // ! OLN_CORE_INTERNAL_VALUE_PROXY_HH Index: oln/core/internal/instant_value.hh --- oln/core/internal/instant_value.hh (revision 926) +++ oln/core/internal/instant_value.hh (working copy) @@ -93,7 +93,7 @@ } */ -# endif // OLN_INCLUDE_ONLY +# endif // ! OLN_INCLUDE_ONLY } // end of namespace oln::internal Index: oln/stc/scoop.hh --- oln/stc/scoop.hh (revision 926) +++ oln/stc/scoop.hh (working copy) @@ -118,6 +118,8 @@ # define stc_type_is_found(Type) stc::is_found< stc_deferred(Type) > # define stc_type_is_not_found(Type) stc::is_not_found< stc_deferred(Type) > +# define stc_is_found_type(From, Type) stc::is_found< stc_deferred_type(From, Type) > + # define stc_is_a(T, U) \

17 years, 8 months

926: Add plus and minus with explicit cast.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/olena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add plus and minus with explicit cast. * TODO: Extend. * oln/core/gen/pw_value.hh (image): New method. * oln/core/gen/value_cast.hh: New. * oln/arith/plus.hh (plus): New. * oln/arith/minus.hh (minus): New. * oln/morpho/elementary_gradient.hh, * oln/morpho/elementary_gradient_external.hh, * oln/morpho/elementary_laplace.hh, * oln/morpho/gradient_internal.hh, * oln/morpho/top_hat_black.hh, * oln/morpho/gradient.hh, * oln/morpho/top_hat_white.hh, * oln/morpho/closing.hh, * oln/morpho/opening.hh, * oln/morpho/gradient_external.hh, * oln/morpho/laplace.hh, * oln/morpho/elementary_gradient_internal.hh: Update. * oln/level/compare.hh: Add FIXME. TODO | 2 oln/arith/minus.hh | 32 +++++++++ oln/arith/plus.hh | 37 ++++++++++- oln/core/gen/pw_value.hh | 12 +++ oln/core/gen/value_cast.hh | 96 +++++++++++++++++++++++++++++ oln/level/compare.hh | 3 oln/morpho/elementary_gradient.hh | 2 oln/morpho/elementary_gradient_external.hh | 2 oln/morpho/elementary_gradient_internal.hh | 2 oln/morpho/elementary_laplace.hh | 10 +-- oln/morpho/gradient.hh | 2 oln/morpho/gradient_external.hh | 2 oln/morpho/gradient_internal.hh | 2 oln/morpho/laplace.hh | 7 +- oln/morpho/top_hat_black.hh | 2 oln/morpho/top_hat_white.hh | 3 16 files changed, 195 insertions(+), 21 deletions(-) Index: TODO --- TODO (revision 925) +++ TODO (working copy) @@ -30,6 +30,8 @@ meta-window type; for instance, ball, segment, etc. +provide "- win" for morpho::opening and morpho::closing. + const promotions for op_<L,O,R> types + result is Mutable only if the underlying type is not 'const' Index: oln/core/gen/pw_value.hh --- oln/core/gen/pw_value.hh (revision 925) +++ oln/core/gen/pw_value.hh (working copy) @@ -33,6 +33,7 @@ # include <oln/core/gen/fun_ops.hh> + namespace oln { @@ -43,6 +44,7 @@ } // end of namespace oln::ERROR + template <typename I> class pw_value_ : public Function_p2v< pw_value_ >, private mlc::assert_< mlc_is_a(I, Image), @@ -55,6 +57,8 @@ pw_value_(const Image& ima); oln_value(I) operator()(const oln_point(I)& p) const; + const I& image() const; + protected: const I& ima_; }; @@ -64,6 +68,7 @@ pw_value_ pw_value(const Image& ima); + # ifndef OLN_INCLUDE_ONLY template <typename I> @@ -83,6 +88,13 @@ } template <typename I> + const I& + pw_value_::image() const + { + return this->ima_; + } + + template <typename I> pw_value_ pw_value(const Image& ima) { Index: oln/core/gen/value_cast.hh --- oln/core/gen/value_cast.hh (revision 0) +++ oln/core/gen/value_cast.hh (revision 0) @@ -0,0 +1,96 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_GEN_VALUE_CAST_HH +# define OLN_CORE_GEN_VALUE_CAST_HH + +# include <oln/core/gen/fun.hh> + + +// FIXME: Separate defs and decls. + + + +namespace oln +{ + + + // ----------------------------- casted_fp2v_<F, V> + + + // Fwd decl. + template <typename F, typename V> struct casted_fp2v_; + + // Category. + namespace internal + { + template <typename F, typename V> + struct set_category_of_< casted_fp2v_<F, V> > + { + typedef stc::is< Function_p2v > ret; + }; + } + + + // Class. + template <typename F, typename V> + struct casted_fp2v_ : public Function_p2v< casted_fp2v_<F, V> > + { + typedef oln_arg_of_(F) argument; + typedef oln_res_of_(F) f_result; + typedef V result; + + casted_fp2v_(const F& f) : f_(f) {} + + result operator()(argument arg) const + { + return static_cast<V>(this->f_(arg)); + } + + private: + F f_; + }; + + + // value_cast + + template <typename V, typename F> + casted_fp2v_<F, V> value_cast(const Function_p2v<F>& f) + { + // FIXME: Check that the cast "F::result -> V" is OK. + casted_fp2v_<F, V> tmp(exact(f)); + return tmp; + } + + + // FIXME: Add casted_fv2v_<F,V>? + + +} // end of namespace oln + + +#endif // ! OLN_CORE_GEN_VALUE_CAST_HH Index: oln/morpho/elementary_gradient.hh --- oln/morpho/elementary_gradient.hh (revision 925) +++ oln/morpho/elementary_gradient.hh (working copy) @@ -59,7 +59,7 @@ { oln_plain(I) dil = elementary_dilation(input); oln_plain(I) ero = elementary_erosion(input); - return dil - ero; + return arith::minus<oln_value(I)>(dil, ero); } Index: oln/morpho/elementary_gradient_external.hh --- oln/morpho/elementary_gradient_external.hh (revision 925) +++ oln/morpho/elementary_gradient_external.hh (working copy) @@ -57,7 +57,7 @@ elementary_gradient_external_(const Image_with_Nbh& input) { oln_plain(I) dil = elementary_dilation(input); - return dil - input; + return arith::minus<oln_value(I)>(dil, input); } Index: oln/morpho/elementary_laplace.hh --- oln/morpho/elementary_laplace.hh (revision 925) +++ oln/morpho/elementary_laplace.hh (working copy) @@ -41,7 +41,7 @@ // Fwd decl. template <typename I> - oln_plain(I) + oln_minus_trait(I, I) elementary_laplace(const Image_with_Nbh& input); @@ -53,7 +53,7 @@ // Generic version. template <typename I> - oln_plain(I) + oln_minus_trait(I, I) elementary_laplace_(const Image_with_Nbh& input) { oln_plain(I) g_ext = elementary_gradient_external(input); @@ -61,18 +61,16 @@ return g_ext - g_int; } - - // FIXME: Add a fast version. - } // end of namespace oln::morpho::impl // Facade. template <typename I> - oln_plain(I) + oln_minus_trait(I, I) elementary_laplace(const Image_with_Nbh& input) { + // FIXME: Add postcondition. return impl::elementary_laplace_(exact(input)); } Index: oln/morpho/gradient_internal.hh --- oln/morpho/gradient_internal.hh (revision 925) +++ oln/morpho/gradient_internal.hh (working copy) @@ -57,7 +57,7 @@ gradient_internal_(const Image& input, const Window<W>& win) { oln_plain(I) ero = erosion(input, win); - return input - ero; + return arith::minus<oln_value(I)>(input, ero); } Index: oln/morpho/top_hat_black.hh --- oln/morpho/top_hat_black.hh (revision 925) +++ oln/morpho/top_hat_black.hh (working copy) @@ -58,7 +58,7 @@ top_hat_black_(const Image& input, const Window<W>& win) { oln_plain(I) clo = closing(input, win); - return clo - input; + return arith::minus<oln_value(I)>(clo, input); } Index: oln/morpho/gradient.hh --- oln/morpho/gradient.hh (revision 925) +++ oln/morpho/gradient.hh (working copy) @@ -59,7 +59,7 @@ { oln_plain(I) dil = dilation(input, win); oln_plain(I) ero = erosion(input, win); - return dil - ero; + return arith::minus<oln_value(I)>(dil, ero); } Index: oln/morpho/top_hat_white.hh --- oln/morpho/top_hat_white.hh (revision 925) +++ oln/morpho/top_hat_white.hh (working copy) @@ -58,10 +58,9 @@ top_hat_white_(const Image& input, const Window<W>& win) { oln_plain(I) ope = opening(input, win) - return input - ope; + return arith::minus<oln_value(I)>(input, ope); } - // FIXME: Add a fast version. } // end of namespace oln::morpho::impl Index: oln/morpho/closing.hh Index: oln/morpho/opening.hh Index: oln/morpho/gradient_external.hh --- oln/morpho/gradient_external.hh (revision 925) +++ oln/morpho/gradient_external.hh (working copy) @@ -57,7 +57,7 @@ gradient_external_(const Image& input, const Window<W>& win) { oln_plain(I) dil = dilation(input, win); - return dil - input; + return arith::minus<oln_value(I)>(dil, input); } Index: oln/morpho/laplace.hh --- oln/morpho/laplace.hh (revision 925) +++ oln/morpho/laplace.hh (working copy) @@ -41,7 +41,7 @@ // Fwd decl. template <typename I, typename W> - oln_plain(I) + oln_minus_trait(I, I) laplace(const Image& input, const Window<W>& win); @@ -53,7 +53,7 @@ // Generic version. template <typename I, typename W> - oln_plain(I) + oln_minus_trait(I, I) laplace_(const Image& input, const Window<W>& win) { oln_plain(I) g_ext = gradient_external(input, win); @@ -70,9 +70,10 @@ // Facade. template <typename I, typename W> - oln_plain(I) + oln_minus_trait(I, I) laplace(const Image& input, const Window<W>& win) { + // FIXME: Add postcondition. return impl::laplace_(exact(input), exact(win)); } Index: oln/morpho/elementary_gradient_internal.hh --- oln/morpho/elementary_gradient_internal.hh (revision 925) +++ oln/morpho/elementary_gradient_internal.hh (working copy) @@ -57,7 +57,7 @@ elementary_gradient_internal_(const Image_with_Nbh& input) { oln_plain(I) ero = elementary_erosion(input) - return input - ero; + return arith::minus<oln_value(I)>(input, ero); } Index: oln/level/compare.hh --- oln/level/compare.hh (revision 925) +++ oln/level/compare.hh (working copy) @@ -60,6 +60,9 @@ bool operator <= (const Image& lhs, const literal_<oln_value(I)>& val); + // FIXME: is-it a good idea to have "ima = lit"? + // FIXME: should we rather have "ima = f:p->v"? + # ifndef OLN_LNCLUDE_ONLY Index: oln/arith/plus.hh --- oln/arith/plus.hh (revision 925) +++ oln/arith/plus.hh (working copy) @@ -29,8 +29,14 @@ # define OLN_ARITH_PLUS_HH # include <oln/core/concept/image.hh> -// # include <oln/core/internal/f_ch_value.hh> # include <oln/core/gen/traits.hh> +# include <oln/core/gen/pw_value.hh> +# include <oln/core/gen/value_cast.hh> +# include <oln/level/fill.hh> +# include <oln/core/internal/f_ch_value.hh> + + +// FIXME: what about "ima + literal"? namespace oln @@ -46,12 +52,22 @@ typedef oln_plain_value(I, V) ret; }; - // Fwd decl. + + // Fwd decls. template <typename I, typename J> oln_plus_trait(I, J) operator + (const Image& lhs, const Image<J>& rhs); + namespace arith + { + + template <typename V, typename I, typename J> + oln_plain_value(I, V) + plus(const Image& lhs, const Image<J>& rhs); + + } // end of namespace oln::arith + # ifndef OLN_INCLUDE_ONLY @@ -68,6 +84,23 @@ return output; } + namespace arith + { + + template <typename V, typename I, typename J> + oln_plain_value(I, V) + plus(const Image& lhs, const Image<J>& rhs) + { + precondition(lhs.points() = rhs.points()); + oln_plain_value(I, V) output; + prepare(output, with, lhs); + level::fill(output, + value_cast<V>(pw_value(lhs) + pw_value(rhs))); + return output; + } + + } // end of namespace oln::arith + # endif // ! OLN_INCLUDE_ONLY } // end of namespace oln Index: oln/arith/minus.hh --- oln/arith/minus.hh (revision 925) +++ oln/arith/minus.hh (working copy) @@ -30,6 +30,10 @@ # include <oln/core/concept/image.hh> # include <oln/core/gen/traits.hh> +# include <oln/core/gen/pw_value.hh> +# include <oln/core/gen/value_cast.hh> +# include <oln/level/fill.hh> +# include <oln/core/internal/f_ch_value.hh> namespace oln @@ -45,12 +49,21 @@ }; - // Fwd decl. + // Fwd decls. template <typename I, typename J> oln_minus_trait(I, J) operator - (const Image& lhs, const Image<J>& rhs); + namespace arith + { + + template <typename V, typename I, typename J> + oln_plain_value(I, V) + minus(const Image& lhs, const Image<J>& rhs); + + } // end of namespace oln::arith + # ifndef OLN_INCLUDE_ONLY @@ -67,6 +80,23 @@ return output; } + namespace arith + { + + template <typename V, typename I, typename J> + oln_plain_value(I, V) + minus(const Image& lhs, const Image<J>& rhs) + { + precondition(lhs.points() = rhs.points()); + oln_plain_value(I, V) output; + prepare(output, with, lhs); + level::fill(output, + value_cast<V>(pw_value(lhs) - pw_value(rhs))); + return output; + } + + } // end of namespace oln::arith + # endif // ! OLN_INCLUDE_ONLY } // end of namespace oln

17 years, 8 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches April 2007