Olena-patches June 2008

olena-patches@lrde.epita.fr

9 participants
135 discussions

2033: Add the ability to plot a point (small cross).

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Ugo Jardonnet <jardonnet(a)lrde.epita.fr> Add the ability to plot a point (small cross). * mln/draw/plot.hh: New. Plot a point. * mln/draw/all.hh: Update. Add plot.hh. all.hh | 1 plot.hh | 94 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 95 insertions(+) Index: mln/draw/plot.hh --- mln/draw/plot.hh (revision 0) +++ mln/draw/plot.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 inplot 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 MLN_DRAW_PLOT_HH +# define MLN_DRAW_PLOT_HH + +/*! \file mln/draw/plot.hh + * + * \brief Plot a point (small cross) in an image. + */ + +# include <mln/core/concept/image.hh> +# include <mln/core/line2d.hh> +# include <mln/level/paste.hh> +# include <mln/pw/image.hh> +# include <mln/pw/cst.hh> + + +namespace mln +{ + + namespace draw + { + + /*! Plot a point at level \p v in image \p ima between the points + * \p beg and \p end. + * + * \param[in,out] ima The image to be drawn. + * \param[in] p The point to be plotted. + * \param[in] v The value to assign to all drawn pixels. + * + * \pre \p ima has to be initialized. + * \pre \p ima has \p p. + * + */ + template <typename I> + void plot(Image& ima, + const mln_point(I)& p, + const mln_value(I)& v); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + inline + void plot(Image& ima, + const mln_point(I)& p, + const mln_value(I)& v) + { + mln_precondition(exact(ima).has_data()); + mln_precondition(exact(ima).has(p)); + + for (unsigned i = 0; i < I::point::dim; i++) + { + mln_point(I) beg = p, end = p; + beg[i] = beg[i] - 1; + end[i] = end[i] + 1; + level::paste(pw::cst(v) | line2d(beg, end), + ima); + } + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::draw + +} // end of namespace mln + + +#endif // ! MLN_DRAW_PLOT_HH Index: mln/draw/all.hh --- mln/draw/all.hh (revision 2032) +++ mln/draw/all.hh (working copy) @@ -46,5 +46,6 @@ # include <mln/draw/graph.hh> # include <mln/draw/label.hh> # include <mln/draw/line.hh> +# include <mln/draw/plot.hh> #endif // ! MLN_DRAW_ALL_HH

16 years, 6 months

2032: Sandbox: ICP: Add material for slides illustration.

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Ugo Jardonnet <jardonnet(a)lrde.epita.fr> Sandbox: ICP: Add material for slides illustration. * jardonnet/test/icp_ref.cc: Update. Mark centers of mass. * jardonnet/registration/save.hh: Update. Mark center of mass and orientation. * jardonnet/registration/power_it.hh: Update. Now works in n-D. * jardonnet/registration/quat7.hh: Update. Cosmetic change. * jardonnet/TODO: Update. * jardonnet/test/Makefile: Fix clean rule. TODO | 2 -- registration/icp_ref.hh | 6 ++---- registration/power_it.hh | 20 +++++++++----------- registration/quat7.hh | 5 ++--- registration/save.hh | 26 ++++++++++++++++++++++++-- test/Makefile | 5 +++-- test/icp_ref.cc | 31 ++++++++++++++++--------------- 7 files changed, 56 insertions(+), 39 deletions(-) Index: jardonnet/test/icp_ref.cc --- jardonnet/test/icp_ref.cc (revision 2031) +++ jardonnet/test/icp_ref.cc (working copy) @@ -43,27 +43,20 @@ I3d surface = convert::to_image3d(img2); //build p_arrays. - p_array< point_<grid::cube, float> > c; + typedef point_<grid::cube,float> point3df; + p_array<point3df> c; { mln_piter_(I3d) p(cloud.domain()); for_all(p) if (cloud(p)) - { - point_<grid::cube,float> p_; - p_[0] = p[0]; p_[1] = p[1]; p_[2] = p[2]; - c.append(p_); - } + c.append(algebra::to_point<point3df>(point3d(p))); } - p_array< point_<grid::cube, float> > x; + p_array<point3df> x; { mln_piter_(I3d) p(surface.domain()); for_all(p) if (surface(p)) - { - point_<grid::cube,float> p_; - p_[0] = p[0]; p_[1] = p[1]; p_[2] = p[2]; - x.append(p_); - } + x.append(algebra::to_point<point3df>(point3d(p))); } //working box @@ -84,20 +77,28 @@ image2d<value::rgb8> output(convert::to_box2d(working_box), 1); level::fill(output, literal::white); + //plot mu_Ck + point3df mu_Ck = registration::center(c, c.npoints()); + draw::plot(output, point2d(mu_Ck[0], mu_Ck[1]), literal::green); + + //plot mu_X + point3df mu_X = registration::center(x, x.npoints()); + draw::plot(output, point2d(mu_X[0], mu_X[1]), literal::black); + //to 2d : projection (FIXME:if 3d) for (unsigned i = 0; i < c.npoints(); i++) { point2d p(c[i][0], c[i][1]); if (output.has(p)) - output(p) = literal::black; + output(p) = literal::green; } - //ref image + //ref image (black) for (unsigned i = 0; i < x.npoints(); i++) { point2d px(x[i][0], x[i][1]); if (output.has(px)) - output(px) = literal::green; + output(px) = literal::black; } io::ppm::save(output, "registred.ppm"); Index: jardonnet/test/Makefile --- jardonnet/test/Makefile (revision 2031) +++ jardonnet/test/Makefile (working copy) @@ -36,12 +36,13 @@ clean: rm -f -- ./bin/* - rm -f sub gsub gau icpD icp icp_refD icp_ref + rm -f sub gsub gau icpD icp icp_refD icp_ref *.o rm -f log.dat registred.pbm rm -f i_* rm -f tmp.ppm registred.ppm semantic.cache + rm -f step_* -.PHONY: check bench test icpD +.PHONY: check bench test icpD icp_refD icp icp_ref +depend: g++ -M icp.cc $(FLAG) > +depend Index: jardonnet/TODO --- jardonnet/TODO (revision 2031) +++ jardonnet/TODO (working copy) @@ -12,8 +12,6 @@ adapt test for threshold (old thresholding) - - -La translation est mauvaise car certain point de Xk sont compté plusieurs fois. /bof - - - write trans : vec --> quat @@ -21,3 +19,15 @@ - - io/all.hh cassé \ No newline at end of file + +- - +Mettre au clair center, mean ... + +- - + +algebra::to_point ne devrait pas etre dans algebra puisqu'il + est utile pour passer d'un point<int> vers point<float> +move it in convert + +- - +ecrire cov.hh. quoi en argument (p_array, std::set, std::vector?) \ No newline at end of file Index: jardonnet/registration/power_it.hh --- jardonnet/registration/power_it.hh (revision 2031) +++ jardonnet/registration/power_it.hh (working copy) @@ -12,29 +12,27 @@ namespace mln { - algebra::quat power_it(algebra::mat<4,4,float> A) + template <uint n> + algebra::vec<n,float> power_it(algebra::mat<n,n,float> A) { float normex = 1.; - algebra::vec<4,float> x0(literal::zero); - algebra::vec<4,float> b(literal::zero); + algebra::vec<n,float> x0(literal::zero); + algebra::vec<n,float> b(literal::zero); - algebra::vec<4,float> x(literal::zero); - for (int i = 0; i < 4; i++) + algebra::vec<n,float> x(literal::zero); + for (int i = 0; i < n; i++) x[i] = 1.; - while (fabs(norm::l2(x) - norm::l2(x0)) > 1e-6) + //FIXME: infinit loop. + while (about_equal(norm::l2(x),norm::l2(x0))) { x0 = x; normex = norm::l2(x); b = x / normex; x = A * b; } - normex = norm::l2(x); - - algebra::quat q(x / normex); - q.set_unit(); - return q; + return x.normalize(); } } Index: jardonnet/registration/save.hh --- jardonnet/registration/save.hh (revision 2031) +++ jardonnet/registration/save.hh (working copy) @@ -4,10 +4,12 @@ # include <mln/convert/to_image.hh> # include <mln/io/ppm/save.hh> # include <mln/io/pbm/save.hh> +# include <mln/draw/all.hh> # include <string> # include "quat7.hh" # include "tools.hh" +# include "power_it.hh" namespace mln { @@ -21,7 +23,7 @@ { mln_precondition(P::dim == 2); - image2d out = convert::to_image(a); + image2d<bool> out = convert::to_image(a); save(out, filename); } } @@ -51,7 +53,27 @@ image2d<value::rgb8> out(convert::to_box2d(working_box), 1); level::fill(out, literal::white); - //x in green + //plot mu_Ck + algebra::vec<P::dim,float> mu_Ck = center(ck, ck.npoints()); + draw::plot(out, point2d(mu_Ck[0], mu_Ck[1]), literal::green); + //shape orientation + algebra::mat<P::dim,P::dim,float> Mk(literal::zero); + for (unsigned i = 0; i < ck.npoints(); ++i) + { + algebra::vec<P::dim,float> Cki = ck[i]; + Mk += make::mat(Cki - mu_Ck) * trans(make::mat(Cki - mu_Ck)); + } + Mk /= c.npoints(); + algebra::vec<3,float> vck = power_it(Mk); + draw::line(out, point2d(mu_Ck[0], mu_Ck[1]), + point2d(mu_Ck[0]+vck[0]*10, mu_Ck[1]+vck[1]*10), + literal::red); + + //plot mu_X + P mu_X = center(x, x.npoints()); + draw::plot(out, point2d(mu_X[0], mu_X[1]), literal::black); + + //ck in green for (unsigned i = 0; i < ck.npoints(); i++) { point2d p(ck[i][0], ck[i][1]); Index: jardonnet/registration/quat7.hh --- jardonnet/registration/quat7.hh (revision 2031) +++ jardonnet/registration/quat7.hh (working copy) @@ -131,17 +131,16 @@ { //mu_Xk = center map(Ck) algebra::vec<P::dim,float> mu_Xk(literal::zero); - for (size_t i = 0; i < c_length; ++i) + for (unsigned i = 0; i < c_length; ++i) { algebra::vec<P::dim,float> xki = map(Ck[i]); mu_Xk += xki; } mu_Xk /= c_length; - // qR algebra::mat<P::dim,P::dim,float> Mk(literal::zero); - for (size_t i = 0; i < c_length; ++i) + for (unsigned i = 0; i < c_length; ++i) { algebra::vec<P::dim,float> Ci = C[i]; algebra::vec<P::dim,float> Xki = map(Ck[i]); Index: jardonnet/registration/icp_ref.hh --- jardonnet/registration/icp_ref.hh (revision 2031) +++ jardonnet/registration/icp_ref.hh (working copy) @@ -62,8 +62,6 @@ namespace mln { - - namespace registration { @@ -128,6 +126,7 @@ qk.apply_on(C, Ck, c_length); d_k_1 = d_k; + // d_k = d(Yk, Pk+1) // = d(closest(qk-1(P)), qk(P)) d_k = rms(C, map, c_length, buf_qk[1], qk); @@ -136,8 +135,7 @@ e_k = rms(C, map, c_length, buf_qk[1], buf_qk[1]); #ifndef NDEBUG - //save file - save_(qk,C,X,5); + save_(qk,C,X,2); //print info std::cout << k << '\t' << (e_k >= d_k ? ' ' : '-') << '\t' << e_k << '\t' << d_k << '\t' << ((qk - buf_qk[1]).sqr_norm() / qk.sqr_norm()) << '\t'

16 years, 6 months

2028: Sandbox: ICP: Add material for slides illustration.

by Ugo Jardonnet

16 years, 6 months

cleanup-2008 2031: Equip proxies to transparently handle operators.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/branches/cleanup-2008/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Equip proxies to transparently handle operators. * doc/tutorial/examples/p_array.cc: Add tests on proxy_level and on op== applied on proxies. * mln/core/concept/proxy.hh (internal): New meta-code. (set_binary_, set_unary_): Re-activate and make it work. (operator==): New; it is only a start. (operator-): Likewise. (proxy_level): New in Proxy requirements. (helper_proxy_impl): Define proxy_level. * mln/core/concept/gpoint.hh: . doc/tutorial/examples/p_array.cc | 28 +++++++- mln/core/concept/gpoint.hh | 2 mln/core/concept/proxy.hh | 129 ++++++++++++++++++++++++++++++++++----- 3 files changed, 142 insertions(+), 17 deletions(-) Index: doc/tutorial/examples/p_array.cc --- doc/tutorial/examples/p_array.cc (revision 2030) +++ doc/tutorial/examples/p_array.cc (working copy) @@ -27,6 +27,15 @@ using namespace mln; typedef p_array<point2d> Arr1; + typedef p_array<mln_psite_(Arr1)> Arr2; + + { + mln_assertion(mln_psite_(Arr1)::proxy_level == 1); + mln_assertion(mln_piter_(Arr1)::proxy_level == 2); + mln_assertion(mln_psite_(Arr2)::proxy_level == 2); + mln_assertion(mln_piter_(Arr2)::proxy_level == 3); + } + Arr1 arr1; { @@ -41,22 +50,26 @@ } { - typedef p_array< mln_psite_(Arr1) > Arr2; + Arr2 arr2; + // Fill arr2 from arr1 contents. + { mln_piter_(Arr1) p(arr1); for_all(p) if (p.row() % 2 && p.col() % 2) arr2.append(p); + } std::cout << "arr2 = " << arr2 << std::endl; picture(arr2); + // Display indices. { mln_piter_(Arr2) p(arr2); for_all(p) { -// mln_assertion(make::point2d(p.row(), p.col()) == p); // FIXME: Make it work. + mln_assertion(make::point2d(p.row(), p.col()) == p); std::cout << "point " << p << ": #" << index_of_in(p, arr2) << " in arr2, #" << index_of_in(p, arr1) << " in arr1" << std::endl; @@ -64,6 +77,17 @@ } mln_invariant(arr2 < arr1); + + { + mln_piter_(Arr1) p1(arr1); + mln_piter_(Arr2) p2(arr2); + for_all_2(p1, p2) + { + mln_assertion(p2 == p1); // same as: p2.to_site() == p1.to_site() + p1.next(); // p1 goes twice fast as p2. + } + } + } } Index: mln/core/concept/proxy.hh --- mln/core/concept/proxy.hh (revision 2030) +++ mln/core/concept/proxy.hh (working copy) @@ -46,40 +46,75 @@ template <typename E> struct Proxy; - /* - FIXME: Re-activate. + namespace internal + { - namespace trait + template <bool b, typename P> struct unproxy_if; + + template <typename P> + struct unproxy_if< true, P > + { + typedef mln_subject(P) ret; + static typename P::q_subject on(const Proxy& p) { return exact(p).unproxy(); } + }; + + template <typename P> + struct unproxy_if< false, P > { + typedef P ret; + static const P& on(const Proxy& p) { return exact(p); } + }; + + template <typename L, typename R> + struct unproxy_couple + { + enum { L_level = L::proxy_level, + R_level = R::proxy_level }; // To prevent a weird g++ warning. + typedef internal::unproxy_if<(L_level >= R_level), L> L_helper; + typedef internal::unproxy_if<(R_level >= L_level), R> R_helper; + typedef typename L_helper::ret L_ret; + typedef typename R_helper::ret R_ret; + }; - template < typename Op, typename P1, typename P2 > - struct set_binary_< Op, mln::Proxy, P1, mln::Proxy, P2 > + } // end of namespace mln::internal + + + + namespace trait { - typedef mln_trait_binary(Op, mln_subject(P1), mln_subject(P2)) ret; + + template < template <class, class> class Op, + typename L, typename R > + struct set_binary_< Op, mln::Proxy, L, mln::Proxy, R > + { + typedef mln::internal::unproxy_couple<L, R> helper; + typedef mln_trait_binary(Op, + typename helper::L_ret, + typename helper::R_ret) ret; }; - template < typename Op, typename P, typename O > + template < template <class, class> class Op, + typename P, typename O > struct set_binary_< Op, mln::Proxy, P, mln::Object, O > { typedef mln_trait_binary(Op, mln_subject(P), O) ret; }; - template < typename Op, typename E, typename P > - struct set_binary_< Op, mln::Object, E, mln::Proxy, P > + template < template <class, class> class Op, + typename O, typename P > + struct set_binary_< Op, mln::Object, O, mln::Proxy, P > { typedef mln_trait_binary(Op, O, mln_subject(P)) ret; }; - template < typename Op, typename P > - struct set_binary_< Op, mln::Proxy, P > + template < template <class> class Op, typename P > + struct set_unary_< Op, mln::Proxy, P > { typedef mln_trait_unary(Op, mln_subject(P)) ret; }; } // end of namespace mln::trait - */ - /// Proxy category flag type. @@ -99,6 +134,7 @@ typedef Proxy<void> category; /* + enum { proxy_level }; typedef subject; typedef q_subject; q_subject unproxy() const; @@ -113,6 +149,63 @@ }; + + template <typename L, typename R> + inline + mln_trait_op_minus(L, R) + operator-(const mln::Proxy<L>& lhs, const mln::Proxy<R>& rhs) + { + typedef typename internal::unproxy_couple<L, R>::L_helper L_unproxy; + typedef typename internal::unproxy_couple<L, R>::R_helper R_unproxy; + return L_unproxy::on(lhs) - R_unproxy::on(rhs); + } + + template <typename P, typename O> + inline + mln_trait_op_minus(P, O) + operator-(const Proxy& p, const Object<O>& o) + { + return exact(p).unproxy() - exact(o); + } + + template <typename O, typename P> + inline + mln_trait_op_minus(O, P) + operator-(const Object<O>& o, const Proxy& p) + { + return exact(o) - exact(p).unproxy(); + } + + + + template <typename L, typename R> + inline + mln_trait_op_eq(L, R) + operator==(const mln::Proxy<L>& lhs, const mln::Proxy<R>& rhs) + { + typedef typename internal::unproxy_couple<L, R>::L_helper L_unproxy; + typedef typename internal::unproxy_couple<L, R>::R_helper R_unproxy; + return L_unproxy::on(lhs) == R_unproxy::on(rhs); + } + + template <typename P, typename O> + inline + mln_trait_op_eq(P, O) + operator==(const Proxy& p, const Object<O>& o) + { + return exact(p).unproxy() == exact(o); + } + + template <typename O, typename P> + inline + mln_trait_op_eq(O, P) + operator==(const Object<O>& o, const Proxy& p) + { + return exact(o) == exact(p).unproxy(); + } + + + namespace internal { @@ -181,11 +274,15 @@ template <typename Subject, typename E, bool rec = true> struct helper_proxy_impl : proxy_impl< mln_subject(Subject), E > // Rec. - {}; + { + enum { proxy_level = Subject::proxy_level + 1}; + }; template <typename Subject, typename E> struct helper_proxy_impl< Subject, E, false > // Stop rec. - {}; + { + enum { proxy_level = 1 }; + }; template <typename Subject, typename E> struct proxy_impl : helper_proxy_impl< Subject, E, @@ -224,6 +321,8 @@ inline Proxy<E>::Proxy() { + enum { proxy_level = E::proxy_level }; // FIXME: Check that it is >= 0... + typedef mln_subject(E) subject; typedef typename E::q_subject q_subject; Index: mln/core/concept/gpoint.hh --- mln/core/concept/gpoint.hh (revision 2030) +++ mln/core/concept/gpoint.hh (working copy) @@ -92,6 +92,8 @@ template <typename E> struct Gpoint : public Object<E> { + typedef Gpoint<void> category; + /* typedef grid; typedef delta;

16 years, 6 months

cleanup-2008 2030: Introduce Gpoint and Gdpoint.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/branches/cleanup-2008/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Introduce Gpoint and Gdpoint. The concepts of Point_Site and Delta_Point_Site are made obsolete. They are replaced by Gpoint and Gdpoint ('G' meaning "grid" for short). As a consequence, the concept of Point is also obsolete. * doc/tutorial/examples/p_array.cc: Add an assertion. * mln/core/macros.hh (mln_delta, mln_vec): New. * mln/core/point.hh (M): Rename parameter as... (G): ...this; it is a Grid type (not a mesh). (point_): Change inheritance to Gpoint. (grid, vec, delta): New. (point_): New overload ctor for vec. * mln/core/dpoint.hh: Likewise. * mln/core/point2d.hh: Layout. * mln/core/concept/status.txt: New. * mln/core/concept/point.hh: Copy to... * mln/core/concept/gpoint.hh: ...this new file. (operator): Now rely on to_vec, no more on [i]. * mln/core/concept/delta_point_site.hh: Copy to... * mln/core/concept/gdpoint.hh: ...this new file. (operator): Now rely on to_vec, no more on [i]. doc/tutorial/examples/p_array.cc | 3 mln/core/concept/gdpoint.hh | 132 ++++++------------- mln/core/concept/gpoint.hh | 265 +++++++++++++++++++++++++++++++-------- mln/core/concept/status.txt | 10 + mln/core/dpoint.hh | 131 ++++++++++--------- mln/core/macros.hh | 22 +++ mln/core/point.hh | 195 +++++++++++++++------------- mln/core/point2d.hh | 107 +++++++++++---- 8 files changed, 544 insertions(+), 321 deletions(-) Index: doc/tutorial/examples/p_array.cc --- doc/tutorial/examples/p_array.cc (revision 2029) +++ doc/tutorial/examples/p_array.cc (working copy) @@ -55,10 +55,13 @@ { mln_piter_(Arr2) p(arr2); for_all(p) + { +// mln_assertion(make::point2d(p.row(), p.col()) == p); // FIXME: Make it work. std::cout << "point " << p << ": #" << index_of_in(p, arr2) << " in arr2, #" << index_of_in(p, arr1) << " in arr1" << std::endl; } + } mln_invariant(arr2 < arr1); } Index: mln/core/macros.hh --- mln/core/macros.hh (revision 2029) +++ mln/core/macros.hh (working copy) @@ -91,6 +91,12 @@ // d +/// Shortcuts to access the delta type associated to T. +/// \{ +# define mln_delta(T) typename T::delta +# define mln_delta_(T) T::delta +/// \} + /// Shortcuts to access the dpoint type associated to T. /// \{ # define mln_dpoint(T) typename T::dpoint @@ -145,6 +151,16 @@ # define mln_fwd_viter_(T) T::fwd_viter /// \} + +// g + +/// Shortcuts to access the grid type associated to T. +/// \{ +# define mln_grid(T) typename T::grid +# define mln_grid_(T) T::grid +/// \} + + // i /// Shortcuts to access the image type associated to T. @@ -275,6 +291,12 @@ # define mln_value_(T) T::value /// \} +/// Shortcuts to access the algebra::vector (vec) type associated to T. +/// \{ +# define mln_vec(T) typename T::vec +# define mln_vec_(T) T::vec +/// \} + /// Shortcuts to access the type of value set (vset) associated to T. /// \{ # define mln_vset(T) typename T::vset Index: mln/core/point.hh --- mln/core/point.hh (revision 2029) +++ mln/core/point.hh (working copy) @@ -32,10 +32,10 @@ * * \brief Definition of the generic point class mln::point_. * - * \todo Try to generalize less_than with Ml and Mr. + * \todo Try to generalize less_than with Gl and Gr. */ -# include <mln/core/concept/point.hh> +# include <mln/core/concept/gpoint.hh> # include <mln/core/internal/coord_impl.hh> # include <mln/fun/i2v/all_to.hh> @@ -49,8 +49,8 @@ { /// \{ Fwd decls. - template <typename M, typename C> struct point_; - template <typename M, typename C> struct dpoint_; + template <typename G, typename C> struct point_; + template <typename G, typename C> struct dpoint_; namespace literal { struct zero_t; struct one_t; @@ -64,11 +64,11 @@ // Helper point_to_. - template <typename M, typename C> + template <typename G, typename C> struct point_to_ { - typedef algebra::vec<M::dim, C> metal_vec; - typedef mln::h_vec<M::dim, C> h_vec; + typedef algebra::vec<G::dim, C> metal_vec; + typedef mln::h_vec<G::dim, C> h_vec; }; } // end of namespace mln::internal @@ -80,28 +80,34 @@ * Parameters are \c n the dimension of the space and \c C the * coordinate type in this space. */ - template <typename M, typename C> - struct point_ : public Point< point_<M,C> >, - public internal::mutable_coord_impl_< M::dim, C, point_<M,C> > + template <typename G, typename C> + struct point_ : public Gpoint< point_<G,C> >, + public internal::mutable_coord_impl_< G::dim, C, point_<G,C> > { /*! \var dim * \brief Dimension of the space. * \invariant dim > 0 */ - enum { dim = M::dim }; + enum { dim = G::dim }; - /// Mesh associated type. - typedef M mesh; + /// Grid associated type. + typedef G grid; /// Dpoint associated type. - typedef dpoint_<M,C> dpoint; + typedef dpoint_<G,C> dpoint; + + /// Delta associated type. + typedef dpoint_<G,C> delta; /// DPsite associated type. - typedef dpoint_<M,C> dpsite; + typedef dpoint_<G,C> dpsite; /// Coordinate associated type. typedef C coord; + /// Algebra vector (vec) associated type. + typedef algebra::vec<G::dim, C> vec; + /*! \brief Read-only access to the \p i-th coordinate value. * \param[in] i The coordinate index. * \pre \p i < \c dim @@ -117,6 +123,10 @@ /// Constructor without argument. point_(); + /// Constructor from an algebra vector. + template <typename C2> + point_(const algebra::vec<dim,C2>& v); + /// \{ Constructors with different numbers of arguments /// (coordinates) w.r.t. the dimension. point_(C ind); @@ -126,12 +136,12 @@ /// \{ Constructors/assignments with literals. point_(const literal::origin_t&); - point_<M,C>& operator=(const literal::origin_t&); + point_<G,C>& operator=(const literal::origin_t&); // Works only in 1D: point_(const literal::zero_t&); - point_<M,C>& operator=(const literal::zero_t&); + point_<G,C>& operator=(const literal::zero_t&); point_(const literal::one_t&); - point_<M,C>& operator=(const literal::one_t&); + point_<G,C>& operator=(const literal::one_t&); /// \} /// Constructor; coordinates are set by function \p f. @@ -142,29 +152,26 @@ void set_all(C c); /// Origin point (all coordinates are 0). - static const point_<M,C> origin; + static const point_<G,C> origin; /// Shifting by \p dp. - point_<M,C>& operator+=(const dpoint& dp); + point_<G,C>& operator+=(const dpoint& dp); /// Shifting by \p the inverse of dp. - point_<M,C>& operator-=(const dpoint& dp); - - /// Type of the array of coordinates. - typedef algebra::vec<M::dim, C> vec_t; + point_<G,C>& operator-=(const dpoint& dp); /// Hook to coordinates. - operator typename internal::point_to_<M, C>::metal_vec () const; - operator algebra::vec<M::dim, float> () const; + operator typename internal::point_to_<G, C>::metal_vec () const; + operator algebra::vec<G::dim, float> () const; /// Explicit conversion towards mln::algebra::vec. - const algebra::vec<M::dim, C>& to_vec() const; + const algebra::vec<G::dim, C>& to_vec() const; /// Transform to point in homogene coordinate system. - h_vec<M::dim, C> to_h_vec() const; + h_vec<G::dim, C> to_h_vec() const; protected: - algebra::vec<M::dim, C> coord_; + algebra::vec<G::dim, C> coord_; }; @@ -183,9 +190,9 @@ * not bound to the way of browsing a domain with a forward point * iterator. */ - template <typename M, typename Cl, typename Cr> - struct less_than< point_<M,Cl>, - point_<M,Cr> > + template <typename G, typename Cl, typename Cr> + struct less_than< point_<G,Cl>, + point_<G,Cr> > { /*! \brief Comparison between a couple of points \a lhs and \a * rhs. @@ -193,8 +200,8 @@ * \return True if \p lhs is before \p rhs in the sense of the * coordinates lexicographic comparison, otherwise false. */ - bool operator()(const point_<M,Cl>& lhs, - const point_<M,Cr>& rhs) const; + bool operator()(const point_<G,Cl>& lhs, + const point_<G,Cr>& rhs) const; }; } // end of namespace mln::util @@ -202,17 +209,17 @@ # ifndef MLN_INCLUDE_ONLY - template <typename M, typename C> + template <typename G, typename C> inline - C point_<M,C>::operator[](unsigned i) const + C point_<G,C>::operator[](unsigned i) const { assert(i < dim); return this->coord_[i]; } - template <typename M, typename C> + template <typename G, typename C> inline - C& point_<M,C>::operator[](unsigned i) + C& point_<G,C>::operator[](unsigned i) { assert(i < dim); return this->coord_[i]; @@ -220,32 +227,40 @@ // Constructors. - template <typename M, typename C> + template <typename G, typename C> + inline + point_<G,C>::point_() + { + } + + template <typename G, typename C> + template <typename C2> inline - point_<M,C>::point_() + point_<G,C>::point_(const algebra::vec<dim,C2>& v) { + coord_ = v; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::point_(C ind) + point_<G,C>::point_(C ind) { metal::bool_<(dim == 1)>::check(); coord_[0] = ind; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::point_(C row, C col) + point_<G,C>::point_(C row, C col) { metal::bool_<(dim == 2)>::check(); coord_[0] = row; coord_[1] = col; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::point_(C sli, C row, C col) + point_<G,C>::point_(C sli, C row, C col) { metal::bool_<(dim == 3)>::check(); coord_[0] = sli; @@ -253,10 +268,10 @@ coord_[2] = col; } - template <typename M, typename C> + template <typename G, typename C> template <typename F> inline - point_<M,C>::point_(const Function_i2v<F>& f_) + point_<G,C>::point_(const Function_i2v<F>& f_) { mlc_converts_to(mln_result(F), C)::check(); const F& f = exact(f_); @@ -264,98 +279,98 @@ coord_[i] = f(i); } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::point_(const literal::origin_t&) + point_<G,C>::point_(const literal::origin_t&) { coord_.set_all(0); } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>& - point_<M,C>::operator=(const literal::origin_t&) + point_<G,C>& + point_<G,C>::operator=(const literal::origin_t&) { coord_.set_all(0); return *this; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::point_(const literal::zero_t&) + point_<G,C>::point_(const literal::zero_t&) { metal::bool_<(dim == 1)>::check(); coord_[0] = 1; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>& - point_<M,C>::operator=(const literal::zero_t&) + point_<G,C>& + point_<G,C>::operator=(const literal::zero_t&) { metal::bool_<(dim == 1)>::check(); coord_[0] = 1; return *this; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::point_(const literal::one_t&) + point_<G,C>::point_(const literal::one_t&) { metal::bool_<(dim == 1)>::check(); coord_[0] = 1; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>& - point_<M,C>::operator=(const literal::one_t&) + point_<G,C>& + point_<G,C>::operator=(const literal::one_t&) { metal::bool_<(dim == 1)>::check(); coord_[0] = 1; return *this; } - template <typename M, typename C> + template <typename G, typename C> inline - void point_<M,C>::set_all(C c) + void point_<G,C>::set_all(C c) { coord_.set_all(c); } - template <typename M, typename C> - const point_<M,C> point_<M,C>::origin = all_to(0); + template <typename G, typename C> + const point_<G,C> point_<G,C>::origin = all_to(0); - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>& - point_<M,C>::operator+=(const dpoint& dp) + point_<G,C>& + point_<G,C>::operator+=(const dpoint& dp) { for (unsigned i = 0; i < dim; ++i) coord_[i] += dp[i]; return *this; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>& - point_<M,C>::operator-=(const dpoint& dp) + point_<G,C>& + point_<G,C>::operator-=(const dpoint& dp) { for (unsigned i = 0; i < dim; ++i) coord_[i] -= dp[i]; return *this; } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::operator typename internal::point_to_<M, C>::metal_vec () const + point_<G,C>::operator typename internal::point_to_<G, C>::metal_vec () const { - return coord_; // FIXME: Is-it OK? + return coord_; // FIXGE: Is-it OK? } - template <typename M, typename C> + template <typename G, typename C> inline - point_<M,C>::operator algebra::vec<M::dim, float> () const + point_<G,C>::operator algebra::vec<G::dim, float> () const { algebra::vec<dim, float> tmp; for (unsigned i = 0; i < dim; ++i) @@ -363,22 +378,22 @@ return tmp; } - template <typename M, typename C> + template <typename G, typename C> inline - const algebra::vec<M::dim, C>& - point_<M,C>::to_vec() const + const algebra::vec<G::dim, C>& + point_<G,C>::to_vec() const { return coord_; } - template <typename M, typename C> + template <typename G, typename C> inline - h_vec<M::dim, C> point_<M,C>::to_h_vec() const + h_vec<G::dim, C> point_<G,C>::to_h_vec() const { - h_vec<M::dim, C> tmp; + h_vec<G::dim, C> tmp; for (unsigned i = 0; i < dim; ++i) tmp[i] = coord_[i]; - tmp[M::dim] = 1; + tmp[G::dim] = 1; return tmp; } @@ -386,13 +401,13 @@ namespace util { - template <typename M, typename Cl, typename Cr> + template <typename G, typename Cl, typename Cr> bool - less_than< point_<M,Cl>, - point_<M,Cr> >::operator()(const point_<M,Cl>& lhs, - const point_<M,Cr>& rhs) const + less_than< point_<G,Cl>, + point_<G,Cr> >::operator()(const point_<G,Cl>& lhs, + const point_<G,Cr>& rhs) const { - enum { n = M::dim }; + enum { n = G::dim }; typedef less_than< algebra::vec<n,Cl>, algebra::vec<n,Cr> > less_t; static const less_t op = less_t(); return op(lhs.to_vec(), rhs.to_vec()); Index: mln/core/dpoint.hh --- mln/core/dpoint.hh (revision 2029) +++ mln/core/dpoint.hh (working copy) @@ -33,7 +33,7 @@ * \brief Definition of the generic delta-point class mln::dpoint_. */ -# include <mln/core/concept/dpoint.hh> +# include <mln/core/concept/gdpoint.hh> # include <mln/core/internal/coord_impl.hh> # include <mln/fun/i2v/all.hh> # include <mln/algebra/vec.hh> @@ -43,7 +43,7 @@ { /// \{ Fwd decls. - template <typename M, typename C> struct point_; + template <typename G, typename C> struct point_; namespace literal { struct zero_t; struct one_t; @@ -53,34 +53,37 @@ /*! \brief Generic delta-point class. * - * Parameters are \c M the dimension of the space and \c C the + * Parameters are \c G the dimension of the space and \c C the * coordinate type in this space. */ - template <typename M, typename C> - struct dpoint_ : public Dpoint< dpoint_<M,C> >, - public internal::mutable_coord_impl_< M::dim, C, dpoint_<M,C> > + template <typename G, typename C> + struct dpoint_ : public Gdpoint< dpoint_<G,C> >, + public internal::mutable_coord_impl_< G::dim, C, dpoint_<G,C> > { /*! \var dim * \brief Dimension of the space. * \invariant dim > 0 */ - enum { dim = M::dim }; + enum { dim = G::dim }; - /// Mesh associated type. - typedef M mesh; + /// Grid associated type. + typedef G grid; /// Point associated type. - typedef point_<M,C> point; + typedef point_<G,C> point; /// Psite associated type. - typedef point_<M,C> psite; + typedef point_<G,C> psite; /// Site associated type. - typedef point_<M,C> site; + typedef point_<G,C> site; /// Coordinate associated type. typedef C coord; + /// Algebra vector (vec) associated type. + typedef algebra::vec<G::dim, C> vec; + /*! \brief Read-only access to the \p i-th coordinate value. * \param[in] i The coordinate index. * \pre \p i < \c dim @@ -96,6 +99,10 @@ /// Constructor without argument. dpoint_(); + /// Constructor from an algebra vector. + template <typename C2> + dpoint_(const algebra::vec<dim,C2>& v); + /// \{ Constructors with different numbers of arguments /// (coordinates) w.r.t. the dimension. dpoint_(C ind); @@ -105,10 +112,10 @@ /// \{ Constructors/assignments with literals. dpoint_(const literal::zero_t&); - dpoint_<M,C>& operator=(const literal::zero_t&); + dpoint_<G,C>& operator=(const literal::zero_t&); // Works only in 1D: dpoint_(const literal::one_t&); - dpoint_<M,C>& operator=(const literal::one_t&); + dpoint_<G,C>& operator=(const literal::one_t&); /// \} /// Constructor; coordinates are set by function \p f. @@ -120,13 +127,13 @@ /// Conversion towards a algebra::vec. template <typename Q> - operator algebra::vec<M::dim, Q>() const; + operator algebra::vec<G::dim, Q>() const; /// Explicit conversion. - const algebra::vec<M::dim, C>& to_vec() const; + const algebra::vec<G::dim, C>& to_vec() const; protected: - algebra::vec<M::dim, C> coord_; + algebra::vec<G::dim, C> coord_; }; @@ -141,9 +148,9 @@ * * Both delta-points have to be defined on the same topology. */ - template <typename M, typename Cl, typename Cr> - struct less_than< dpoint_<M,Cl>, - dpoint_<M,Cr> > + template <typename G, typename Cl, typename Cr> + struct less_than< dpoint_<G,Cl>, + dpoint_<G,Cr> > { /*! \brief Comparison between a couple of delta-points \a lhs * and \a rhs. @@ -151,8 +158,8 @@ * \return True if \p lhs is before \p rhs in the sense of the * coordinates lexicographic comparison, otherwise false. */ - bool operator()(const dpoint_<M,Cl>& lhs, - const dpoint_<M,Cr>& rhs) const; + bool operator()(const dpoint_<G,Cl>& lhs, + const dpoint_<G,Cr>& rhs) const; }; } // end of namespace mln::util @@ -160,48 +167,56 @@ # ifndef MLN_INCLUDE_ONLY - template <typename M, typename C> + template <typename G, typename C> inline - C dpoint_<M,C>::operator[](unsigned i) const + C dpoint_<G,C>::operator[](unsigned i) const { assert(i < dim); return coord_[i]; } - template <typename M, typename C> + template <typename G, typename C> inline - C& dpoint_<M,C>::operator[](unsigned i) + C& dpoint_<G,C>::operator[](unsigned i) { assert(i < dim); return coord_[i]; } - template <typename M, typename C> + template <typename G, typename C> + inline + dpoint_<G,C>::dpoint_() + { + } + + template <typename G, typename C> + template <typename C2> inline - dpoint_<M,C>::dpoint_() + dpoint_<G,C>::dpoint_(const algebra::vec<dim,C2>& v) { + coord_ = v; } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>::dpoint_(C ind) + dpoint_<G,C>::dpoint_(C ind) { metal::bool_<(dim == 1)>::check(); coord_[0] = ind; } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>::dpoint_(C row, C col) + dpoint_<G,C>::dpoint_(C row, C col) { metal::bool_<(dim == 2)>::check(); coord_[0] = row; coord_[1] = col; } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>::dpoint_(C sli, C row, C col) + dpoint_<G,C>::dpoint_(C sli, C row, C col) { metal::bool_<(dim == 3)>::check(); coord_[0] = sli; @@ -209,44 +224,44 @@ coord_[2] = col; } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>::dpoint_(const literal::zero_t&) + dpoint_<G,C>::dpoint_(const literal::zero_t&) { coord_.set_all(0); } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>& - dpoint_<M,C>::operator=(const literal::zero_t&) + dpoint_<G,C>& + dpoint_<G,C>::operator=(const literal::zero_t&) { coord_.set_all(0); return *this; } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>::dpoint_(const literal::one_t&) + dpoint_<G,C>::dpoint_(const literal::one_t&) { metal::bool_<(dim == 1)>::check(); coord_[0] = 1; } - template <typename M, typename C> + template <typename G, typename C> inline - dpoint_<M,C>& - dpoint_<M,C>::operator=(const literal::one_t&) + dpoint_<G,C>& + dpoint_<G,C>::operator=(const literal::one_t&) { metal::bool_<(dim == 1)>::check(); coord_[0] = 1; return *this; } - template <typename M, typename C> + template <typename G, typename C> template <typename F> inline - dpoint_<M,C>::dpoint_(const Function_i2v<F>& f_) + dpoint_<G,C>::dpoint_(const Function_i2v<F>& f_) { mlc_converts_to(mln_result(F), C)::check(); const F& f = exact(f_); @@ -254,26 +269,26 @@ coord_[i] = f(i); } - template <typename M, typename C> + template <typename G, typename C> inline - void dpoint_<M,C>::set_all(C c) + void dpoint_<G,C>::set_all(C c) { for (unsigned i = 0; i < dim; ++i) coord_[i] = c; } - template <typename M, typename C> + template <typename G, typename C> template <typename Q> inline - dpoint_<M,C>::operator algebra::vec<M::dim, Q> () const + dpoint_<G,C>::operator algebra::vec<G::dim, Q> () const { return coord_; } - template <typename M, typename C> + template <typename G, typename C> inline - const algebra::vec<M::dim, C>& - dpoint_<M,C>::to_vec() const + const algebra::vec<G::dim, C>& + dpoint_<G,C>::to_vec() const { return coord_; } @@ -281,13 +296,13 @@ namespace util { - template <typename M, typename Cl, typename Cr> + template <typename G, typename Cl, typename Cr> bool - less_than< dpoint_<M,Cl>, - dpoint_<M,Cr> >::operator()(const dpoint_<M,Cl>& lhs, - const dpoint_<M,Cr>& rhs) const + less_than< dpoint_<G,Cl>, + dpoint_<G,Cr> >::operator()(const dpoint_<G,Cl>& lhs, + const dpoint_<G,Cr>& rhs) const { - enum { n = M::dim }; + enum { n = G::dim }; typedef less_than< algebra::vec<n,Cl>, algebra::vec<n,Cr> > less_t; static const less_t op = less_t(); return op(lhs.to_vec(), rhs.to_vec()); Index: mln/core/point2d.hh --- mln/core/point2d.hh (revision 2029) +++ mln/core/point2d.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 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 @@ -42,6 +42,12 @@ namespace mln { + /*! \brief Type alias for a point defined on the 2D square grid with + * integer coordinates. + */ + typedef point_<grid::square, int> point2d; + + namespace internal { @@ -50,56 +56,101 @@ template <typename C, typename E> struct site_const_impl< point_<grid::square, C>, E > { + C row() const; + C col() const; + C operator[](unsigned i) const; + private: + const E& exact_() const; + }; + + + // Specialization for point_<M,C>. + + template <typename C, typename E> + struct site_mutable_impl< point_<grid::square, C>, E > : + site_const_impl < point_<grid::square, C>, E > + { + C& row(); + C& col(); + C& operator[](unsigned i); + private: + typedef site_const_impl< point_<grid::square, C>, E > super; + E& exact_(); + }; + + + +# ifndef MLN_INCLUDE_ONLY + // Either unproxy() or to_site() can be used below. In the // former case, the unproxied features ind() because it is a // point_ or another proxy to a point_. - C row() const + + // site_const_impl + + template <typename C, typename E> + C + site_const_impl< point_<grid::square, C>, E >::row() const { - return internal::force_exact<const E>(*this).to_site().row(); + return exact_().to_site().row(); } - C col() const + + template <typename C, typename E> + C + site_const_impl< point_<grid::square, C>, E >::col() const { - return internal::force_exact<const E>(*this).to_site().col(); + return exact_().to_site().col(); } - C operator[](unsigned i) const + + template <typename C, typename E> + C + site_const_impl< point_<grid::square, C>, E >::operator[](unsigned i) const { mln_precondition(i < 2); - return internal::force_exact<const E>(*this).to_site()[i]; + return exact_().to_site()[i]; } - }; - - - // Specialization for point_<M,C>. template <typename C, typename E> - struct site_mutable_impl< point_<grid::square, C>, E > : - site_const_impl < point_<grid::square, C>, E > + const E& + site_const_impl< point_<grid::square, C>, E >::exact_() const { - private: - typedef site_const_impl< point_<grid::square, C>, E > super; - public: + return internal::force_exact<const E>(*this); + } - using super::row; - using super::col; + // site_mutable_impl - C& row() + template <typename C, typename E> + C& + site_mutable_impl< point_<grid::square, C>, E >::row() { - return internal::force_exact<E>(*this).to_site().row(); + return exact_().to_site().row(); } - C& col() + + template <typename C, typename E> + C& + site_mutable_impl< point_<grid::square, C>, E >::col() { - return internal::force_exact<E>(*this).to_site().col(); + return exact_().to_site().col(); } - }; - } // end of namespace mln::internal + template <typename C, typename E> + C& + site_mutable_impl< point_<grid::square, C>, E >::operator[](unsigned i) + { + mln_precondition(i < 2); + return exact_().to_site()[i]; + } + template <typename C, typename E> + E& + site_mutable_impl< point_<grid::square, C>, E >::exact_() + { + return internal::force_exact<E>(*this); + } +# endif // ! MLN_INCLUDE_ONLY - /*! \brief Type alias for a point defined on the 2D square grid with - * integer coordinates. - */ - typedef point_<grid::square, int> point2d; + } // end of namespace mln::internal } // end of namespace mln Index: mln/core/concept/status.txt --- mln/core/concept/status.txt (revision 0) +++ mln/core/concept/status.txt (revision 0) @@ -0,0 +1,10 @@ +obsolete replacement +----------------- -------------- +point -> gpoint +point_site -> pseudo_site + +dpoint -> gdpoint +delta_point_site -> + +point_iterator -> site_iterator +point_set -> site_set Index: mln/core/concept/gpoint.hh --- mln/core/concept/gpoint.hh (revision 2029) +++ mln/core/concept/gpoint.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 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 @@ -25,16 +25,16 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_CORE_CONCEPT_POINT_HH -# define MLN_CORE_CONCEPT_POINT_HH +#ifndef MLN_CORE_CONCEPT_GPOINT_HH +# define MLN_CORE_CONCEPT_GPOINT_HH -/*! \file mln/core/concept/point.hh +/*! \file mln/core/concept/gpoint.hh * - * \brief Definition of the concept of mln::Point. + * \brief Definition of the concept of mln::Gpoint. */ -# include <mln/core/concept/point_site.hh> -# include <mln/core/concept/dpoint.hh> +# include <mln/core/concept/object.hh> +# include <mln/core/concept/gdpoint.hh> # include <mln/value/concept/scalar.hh> @@ -42,14 +42,43 @@ { // Fwd decl. - template <typename E> struct Point; + template <typename E> struct Gpoint; - // Point category flag type. + + namespace trait + { + + template < typename P, typename D > + struct set_binary_< op::plus, + mln::Gpoint, P, mln::Gdpoint, D > + { + typedef P ret; + }; + + template < typename P, typename D > + struct set_binary_< op::minus, + mln::Gpoint, P, mln::Gdpoint, D > + { + typedef P ret; + }; + + template < typename L, typename R > + struct set_binary_< op::minus, + mln::Gpoint, L, mln::Gpoint, R > + { + typedef mln_delta(L) ret; + }; + + } // end of namespace mln::trait + + + + // Gpoint category flag type. template <> - struct Point<void> + struct Gpoint<void> { - typedef Point_Site<void> super; + typedef Object<void> super; }; @@ -60,20 +89,111 @@ * For instance, mln::point2d is the type of elements defined on the * discrete square grid of the 2D plane. */ - template <typename P> - struct Point : public Point_Site + template <typename E> + struct Gpoint : public Object<E> { - /*! \brief The associated point type is itself. + /* + typedef grid; + typedef delta; + typedef vec; + const vec& to_vec() const */ - typedef P point; + protected: + Gpoint(); + }; + + - /*! \brief It is a Point so it returns itself. + /*! \brief Equality comparison between a couple of grid point \p lhs + * and \p rhs. + * + * \param[in] lhs A first grid point. + * \param[in] rhs A second grid point. + * + * \pre Both \p lhs and \p rhs have to be defined on the same + * topology; otherwise this test does not compile. + * + * \return True if both grid points have the same + * coordinates, otherwise false. + * + * \relates mln::Gpoint */ - const P& to_point() const; + template <typename L, typename R> + bool operator==(const Gpoint<L>& lhs, const Gpoint<R>& rhs); - protected: - Point(); - }; + + /*! \brief Difference between a couple of grid point \p lhs and \p + * rhs. + * + * \param[in] lhs A first grid point. + * \param[in] rhs A second grid point. + * + * \warning There is no type promotion in milena so the client + * has to make sure that both points are defined with the same + * type of coordinates. + * + * \pre Both \p lhs and \p rhs have to be defined on the same + * topology and with the same type of coordinates; otherwise this + * test does not compile. + * + * \post The result, \p dp, is such as \p lhs == \p rhs + \p dp. + * + * \return A delta point (temporary object). + * + * \relates mln::Gpoint + * \see mln::Gdpoint + */ + template <typename L, typename R> + mln_delta(L) + operator-(const Gpoint<L>& lhs, const Gpoint<R>& rhs); + + + /*! \brief Add a delta-point \p rhs to a grid point \p lhs. + * + * \param[in] p A grid point. + * \param[in] dp A delta-point. + * + * The type of \p dp has to compatible with the type of \p p. + * + * \return A point (temporary object). + * + * \relates mln::Gpoint + * \see mln::Gdpoint + */ + template <typename P, typename D> + P + operator+(const Gpoint& p, const Gdpoint<D>& dp); + + + + /*! \brief Substract a delta-point \p rhs to a grid point \p lhs. + * + * \param[in] p A grid point. + * \param[in] dp A delta-point. + * + * The type of \p dp has to compatible with the type of \p p. + * + * \return A point (temporary object). + * + * \see mln::Gdpoint + * \see mln::Gdpoint + */ + template <typename P, typename D> + P + operator-(const Gpoint& p, const Gdpoint<D>& dp); + + + /*! \brief Print a grid point \p p into the output stream \p ostr. + * + * \param[in,out] ostr An output stream. + * \param[in] p A grid point. + * + * \return The modified output stream \p ostr. + * + * \relates mln::Gpoint + */ + template <typename P> + std::ostream& operator<<(std::ostream& ostr, const Gpoint& p); /*! \brief Shift a point \p by a delta-point \p dp. @@ -85,10 +205,10 @@ * \pre The type of \p dp has to be compatible with the type of \p * p. * - * \relates mln::Point + * \relates mln::Gpoint */ template <typename P, typename D> - P& operator+=(Point& p, const Dpoint<D>& dp); + P& operator+=(Gpoint& p, const Gdpoint<D>& dp); /*! \brief Shift a point \p by the negate of a delta-point \p dp. @@ -100,10 +220,10 @@ * \pre The type of \p dp has to be compatible with the type of \p * p. * - * \relates mln::Point + * \relates mln::Gpoint */ template <typename P, typename D> - P& operator-=(Point& p, const Dpoint<D>& dp); + P& operator-=(Gpoint& p, const Gdpoint<D>& dp); /*! \brief Divise a point \p by a scalar \p s. * @@ -111,64 +231,101 @@ * \param[in] dp A scalar. * \return A reference to the point \p p once divised by \p s. * - * \relates mln::Point + * \relates mln::Gpoint */ template <typename P, typename D> - P& operator/(Point& p, const value::Scalar<D>& dp); + P operator/(Gpoint& p, const value::Scalar<D>& dp); // FIXME : add operators and traits? + + # ifndef MLN_INCLUDE_ONLY - template <typename P> + // Gpoint + + template <typename E> inline - Point::Point() + Gpoint<E>::Gpoint() { + typedef mln_grid(E) grid; + typedef mln_delta(E) delta; + typedef mln_vec(E) vec; + const vec& (E::*m)() const = & E::to_vec; + m = 0; } - template <typename P> + // Operators. + + template <typename L, typename R> inline - const P& - Point::to_point() const + bool operator==(const Gpoint<L>& lhs, const Gpoint<R>& rhs) { - return exact(*this); + mlc_equal(mln_grid(L), mln_grid(R))::check(); + return exact(lhs).to_vec() == exact(rhs).to_vec(); + } + + template <typename L, typename R> + inline + mln_delta(L) // FIXME: promote! + operator-(const Gpoint<L>& lhs, const Gpoint<R>& rhs) + { + mlc_equal(mln_grid(L), mln_grid(R))::check(); + mln_delta(L) tmp = exact(lhs).to_vec() - exact(rhs).to_vec(); + mln_postcondition(rhs + tmp == lhs); + return tmp; } template <typename P, typename D> inline - P& operator+=(Point& p_, const Dpoint<D>& dp_) + P // FIXME: promote! + operator+(const Gpoint& p, const Gdpoint<D>& dp) { - P& p = exact(p_); - const D& dp = exact(dp_); - // FIXME: Use to_vec()! - for (unsigned i = 0; i < P::dim; ++i) - p[i] += dp[i]; - return p; + mlc_equal(mln_grid(P), mln_grid(D))::check(); + P tmp = exact(p).to_vec() + exact(dp).to_vec(); + return tmp; } template <typename P, typename D> inline - P& operator-=(Point& p_, const Dpoint<D>& dp_) + P // FIXME: promote! + operator-(const Gpoint& p, const Gdpoint<D>& dp) { - P& p = exact(p_); - const D& dp = exact(dp_); - // FIXME: Use to_vec()! - for (unsigned i = 0; i < P::dim; ++i) - p[i] -= dp[i]; - return p; + mlc_equal(mln_grid(P), mln_grid(D))::check(); + P tmp = exact(p).to_vec() - exact(dp).to_vec(); + return tmp; } + template <typename P> + inline + std::ostream& operator<<(std::ostream& ostr, const Gpoint& p) + { + return ostr << exact(p).to_vec(); + } template <typename P, typename D> inline - P& - operator/(Point& p_, const value::Scalar<D>& s_) + P& operator+=(Gpoint& p, const Gdpoint<D>& dp) + { + mlc_equal(mln_grid(P), mln_grid(D))::check(); + return exact(p) = p + dp; + } + + template <typename P, typename D> + inline + P& operator-=(Gpoint& p, const Gdpoint<D>& dp) + { + mlc_equal(mln_grid(P), mln_grid(D))::check(); + return exact(p) = p - dp; + } + + + template <typename P, typename S> + inline + P + operator/(Gpoint& p, const value::Scalar<S>& s_) { - P& p = exact(p_); - const D& s = exact(s_); - for (unsigned i = 0; i < P::dim; ++i) - p[i] /= s; - return p; + return p.to_vec() / s_; } # endif // ! MLN_INCLUDE_ONLY @@ -177,4 +334,4 @@ -#endif // ! MLN_CORE_CONCEPT_POINT_HH +#endif // ! MLN_CORE_CONCEPT_GPOINT_HH Index: mln/core/concept/gdpoint.hh --- mln/core/concept/gdpoint.hh (revision 2029) +++ mln/core/concept/gdpoint.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 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 @@ -25,12 +25,12 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_CORE_CONCEPT_DELTA_POINT_SITE_HH -# define MLN_CORE_CONCEPT_DELTA_POINT_SITE_HH +#ifndef MLN_CORE_CONCEPT_GDPOINT_HH +# define MLN_CORE_CONCEPT_GDPOINT_HH /*! \file mln/core/concept/delta_point_site.hh * - * \brief Definition of the concept of mln::Delta_Point_Site. + * \brief Definition of the concept of mln::Gdpoint. */ # include <mln/core/concept/object.hh> @@ -42,7 +42,7 @@ { // Fwd decl. - template <typename E> struct Delta_Point_Site; + template <typename E> struct Gdpoint; @@ -51,16 +51,16 @@ template < typename L, typename R > struct set_binary_< op::plus, - mln::Delta_Point_Site, L, mln::Delta_Point_Site, R > + mln::Gdpoint, L, mln::Gdpoint, R > { - typedef mln_dpoint(L) ret; + typedef L ret; }; template < typename L, typename R > struct set_binary_< op::minus, - mln::Delta_Point_Site, L, mln::Delta_Point_Site, R > + mln::Gdpoint, L, mln::Gdpoint, R > { - typedef mln_dpoint(L) ret; + typedef L ret; }; } // end of namespace mln::trait @@ -69,7 +69,7 @@ /// Delta point site category flag type. template <> - struct Delta_Point_Site<void> + struct Gdpoint<void> { typedef Object<void> super; }; @@ -78,24 +78,18 @@ /*! \brief FIXME: Doc! */ template <typename E> - struct Delta_Point_Site : public Object<E> + struct Gdpoint : public Object<E> { - typedef Delta_Point_Site<void> category; + typedef Gdpoint<void> category; /* - enum { dim }; - typedef mesh; - - typedef point; - typedef dpoint; - typedef coord; - - const dpoint& to_dpoint() const; - coord operator[](unsigned i) const; + typedef grid; + typedef vec; + const vec& to_vec() const; */ protected: - Delta_Point_Site(); + Gdpoint(); }; @@ -104,25 +98,21 @@ template <typename D> std::ostream& - operator<<(std::ostream& ostr, const Delta_Point_Site<D>& dp); - + operator<<(std::ostream& ostr, const Gdpoint<D>& dp); - template <typename L, typename R> - bool - operator==(const Delta_Point_Site<L>& lhs, const Delta_Point_Site<R>& rhs); template <typename L, typename R> bool - operator<(const Delta_Point_Site<L>& lhs, const Delta_Point_Site<R>& rhs); + operator==(const Gdpoint<L>& lhs, const Gdpoint<R>& rhs); template <typename L, typename R> - mln_dpoint(L) // FIXME: promote! - operator+(const Delta_Point_Site<L>& lhs, const Delta_Point_Site<R>& rhs); + L // FIXME: promote! + operator+(const Gdpoint<L>& lhs, const Gdpoint<R>& rhs); template <typename L, typename R> - mln_dpoint(L) // FIXME: promote! - operator-(const Delta_Point_Site<L>& lhs, const Delta_Point_Site<R>& rhs); + L // FIXME: promote! + operator-(const Gdpoint<L>& lhs, const Gdpoint<R>& rhs); @@ -131,88 +121,48 @@ template <typename E> inline - Delta_Point_Site<E>::Delta_Point_Site() + Gdpoint<E>::Gdpoint() { - int dim = E::dim; - mln_invariant(dim > 0); - dim = 0; - typedef mln_mesh(E) mesh; - typedef mln_point(E) point; - typedef mln_dpoint(E) dpoint; - typedef mln_coord(E) coord; - const dpoint& (E::*m1)() const = & E::to_dpoint; - m1 = 0; - coord (E::*m2)(unsigned i) const = & E::operator[]; - m2 = 0; + typedef mln_grid(E) grid; + typedef mln_vec(E) vec; + const vec& (E::*m)() const = & E::to_vec; + m = 0; } template <typename D> inline - std::ostream& operator<<(std::ostream& ostr, const Delta_Point_Site<D>& dp_) + std::ostream& operator<<(std::ostream& ostr, const Gdpoint<D>& dp) { - const D& dp = exact(dp_); - ostr << '('; - for (unsigned i = 0; i < D::dim; ++i) - ostr << dp[i] << (i == D::dim - 1 ? ')' : ','); - return ostr; + return ostr << exact(dp).to_vec(); } template <typename L, typename R> inline - bool operator==(const Delta_Point_Site<L>& lhs_, const Delta_Point_Site<R>& rhs_) + bool operator==(const Gdpoint<L>& lhs, const Gdpoint<R>& rhs) { - mln::metal::bool_<(int(L::dim) == int(R::dim))>::check(); - const L& lhs = exact(lhs_); - const R& rhs = exact(rhs_); - for (unsigned i = 0; i < L::dim; ++i) - if (lhs[i] != rhs[i]) - return false; - return true; - } - - template <typename L, typename R> - inline - bool operator<(const Delta_Point_Site<L>& lhs_, const Delta_Point_Site<R>& rhs_) - { - mln::metal::bool_<(int(L::dim) == int(R::dim))>::check(); - const L& lhs = exact(lhs_); - const R& rhs = exact(rhs_); - for (unsigned i = 0; i < L::dim; ++i) - { - if (lhs[i] == rhs[i]) - continue; - return lhs[i] < rhs[i]; - } - return false; + mlc_equal(mln_grid(L), mln_grid(R))::check(); + return exact(lhs).to_vec() == exact(rhs).to_vec(); } template <typename L, typename R> inline - mln_dpoint(L) // FIXME: promote! - operator+(const Delta_Point_Site<L>& lhs_, const Delta_Point_Site<R>& rhs_) + L // FIXME: promote! + operator+(const Gdpoint<L>& lhs, const Gdpoint<R>& rhs) { - mln::metal::bool_<(int(L::dim) == int(R::dim))>::check(); - const L& lhs = exact(lhs_); - const R& rhs = exact(rhs_); - mln_dpoint(L) tmp; - for (unsigned i = 0; i < L::dim; ++i) - tmp[i] = lhs[i] + rhs[i]; + mlc_equal(mln_grid(L), mln_grid(R))::check(); + L tmp = exact(lhs).to_vec() + exact(rhs).to_vec(); return tmp; } template <typename L, typename R> inline - mln_dpoint(L) // FIXME: promote! - operator-(const Delta_Point_Site<L>& lhs_, const Delta_Point_Site<R>& rhs_) + L // FIXME: promote! + operator-(const Gdpoint<L>& lhs, const Gdpoint<R>& rhs) { - mln::metal::bool_<(int(L::dim) == int(R::dim))>::check(); - const L& lhs = exact(lhs_); - const R& rhs = exact(rhs_); - mln_dpoint(L) tmp; - for (unsigned i = 0; i < L::dim; ++i) - tmp[i] = lhs[i] - rhs[i]; + mlc_equal(mln_grid(L), mln_grid(R))::check(); + L tmp = exact(lhs).to_vec() - exact(rhs).to_vec(); return tmp; } @@ -221,4 +171,4 @@ } // end of namespace mln -#endif // ! MLN_CORE_CONCEPT_DELTA_POINT_SITE_HH +#endif // ! MLN_CORE_CONCEPT_GDPOINT_HH

16 years, 6 months

Re: [Olena-patches] [Olena] #34: New algorithm: Liquid Rescale

by Olena

#34: New algorithm: Liquid Rescale --------------------------+------------------------------------------------- Reporter: levill_r | Owner: Olena Team Type: enhancement | Status: new Priority: minor | Milestone: Olena 1.1 Component: Milena | Version: 1.0 Resolution: | Keywords: --------------------------+------------------------------------------------- Changes (by levill_r): * version: => 1.0 * milestone: => Olena 1.1 -- Ticket URL: <https://trac.lrde.org/olena/ticket/34#comment:2> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 6 months

[Olena] #127: Generalize the definition of the Sobel gradient

by Olena

#127: Generalize the definition of the Sobel gradient -------------------------+-------------------------------------------------- Reporter: levill_r | Owner: Olena Team Type: enhancement | Status: new Priority: trivial | Milestone: Component: Milena | Version: 1.0 Keywords: | -------------------------+-------------------------------------------------- For the moment (rev. 1656), the Sobel gradient only works on 2-D images. We could generalize its definition to n-D (regular) images. For instance, a 3-D version is mentioned in http://www.aravind.ca/cs788h_Final_Project/gradient_estimators.htm. -- Ticket URL: <https://trac.lrde.org/olena/ticket/127> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image library.

16 years, 6 months

Re: [Olena-patches] [Olena] #16: Port Olena 0.11 tests to Olena 1.0 and 2.0

by Olena

#16: Port Olena 0.11 tests to Olena 1.0 and 2.0 -----------------------+---------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: new Priority: minor | Milestone: Olena 1.1 Component: Olena | Version: 1.0 Resolution: | Keywords: test suite 0.10 -----------------------+---------------------------------------------------- Changes (by levill_r): * milestone: => Olena 1.1 -- Ticket URL: <https://trac.lrde.org/olena/ticket/16#comment:2> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 6 months

Re: [Olena-patches] [Olena] #15: Set up a build farm framework, or adjust Olena 0.11's one

by Olena

#15: Set up a build farm framework, or adjust Olena 0.11's one -----------------------+---------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: closed Priority: minor | Milestone: Component: Olena | Version: 1.0 Resolution: fixed | Keywords: test suite framework uttk cppunit 0.10 -----------------------+---------------------------------------------------- Changes (by levill_r): * status: new => closed * resolution: => fixed Comment: Done: a !BuildBot has been set up for Olena (https://buildfarm.lrde.org/buildfarm/oln/). -- Ticket URL: <https://trac.lrde.org/olena/ticket/15#comment:2> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 6 months

Re: [Olena-patches] [Olena] #80: Olena 1.0 User Documentation

by Olena

#80: Olena 1.0 User Documentation -----------------------+---------------------------------------------------- Reporter: levill_r | Owner: Olena Team Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Resolution: | Keywords: vaucanson doc -----------------------+---------------------------------------------------- Old description: > How to make a nice '''user''' documentation for Olena 1.0, using Doxygen? > or LaTeX? or anything else? > > This documentation shall be > * readable, > * with no description of the internals (either `namespace internal` or > places tagged as such). > > Ask the Vaucanson Team for some hints and/or pointers. New description: How to make a nice '''user''' documentation for Olena 1.0, using Doxygen? or use a new tool, like [http://www.doxys.dk/ Doxys] ? or LaTeX? or anything else? This documentation shall be * readable, * with no description of the internals (either `namespace internal` or places tagged as such). Ask the Vaucanson Team for some hints and/or pointers. Comment (by levill_r): Merge with #20. -- Ticket URL: <https://trac.lrde.org/olena/ticket/80#comment:5> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 6 months

← Newer
1
...
6
7
8
9
10
11
12
13
14
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches June 2008