- Olena-patches

1773: Partially check point sets compatibility.
by Roland Levillain 12 Mar '08

12 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Partially check point sets compatibility. * tests/core/point_set_compatibility.cc: New test. * tests/core/Makefile.am (check_PROGRAMS): Add point_set_compatibility. (point_set_compatibility_SOURCES): New. Makefile.am | 2 + point_set_compatibility.cc | 89 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+) Index: tests/core/point_set_compatibility.cc --- tests/core/point_set_compatibility.cc (revision 0) +++ tests/core/point_set_compatibility.cc (revision 0) @@ -0,0 +1,89 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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. + +/// \file tests/core/point_set_compatibility.cc +/// \brief Tests on the compatibility of some point sites with some +/// point sets (and their iterators). + +#include <mln/core/point2d.hh> + +#include <mln/core/p_array.hh> +#include <mln/core/graph_psite.hh> +#include <mln/core/p_graph_piter.hh> + + +int main() +{ + using namespace mln; + + /*--------------------------------------------------------. + | Compatibility of mln::graph_psite with mln::p_array and | + | mln::p_array_piter. | + `--------------------------------------------------------*/ + + // Graph. + + // Points associated to nodes. + std::vector<point2d> points; + points.push_back(make::point2d(0,0)); // Point associated to node 0. + points.push_back(make::point2d(2,2)); // Point associated to node 1. + points.push_back(make::point2d(0,4)); // Point associated to node 2. + points.push_back(make::point2d(4,3)); // Point associated to node 3. + points.push_back(make::point2d(4,4)); // Point associated to node 4. + + // Edges. + util::graph<point2d> g; + // Populate the graph with nodes. + for (unsigned i = 0; i < points.size(); ++i) + g.add_node (points[i]); + // Populate the graph with edges. + g.add_edge(0, 1); + g.add_edge(1, 2); + g.add_edge(1, 3); + g.add_edge(3, 4); + g.add_edge(4, 2); + + + // Graph point set. + p_graph<point2d> pg(g); + + + // Array of graph point sites. + typedef graph_psite<point2d> gpsite_t; + p_array<gpsite_t> pa; + + + // Tests: copying all psites from PG to PA. + p_graph_fwd_piter_<point2d> p(pg); + for_all (p) + pa.append (p); + + // Test: create and use an iterator over PA. + p_array_fwd_piter_<gpsite_t> p2(pa); + for_all (p2) + std::cout << p2 << std::endl; +} Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 1772) +++ tests/core/Makefile.am (working copy) @@ -22,6 +22,7 @@ p_queue \ p_queue_fast \ p_runs \ + point_set_compatibility \ rle_image \ sparse_image \ t_image \ @@ -46,6 +47,7 @@ p_queue_SOURCES = p_priority_queue_fast.cc p_queue_fast_SOURCES = p_priority_queue_fast.cc p_runs_SOURCES = p_runs.cc +point_set_compatibility_SOURCES = point_set_compatibility.cc rle_image_SOURCES = rle_image.cc sparse_image_SOURCES = sparse_image.cc t_image_SOURCES = t_image.cc

1 0

1772: Add backward iterators on line graph windows and neighborhoods.
by Roland Levillain 12 Mar '08

12 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add backward iterators on line graph windows and neighborhoods. * mln/core/line_graph_window_piter.hh: Add more documentation. (mln::line_graph_window_fwd_piter::point): Set typedef to P. (mln::line_graph_window_fwd_piter::to_point) (mln::line_graph_window_fwd_piter::operator[](unsigned)): Adjust return types. (mln::line_graph_window_fwd_piter::operator point): Remove. (line_graph_window_fwd_piter(const W&, const Point_Site<Pref>&)) (line_graph_window_fwd_piter::invalidate) Adjust to the new interface of mln::p_line_graph. (line_graph_window_fwd_piter::update_): Don't update member p_. (operator<<(std::ostream&, const line_graph_window_fwd_piter&)): Print the associated psite, not the associated point. (mln::line_graph_window_bkd_piter) (operator<<(std::ostream&, const line_graph_window_bkd_piter&)): New. * mln/core/line_graph_neighborhood_piter.hh Add more documentation. (mln::line_graph_neighborhood_fwd_piter::point): Set typedef to P. (mln::line_graph_neighborhood_fwd_piter::to_point) (mln::line_graph_neighborhood_fwd_piter::operator[](unsigned)): Adjust return types. (mln::line_graph_neighborhood_fwd_piter::operator point): Remove. (line_graph_neighborhood_fwd_piter(const N&, const Point_Site<Pref>&): (mln::line_graph_neighborhood_fwd_piter::invalidate) Adjust to the new interface of mln::p_line_graph. (mln::line_graph_neighborhood_fwd_piter::update_): Don't update member p_. (operator<<(std::ostream&,const line_graph_neighborhood_fwd_piter&)): Print the associated psite, not the associated point. (mln::line_graph_neighborhood_bkd_piter) (operator<<(std::ostream&,const line_graph_neighborhood_bkd_piter&)): New. line_graph_neighborhood_piter.hh | 310 ++++++++++++++++++++++++++++++++++----- line_graph_window_piter.hh | 296 +++++++++++++++++++++++++++++++++---- 2 files changed, 543 insertions(+), 63 deletions(-) Index: mln/core/line_graph_window_piter.hh --- mln/core/line_graph_window_piter.hh (revision 1771) +++ mln/core/line_graph_window_piter.hh (working copy) @@ -37,9 +37,6 @@ - mln::graph_neighborhood_fwd_piter - mln::line_graph_window_fwd_piter - mln::line_graph_neighborhood_fwd_piter. - - and later (when they get implemented): - - mln::graph_window_bkd_piter - mln::graph_neighborhood_bkd_piter - mln::line_graph_window_bkd_piter @@ -48,9 +45,6 @@ # include <mln/core/concept/point_iterator.hh> # include <mln/core/p_line_graph.hh> # include <mln/core/line_graph_psite.hh> -# include <mln/core/point_pair.hh> - -/* FIXME: Doc. */ /* FIXME: Due to the poor interface of mln::p_line_graph and mln::util::graph, we show to much implementation details here. @@ -67,6 +61,7 @@ | line_graph_window_fwd_piter. | `---------------------------------*/ + /// \brief Forward iterator on line graph window. template <typename P> class line_graph_window_fwd_piter : public Point_Iterator< line_graph_window_fwd_piter > // or Iterator<...>? @@ -75,38 +70,53 @@ typedef Point_Iterator< self_ > super_; public: - typedef line_graph_psite psite; - + // Make definitions from super class available. enum { dim = P::dim }; - // FIXME: Dummy value. - typedef void mesh; - typedef point_pair point; + typedef line_graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; // FIXME: Dummy typedef. typedef void dpoint; - typedef mln_coord(point) coord; + // FIXME: Dummy typedef. + typedef void mesh; public: + /// Construction. + /// \{ template <typename W, typename Pref> line_graph_window_fwd_piter(const W& win, const Point_Site<Pref>& p_ref); + /// \} + /// Manipulation. + /// \{ + /// Test if the iterator is valid. bool is_valid() const; + /// Invalidate the iterator. void invalidate(); + /// Start an iteration. void start(); + /// Go to the next point. void next_(); + /// Is the piter adjacent or equal to the reference point? bool adjacent_or_equal_to_p_ref_() const; /// Update the internal data of the iterator. void update_(); + /// \} + /// Conversion and accessors. + /// \{ + /// Reference to the corresponding point. const point& to_point() const; + /// Reference to the corresponding point site. const psite& to_psite() const; - - operator point() const; + /// Convert the iterator into a line graph psite. operator psite() const; - /// Return the \a i th coordinate of the (iterated) point. + /// Read-only access to the \a i-th coordinate. coord operator[](unsigned i) const; + /// \} private: /// The ``central'' psite of the window. @@ -116,6 +126,8 @@ /// The psite corresponding to this iterator. psite psite_; /// The point corresponding to this iterator. + /* FIXME: Dummy value. To be removed as soon as the conversion + from psite to point is no longer mandatory. */ point p_; }; @@ -133,11 +145,93 @@ | line_graph_window_bkd_piter. | `---------------------------------*/ - // FIXME: Implement line_graph_window_bkd_piter. + /// \brief Backward iterator on line graph window. + template <typename P> + class line_graph_window_bkd_piter : + public Point_Iterator< line_graph_window_bkd_piter > // or Iterator<...>? + { + typedef line_graph_window_bkd_piter self_; + typedef Point_Iterator< self_ > super_; + + public: + // Make definitions from super class available. + enum { dim = P::dim }; + + typedef line_graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; + // FIXME: Dummy typedef. + typedef void dpoint; + // FIXME: Dummy typedef. + typedef void mesh; + + public: + /// Construction. + /// \{ + template <typename W, typename Pref> + line_graph_window_bkd_piter(const W& win, const Point_Site<Pref>& p_ref); + /// \} + + /// Manipulation. + /// \{ + /// Test if the iterator is valid. + bool is_valid() const; + /// Invalidate the iterator. + void invalidate(); + /// Start an iteration. + void start(); + + /// Go to the next point. + void next_(); + /// Is the piter adjacent or equal to the reference point? + bool adjacent_or_equal_to_p_ref_() const; + /// Update the internal data of the iterator. + void update_(); + /// \} + + /// Conversion and accessors. + /// \{ + /// Reference to the corresponding point. + const point& to_point() const; + /// Reference to the corresponding point site. + const psite& to_psite() const; + /// Convert the iterator into a line graph psite. + operator psite() const; + + /// Read-only access to the \a i-th coordinate. + coord operator[](unsigned i) const; + /// \} + + private: + /// The ``central'' psite of the window. + const psite& p_ref_; + /// An internal iterator on the set of edges of the underlying graph. + util::edge_id id_; + /// The psite corresponding to this iterator. + psite psite_; + /// The point corresponding to this iterator. + /* FIXME: Dummy value. To be removed as soon as the conversion + from psite to point is no longer mandatory. */ + point p_; + }; + + /* FIXME: This hand-made delegation is painful. We should rely on + the general mechanism provided by Point_Site. But then again, we + need to refine/adjust the interface of Point_Site w.r.t. the + mandatory conversions to points. */ + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const line_graph_window_bkd_piter& p); + # ifndef MLN_INCLUDE_ONLY + /*---------------------------------. + | line_graph_window_fwd_piter. | + `---------------------------------*/ + // FIXME: Currently, argument win is ignored. template <typename P> template <typename W, typename Pref> @@ -146,8 +240,7 @@ const Point_Site<Pref>& p_ref) : p_ref_(exact(p_ref).to_psite()), // Initialize psite_ to a dummy value. - psite_(p_ref_.plg(), p_ref_.plg().nlines()), - p_() + psite_() { // Invalidate id_. invalidate(); @@ -169,7 +262,7 @@ void line_graph_window_fwd_piter::invalidate() { - id_ = p_ref_.plg().gr_.nedges(); + id_ = -1; } template <typename P> @@ -245,16 +338,11 @@ { // Update psite_. psite_ = line_graph_psite(p_ref_.plg(), id_); - // Update p_. - // FIXME: These repeated assignments might be very costly. - /* FIXME: Likewise, it's hard to read. Simplify accesses to the graph. */ - p_ = point(p_ref_.plg().gr_.node_data(p_ref_.plg().gr_.edge(id_).n1()), - p_ref_.plg().gr_.node_data(p_ref_.plg().gr_.edge(id_).n2())); } template <typename P> inline - const point_pair& + const P& line_graph_window_fwd_piter::to_point() const { return p_; @@ -270,15 +358,161 @@ template <typename P> inline - line_graph_window_fwd_piter::operator point_pair() const + line_graph_window_fwd_piter::operator line_graph_psite () const { mln_precondition(is_valid()); + return psite_; + } + + template <typename P> + inline + mln_coord(P) + line_graph_window_fwd_piter::operator[](unsigned i) const + { + assert(i < dim); + return p_[i]; + } + + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const line_graph_window_fwd_piter& p) + { + return ostr << p.to_psite(); + } + + + /*---------------------------------. + | line_graph_window_bkd_piter. | + `---------------------------------*/ + + // FIXME: Currently, argument win is ignored. + template <typename P> + template <typename W, typename Pref> + inline + line_graph_window_bkd_piter::line_graph_window_bkd_piter(const W& /* win */, + const Point_Site<Pref>& p_ref) + : p_ref_(exact(p_ref).to_psite()), + // Initialize psite_ to a dummy value. + psite_() + { + // Invalidate id_. + invalidate(); + } + + template <typename P> + inline + bool + line_graph_window_bkd_piter::is_valid() const + { + // FIXME: We depend too much on the implementation of util::graph + // here. The util::graph should provide the service to abstract + // these manipulations. + return id_ < p_ref_.plg().gr_.nedges(); + } + + template <typename P> + inline + void + line_graph_window_bkd_piter::invalidate() + { + id_ = -1; + } + + template <typename P> + inline + void + line_graph_window_bkd_piter::start() + { + id_ = p_ref_.plg().gr_.nedges() - 1; + if (!adjacent_or_equal_to_p_ref_()) + next_(); + /* FIXME: This is redundant with the end of next_(), but we might + change the implementation of start_() when we'll fix it later, + and no longer use next_(). */ + if (is_valid()) + update_(); + } + + template <typename P> + inline + void + line_graph_window_bkd_piter::next_() + { + /* FIXME: This is inefficient. The graph structure should be able + to produce the set of adjacent edges fast. Boost Graphs + probably provides adequates structures to fetch these + neighbors in constant time. */ + /* FIXME: Moreover, the behavior of next shall depend on the + window, which is not the case now! (Currently, next_() behaves + as win was always an elementary window.) */ + do + --id_; + while (is_valid() && !adjacent_or_equal_to_p_ref_()); + if (is_valid()) + update_(); + } + + template <typename P> + inline + bool + line_graph_window_bkd_piter::adjacent_or_equal_to_p_ref_() const + { + // Check wether the iterator points to P_REF_. + if (id_ == p_ref_.id()) + return true; + + // Check whether the iterator is among the neighbors of P_REF_. + { + // Paranoid assertion. + assert (p_ref_.id() < p_ref_.plg().gr_.nedges()); + /* FIXME: We should have a convenient shortcut for these + repetitive accesses to p_ref_.plg().gr_ (e.g., a method gr() + or g() in this class. */ + const typename p_line_graph::graph& gr = p_ref_.plg().gr_; + // Check whether the edge this iterator points to is adjacent to + // the one p_ref points to, by comparing their ajacent nodes. + /* FIXME: This is too low-level. Yet another service the graph + // should provide. */ + if (gr.edge(id_).n1() == gr.edge(p_ref_.id()).n1() || + gr.edge(id_).n1() == gr.edge(p_ref_.id()).n2() || + gr.edge(id_).n2() == gr.edge(p_ref_.id()).n1() || + gr.edge(id_).n2() == gr.edge(p_ref_.id()).n2()) + return true; + } + + // Otherwise, the iterator is not adjacent to P_REF_. + return false; + } + + template <typename P> + inline + void + line_graph_window_bkd_piter::update_() + { + // Update psite_. + psite_ = line_graph_psite(p_ref_.plg(), id_); + } + + template <typename P> + inline + const P& + line_graph_window_bkd_piter::to_point() const + { return p_; } template <typename P> inline - line_graph_window_fwd_piter::operator line_graph_psite () const + const line_graph_psite& + line_graph_window_bkd_piter::to_psite() const + { + return psite_; + } + + template <typename P> + inline + line_graph_window_bkd_piter::operator line_graph_psite () const { mln_precondition(is_valid()); return psite_; @@ -286,8 +520,8 @@ template <typename P> inline - mln_coord(point_pair) - line_graph_window_fwd_piter::operator[](unsigned i) const + mln_coord(P) + line_graph_window_bkd_piter::operator[](unsigned i) const { assert(i < dim); return p_[i]; @@ -296,9 +530,9 @@ template <typename P> inline std::ostream& - operator<<(std::ostream& ostr, const line_graph_window_fwd_piter& p) + operator<<(std::ostream& ostr, const line_graph_window_bkd_piter& p) { - return ostr << p.to_point(); + return ostr << p.to_psite(); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/line_graph_neighborhood_piter.hh --- mln/core/line_graph_neighborhood_piter.hh (revision 1771) +++ mln/core/line_graph_neighborhood_piter.hh (working copy) @@ -29,7 +29,7 @@ # define MLN_CORE_LINE_GRAPH_NEIGHBORHOOD_PITER_HH /// \file mln/core/line_graph_neighborhood_piter.hh -/// \brief Definition of a point iterator on a line_graph neighborhood. +/// \brief Definition of a point iterator on a line graph neighborhood. /* FIXME: Factor those classes: @@ -37,9 +37,6 @@ - mln::graph_neighborhood_fwd_piter - mln::line_graph_window_fwd_piter - mln::line_graph_neighborhood_fwd_piter. - - and later (when they get implemented): - - mln::graph_window_bkd_piter - mln::graph_neighborhood_bkd_piter - mln::line_graph_window_bkd_piter @@ -48,9 +45,6 @@ # include <mln/core/concept/point_iterator.hh> # include <mln/core/p_line_graph.hh> # include <mln/core/line_graph_psite.hh> -# include <mln/core/point_pair.hh> - -/* FIXME: Doc. */ /* FIXME: Due to the poor interface of mln::p_line_graph and mln::util::graph, we show to much implementation details here. @@ -67,6 +61,7 @@ | line_graph_neighborhood_fwd_piter. | `---------------------------------------*/ + /// \brief Backward iterator on line graph neighborhood. template <typename P> class line_graph_neighborhood_fwd_piter : public Point_Iterator< line_graph_neighborhood_fwd_piter > // or Iterator<...>? @@ -75,39 +70,55 @@ typedef Point_Iterator< self_ > super_; public: - typedef line_graph_psite psite; - + // Make definitions from super class available. enum { dim = P::dim }; - // FIXME: Dummy value. - typedef void mesh; - typedef point_pair point; + typedef line_graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; // FIXME: Dummy typedef. typedef void dpoint; - typedef mln_coord(point) coord; + // FIXME: Dummy typedef. + typedef void mesh; public: + /// Construction. + /// \{ template <typename N, typename Pref> line_graph_neighborhood_fwd_piter(const N& nbh, const Point_Site<Pref>& p_ref); + /// \} + /// Manipulation. + /// \{ + /// Test if the iterator is valid. bool is_valid() const; + /// Invalidate the iterator. void invalidate(); + /// Start an iteration. void start(); + /// Go to the next point. void next_(); + /// Is the piter adjacent or equal to the reference point? bool adjacent_or_equal_to_p_ref_() const; /// Update the internal data of the iterator. void update_(); + /// \} + /// Conversion and accessors. + /// \{ + /// Reference to the corresponding point. const point& to_point() const; + /// Reference to the corresponding point site. const psite& to_psite() const; - - operator point() const; + /// Convert the iterator into a line graph psite. operator psite() const; - /// Return the \a i th coordinate of the (iterated) point. + /// Read-only access to the \a i-th coordinate. + // FIXME: Dummy. coord operator[](unsigned i) const; + /// \} private: /// The ``central'' psite of the neighborhood. @@ -117,6 +128,8 @@ /// The psite corresponding to this iterator. psite psite_; /// The point corresponding to this iterator. + /* FIXME: Dummy value. To be removed as soon as the conversion + from psite to point is no longer mandatory. */ point p_; }; @@ -135,21 +148,108 @@ | line_graph_neighborhood_bkd_piter. | `---------------------------------------*/ - // FIXME: Implement line_graph_neighborhood_bkd_piter. + /// \brief Backward iterator on line graph neighborhood. + template <typename P> + class line_graph_neighborhood_bkd_piter : + public Point_Iterator< line_graph_neighborhood_bkd_piter > // or Iterator<...>? + { + typedef line_graph_neighborhood_bkd_piter self_; + typedef Point_Iterator< self_ > super_; + + public: + // Make definitions from super class available. + enum { dim = P::dim }; + + typedef line_graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; + // FIXME: Dummy typedef. + typedef void dpoint; + // FIXME: Dummy typedef. + typedef void mesh; + + public: + /// Construction. + /// \{ + template <typename N, typename Pref> + line_graph_neighborhood_bkd_piter(const N& nbh, + const Point_Site<Pref>& p_ref); + /// \} + + /// Manipulation. + /// \{ + /// Test if the iterator is valid. + bool is_valid() const; + /// Invalidate the iterator. + void invalidate(); + /// Start an iteration. + void start(); + + /// Go to the next point. + void next_(); + /// Is the piter adjacent or equal to the reference point? + bool adjacent_or_equal_to_p_ref_() const; + /// Update the internal data of the iterator. + void update_(); + /// \} + + /// Conversion and accessors. + /// \{ + /// Reference to the corresponding point. + const point& to_point() const; + /// Reference to the corresponding point site. + const psite& to_psite() const; + /// Convert the iterator into a line graph psite. + operator psite() const; + + /// Read-only access to the \a i-th coordinate. + // FIXME: Dummy. + coord operator[](unsigned i) const; + /// \} + + private: + /// The ``central'' psite of the neighborhood. + const psite& p_ref_; + /// An internal iterator on the set of edges of the underlying graph. + util::edge_id id_; + /// The psite corresponding to this iterator. + psite psite_; + /// The point corresponding to this iterator. + /* FIXME: Dummy value. To be removed as soon as the conversion + from psite to point is no longer mandatory. */ + point p_; + }; + + /* FIXME: This hand-made delegation is painful. We should rely on + the general mechanism provided by Point_Site. But then again, we + need to refine/adjust the interface of Point_Site w.r.t. the + mandatory conversions to points. */ + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, + const line_graph_neighborhood_bkd_piter& p); + # ifndef MLN_INCLUDE_ONLY + /*---------------------------------------. + | line_graph_neighborhood_fwd_piter. | + `---------------------------------------*/ + // FIXME: Currently, argument nbh is ignored. template <typename P> template <typename N, typename Pref> inline line_graph_neighborhood_fwd_piter::line_graph_neighborhood_fwd_piter(const N& /* nbh */, const Point_Site<Pref>& p_ref) + /* FIXME: We should use a routine actually checking the + conversion, since to_psite() checks nothing (as of + 2008-03-05). */ : p_ref_(exact(p_ref).to_psite()), // Initialize psite_ to a dummy value. - psite_(p_ref_.plg(), p_ref_.plg().nlines()), - p_() + psite_() { // Invalidate id_. invalidate(); @@ -171,7 +271,7 @@ void line_graph_neighborhood_fwd_piter::invalidate() { - id_ = p_ref_.plg().gr_.nedges(); + id_ = -1; } template <typename P> @@ -247,16 +347,11 @@ { // Update psite_. psite_ = line_graph_psite(p_ref_.plg(), id_); - // Update p_. - // FIXME: These repeated assignments might be very costly. - /* FIXME: Likewise, it's hard to read. Simplify accesses to the graph. */ - p_ = point(p_ref_.plg().gr_.node_data(p_ref_.plg().gr_.edge(id_).n1()), - p_ref_.plg().gr_.node_data(p_ref_.plg().gr_.edge(id_).n2())); } template <typename P> inline - const point_pair& + const P& line_graph_neighborhood_fwd_piter::to_point() const { return p_; @@ -272,15 +367,165 @@ template <typename P> inline - line_graph_neighborhood_fwd_piter::operator point_pair() const + line_graph_neighborhood_fwd_piter::operator line_graph_psite () const { mln_precondition(is_valid()); + return psite_; + } + + template <typename P> + inline + mln_coord(P) + line_graph_neighborhood_fwd_piter::operator[](unsigned i) const + { + assert(i < dim); + return p_[i]; + } + + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, + const line_graph_neighborhood_fwd_piter& p) + { + return ostr << p.to_psite(); + } + + + /*---------------------------------------. + | line_graph_neighborhood_bkd_piter. | + `---------------------------------------*/ + + // FIXME: Currently, argument nbh is ignored. + template <typename P> + template <typename N, typename Pref> + inline + line_graph_neighborhood_bkd_piter::line_graph_neighborhood_bkd_piter(const N& /* nbh */, + const Point_Site<Pref>& p_ref) + /* FIXME: We should use a routine actually checking the + conversion, since to_psite() checks nothing (as of + 2008-03-05). */ + : p_ref_(exact(p_ref).to_psite()), + // Initialize psite_ to a dummy value. + psite_() + { + // Invalidate id_. + invalidate(); + } + + template <typename P> + inline + bool + line_graph_neighborhood_bkd_piter::is_valid() const + { + // FIXME: We depend too much on the implementation of util::graph + // here. The util::graph should provide the service to abstract + // these manipulations. + return id_ < p_ref_.plg().gr_.nedges(); + } + + template <typename P> + inline + void + line_graph_neighborhood_bkd_piter::invalidate() + { + id_ = -1; + } + + template <typename P> + inline + void + line_graph_neighborhood_bkd_piter::start() + { + id_ = p_ref_.plg().gr_.nedges() - 1; + if (!adjacent_or_equal_to_p_ref_()) + next_(); + /* FIXME: This is redundant with the end of next_(), but we might + change the implementation of start_() when we'll fix it later, + and no longer use next_(). */ + if (is_valid()) + update_(); + } + + template <typename P> + inline + void + line_graph_neighborhood_bkd_piter::next_() + { + /* FIXME: This is inefficient. The graph structure should be able + to produce the set of adjacent edges fast. Boost Graphs + probably provides adequates structures to fetch these + neighbors in constant time. */ + /* FIXME: Moreover, the behavior of next shall depend on the + neighborhood, which is not the case now! (Currently, next_() + behaves as nbh was always an elementary neighborhood.) */ + do + --id_; + while (is_valid() && !adjacent_or_equal_to_p_ref_()); + if (is_valid()) + update_(); + } + + template <typename P> + inline + bool + line_graph_neighborhood_bkd_piter::adjacent_or_equal_to_p_ref_() const + { + // Check wether the iterator points to P_REF_. + if (id_ == p_ref_.id()) + return true; + + // Check whether the iterator is among the neighbors of P_REF_. + { + // Paranoid assertion. + assert (p_ref_.id() < p_ref_.plg().gr_.nedges()); + /* FIXME: We should have a convenient shortcut for these + repetitive accesses to p_ref_.plg().gr_ (e.g., a method gr() + or g() in this class. */ + const typename p_line_graph::graph& gr = p_ref_.plg().gr_; + // Check whether the edge this iterator points to is adjacent to + // the one p_ref points to, by comparing their ajacent nodes. + /* FIXME: This is too low-level. Yet another service the graph + // should provide. */ + if (gr.edge(id_).n1() == gr.edge(p_ref_.id()).n1() || + gr.edge(id_).n1() == gr.edge(p_ref_.id()).n2() || + gr.edge(id_).n2() == gr.edge(p_ref_.id()).n1() || + gr.edge(id_).n2() == gr.edge(p_ref_.id()).n2()) + return true; + } + + // Otherwise, the iterator is not adjacent to P_REF_. + return false; + } + + template <typename P> + inline + void + line_graph_neighborhood_bkd_piter::update_() + { + // Update psite_. + psite_ = line_graph_psite(p_ref_.plg(), id_); + } + + template <typename P> + inline + const P& + line_graph_neighborhood_bkd_piter::to_point() const + { return p_; } template <typename P> inline - line_graph_neighborhood_fwd_piter::operator line_graph_psite () const + const line_graph_psite& + line_graph_neighborhood_bkd_piter::to_psite() const + { + return psite_; + } + + template <typename P> + inline + line_graph_neighborhood_bkd_piter::operator line_graph_psite () const { mln_precondition(is_valid()); return psite_; @@ -288,8 +533,8 @@ template <typename P> inline - mln_coord(point_pair) - line_graph_neighborhood_fwd_piter::operator[](unsigned i) const + mln_coord(P) + line_graph_neighborhood_bkd_piter::operator[](unsigned i) const { assert(i < dim); return p_[i]; @@ -299,13 +544,14 @@ inline std::ostream& operator<<(std::ostream& ostr, - const line_graph_neighborhood_fwd_piter& p) + const line_graph_neighborhood_bkd_piter& p) { - return ostr << p.to_point(); + return ostr << p.to_psite(); } # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln + #endif // ! MLN_CORE_LINE_GRAPH_NEIGHBORHOOD_PITER_HH

1 0

1771: Add a backward iterator on p_line_graph.
by Roland Levillain 12 Mar '08

12 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add a backward iterator on p_line_graph. * mln/core/p_line_graph_piter.hh (p_line_graph_piter_): Rename as... (p_line_graph_fwd_piter_): ...this. (p_line_graph_fwd_piter_::self_): Adjust. (p_line_graph_fwd_piter_::point): Set typedef to P. (p_line_graph_fwd_piter_::coord): Set typedef to mln_coord(point). (p_line_graph_fwd_piter_(const p_line_graph_fwd_piter_&)) (operator= (const p_line_graph_fwd_piter_&)): New. (p_line_graph_fwd_piter_::operator point): Remove. (p_line_graph_fwd_piter_::operator psite): New. (p_line_graph_fwd_piter_::plg_): Change the type of this member from const p_line_graph& to const p_line_graph*. (p_line_graph_fwd_piter_(const p_line_graph&)) (p_line_graph_fwd_piter_::is_valid) (p_line_graph_fwd_piter_::invalidate): Adjust. (p_line_graph_fwd_piter_::update_): Don't update member p_. (p_line_graph_bkd_piter_): New. (operator<<(std::ostream&, const p_line_graph_fwd_piter_&)) (operator<<(std::ostream&, const p_line_graph_bkd_piter_&)) * mln/core/p_line_graph.hh (mln::box_< point_pair >): Remove this specialization. (mln::p_line_graph::point): Remove typedef. (mln::p_line_graph::fwd_piter): Adjust to the new name of mln::p_line_graph_fwd_piter_. (mln::p_line_graph::bkd_piter): New typedef. (mln::p_line_graph::nlines): Rename as... (mln::p_line_graph::nedges): ..this. (mln::p_line_graph::npoints): Rename as... (mln::p_line_graph::nnodes): ...this. (mln::p_line_graph::npoints): New. s/box_<point>/box_/. (mln::p_line_graph::p_line_graph (util::graph&)): Fix the initialization of bb_. (operator==(const p_line_graph&, const p_line_graph&)): New. p_line_graph.hh | 87 ++++++------ p_line_graph_piter.hh | 351 +++++++++++++++++++++++++++++++++++++++++--------- 2 files changed, 340 insertions(+), 98 deletions(-) Index: mln/core/p_line_graph_piter.hh --- mln/core/p_line_graph_piter.hh (revision 1770) +++ mln/core/p_line_graph_piter.hh (working copy) @@ -31,12 +31,9 @@ # include <mln/core/internal/point_iterator_base.hh> # include <mln/core/p_line_graph.hh> # include <mln/core/line_graph_psite.hh> -# include <mln/core/point_pair.hh> -/*! \file mln/core/p_line_graph_piter.hh - * - * \brief Definition of point iterator on graph-based point set. - */ +/// \file mln/core/p_line_graph_piter.hh +/// \brief Definition of point iterator on line graph-based point set. namespace mln { @@ -45,67 +42,156 @@ template<typename P> class line_graph_psite; - // FIXME: Why `p_line_graph_piter_' and not `p_line_graph_piter' - // (without `_')? + /*-----------------------------. + | p_line_graph_fwd_piter_. | + `-----------------------------*/ + /// \brief Forward iterator on point sites of a mln::p_line_graph. template<typename P> - class p_line_graph_piter_ - : public internal::point_iterator_base_< P, p_line_graph_piter_ > + class p_line_graph_fwd_piter_ + : public internal::point_iterator_base_< P, p_line_graph_fwd_piter_ > { - typedef p_line_graph_piter_ self_; + typedef p_line_graph_fwd_piter_ self_; typedef internal::point_iterator_base_< P, self_ > super_; public: - // Make definitions from super class available. enum { dim = super_::dim }; - typedef line_graph_psite psite; - typedef point_pair point; - typedef mln_coord(point_pair) coord; - p_line_graph_piter_(const p_line_graph& plg); + typedef line_graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; - /// Read-only access to the \p i-th coordinate. - mln_coord(point) operator[](unsigned i) const; + /// Construction and assignment. + /// \{ + p_line_graph_fwd_piter_(const p_line_graph& plg); + p_line_graph_fwd_piter_(const self_& rhs); + self_& operator= (const self_& rhs); + /// \} + /// Manipulation. + /// \{ /// Test if the iterator is valid. bool is_valid() const; - /// Invalidate the iterator. void invalidate(); - /// Start an iteration. void start(); /// Go to the next point. void next_(); - /// Update the internal data of the iterator. void update_(); + /// \} + /// Conversion and accessors. + /// \{ /// Reference to the corresponding point. + // FIXME: Dummy. const point& to_point () const; - /// Reference to the corresponding point site. const psite& to_psite () const; + /// Convert the iterator into a line graph psite. + operator psite() const; + + /// Read-only access to the \a i-th coordinate. + coord operator[](unsigned i) const; + /// \} + + private: + /// The p_line_graph this point site belongs to. + const p_line_graph* plg_; + /// The id of the edge this psite is pointing towards. + util::edge_id id_; + /// The psite corresponding to this iterator. + psite psite_; + /// The point corresponding to this iterator. + /* FIXME: Dummy value. To be removed as soon as the conversion + from psite to point is no longer mandatory. */ + point p_; + }; + + + /* FIXME: This hand-made delegation is painful. We should rely on + the general mechanism provided by Point_Site. But then again, we + need to refine/adjust the interface of Point_Site w.r.t. the + mandatory conversions to points. */ + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const p_line_graph_fwd_piter_& p); - /// Convert the iterator into a point. - operator point() const; - /// Convert the iterator into a graph psite. + /*-----------------------------. + | p_line_graph_bkd_piter_. | + `-----------------------------*/ + + /// \brief Backward iterator on point sites of a mln::p_line_graph. + template<typename P> + class p_line_graph_bkd_piter_ + : public internal::point_iterator_base_< P, p_line_graph_bkd_piter_ > + { + typedef p_line_graph_bkd_piter_ self_; + typedef internal::point_iterator_base_< P, self_ > super_; + + public: + // Make definitions from super class available. + enum { dim = super_::dim }; + + typedef line_graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; + + /// Construction and assignment. + /// \{ + p_line_graph_bkd_piter_(const p_line_graph& plg); + p_line_graph_bkd_piter_(const self_& rhs); + self_& operator= (const self_& rhs); + /// \} + + /// Manipulation. + /// \{ + /// Test if the iterator is valid. + bool is_valid() const; + /// Invalidate the iterator. + void invalidate(); + /// Start an iteration. + void start(); + + /// Go to the next point. + void next_(); + /// Update the internal data of the iterator. + void update_(); + /// \} + + /// Conversion and accessors. + /// \{ + /// Reference to the corresponding point. + // FIXME: Dummy. + const point& to_point () const; + /// Reference to the corresponding point site. + const psite& to_psite () const; + /// Convert the iterator into a line graph psite. operator psite() const; + /// Read-only access to the \a i-th coordinate. + mln_coord(point) operator[](unsigned i) const; + /// \} + protected: /// The p_line_graph this point site belongs to. - const p_line_graph& plg_; + const p_line_graph* plg_; /// The id of the edge this psite is pointing towards. util::edge_id id_; /// The psite corresponding to this iterator. psite psite_; - /// The psite corresponding to this iterator. + /// The point corresponding to this iterator. + /* FIXME: Dummy value. To be removed as soon as the conversion + from psite to point is no longer mandatory. */ point p_; }; + /* FIXME: This hand-made delegation is painful. We should rely on the general mechanism provided by Point_Site. But then again, we need to refine/adjust the interface of Point_Site w.r.t. the @@ -113,18 +199,21 @@ template <typename P> inline std::ostream& - operator<<(std::ostream& ostr, const p_line_graph_piter_& p); + operator<<(std::ostream& ostr, const p_line_graph_bkd_piter_& p); # ifndef MLN_INCLUDE_ONLY + /*-----------------------------. + | p_line_graph_fwd_piter_. | + `-----------------------------*/ + template<typename P> inline - p_line_graph_piter_::p_line_graph_piter_(const p_line_graph& plg) - : plg_(plg), + p_line_graph_fwd_piter_::p_line_graph_fwd_piter_(const p_line_graph& plg) + : plg_(&plg), // Initialize psite_ to a dummy value. - psite_(plg, plg_.nlines()), - p_() + psite_(plg, -1) { // Invalidate id_. invalidate(); @@ -132,32 +221,55 @@ template<typename P> inline - mln_coord(point_pair) - p_line_graph_piter_::operator[](unsigned i) const + p_line_graph_fwd_piter_::p_line_graph_fwd_piter_(const p_line_graph_fwd_piter_& rhs) + : plg_(rhs.plg_), + id_(rhs.id_), + psite_(rhs.psite_) { + } + + template<typename P> + inline + p_line_graph_fwd_piter_& + p_line_graph_fwd_piter_::operator=(const p_line_graph_fwd_piter_& rhs) + { + if (&rhs == this) + return *this; + plg_ = rhs.plg_; + id_ = rhs.id_; + psite_ = rhs.psite_; + return *this; + } + + template<typename P> + inline + mln_coord(P) + p_line_graph_fwd_piter_::operator[](unsigned i) const + { + // Dummy value. return p_[i]; } template<typename P> inline bool - p_line_graph_piter_::is_valid() const + p_line_graph_fwd_piter_::is_valid() const { - return id_ < plg_.nlines(); + return plg_ && id_ < plg_->nedges(); } template<typename P> inline void - p_line_graph_piter_::invalidate() + p_line_graph_fwd_piter_::invalidate() { - id_ = plg_.nlines(); + id_ = -1; } template<typename P> inline void - p_line_graph_piter_::start() + p_line_graph_fwd_piter_::start() { id_ = 0; if (is_valid()) @@ -167,7 +279,7 @@ template<typename P> inline void - p_line_graph_piter_::next_() + p_line_graph_fwd_piter_::next_() { ++id_; if (is_valid()) @@ -177,20 +289,25 @@ template<typename P> inline void - p_line_graph_piter_::update_() + p_line_graph_fwd_piter_::update_() { // Update psite_. - psite_ = line_graph_psite(plg_, id_); - // Update p_. - // FIXME: These repeated assignments might be very costly. - p_ = point(plg_.gr_.node_data(plg_.gr_.edge(id_).n1()), - plg_.gr_.node_data(plg_.gr_.edge(id_).n2())); + psite_ = line_graph_psite(*plg_, id_); + } + + template<typename P> + inline + const P& + p_line_graph_fwd_piter_::to_point() const + { + // Dummy value. + return p_; } template<typename P> inline - const point_pair& - p_line_graph_piter_::to_point() const + const line_graph_psite& + p_line_graph_fwd_piter_::to_psite() const { /* We don't check whether the iterator is valid before returning the value using @@ -203,13 +320,135 @@ on window or neighborhood (say, Q); most of the time, for_all() is responsible for the initialization of P, but it takes place *after* the creation of Q. */ + return psite_; + } + + template<typename P> + inline + p_line_graph_fwd_piter_::operator line_graph_psite() const + { + mln_precondition(is_valid()); + return psite_; + } + + + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const p_line_graph_fwd_piter_& p) + { + // FIXME: We should use p.to_psite() here, but as it lacks the + // precondition the conversion operator has, we use the latter. + return ostr << static_cast< line_graph_psite >(p); + } + + + /*-----------------------------. + | p_line_graph_bkd_piter_. | + `-----------------------------*/ + + template<typename P> + inline + p_line_graph_bkd_piter_::p_line_graph_bkd_piter_(const p_line_graph& plg) + : plg_(&plg), + // Initialize psite_ to a dummy value. + psite_(plg, -1) + { + // Invalidate id_. + invalidate(); + } + + template<typename P> + inline + p_line_graph_bkd_piter_::p_line_graph_bkd_piter_(const p_line_graph_bkd_piter_& rhs) + : plg_(rhs.plg_), + id_(rhs.id_), + psite_(rhs.psite_) + { + } + + template<typename P> + inline + p_line_graph_bkd_piter_& + p_line_graph_bkd_piter_::operator=(const p_line_graph_bkd_piter_& rhs) + { + if (&rhs == this) + return *this; + plg_ = rhs.plg_; + id_ = rhs.id_; + psite_ = rhs.psite_; + // FIXME: Probably superfluous. +// update_(); + return *this; + } + + template<typename P> + inline + mln_coord(P) + p_line_graph_bkd_piter_::operator[](unsigned i) const + { + // Dummy value. + return p_[i]; + } + + template<typename P> + inline + bool + p_line_graph_bkd_piter_::is_valid() const + { + return plg_ && id_ < plg_->nedges(); + } + + template<typename P> + inline + void + p_line_graph_bkd_piter_::invalidate() + { + id_ = -1; + } + + template<typename P> + inline + void + p_line_graph_bkd_piter_::start() + { + id_ = plg_->nedges() - 1; + if (is_valid()) + update_(); + } + + template<typename P> + inline + void + p_line_graph_bkd_piter_::next_() + { + --id_; + if (is_valid()) + update_(); + } + + template<typename P> + inline + void + p_line_graph_bkd_piter_::update_() + { + // Update psite_. + psite_ = line_graph_psite(*plg_, id_); + } + + template<typename P> + inline + const P& + p_line_graph_bkd_piter_::to_point() const + { + // Dummy value. return p_; } template<typename P> inline const line_graph_psite& - p_line_graph_piter_::to_psite() const + p_line_graph_bkd_piter_::to_psite() const { /* We don't check whether the iterator is valid before returning the value using @@ -227,15 +466,7 @@ template<typename P> inline - p_line_graph_piter_::operator point_pair() const - { - mln_precondition(is_valid()); - return p_; - } - - template<typename P> - inline - p_line_graph_piter_::operator line_graph_psite() const + p_line_graph_bkd_piter_::operator line_graph_psite() const { mln_precondition(is_valid()); return psite_; @@ -245,9 +476,9 @@ template <typename P> inline std::ostream& - operator<<(std::ostream& ostr, const p_line_graph_piter_& p) + operator<<(std::ostream& ostr, const p_line_graph_bkd_piter_& p) { - return ostr << p.to_point(); + return ostr << static_cast< line_graph_psite >(p); } # endif // ! MLN_INCLUDE_ONLY @@ -255,4 +486,4 @@ } // end of mln -#endif // MLN_P_LINE_GRAPH_PITER_HH +#endif // ! MLN_CORE_P_LINE_GRAPH_PITER_HH Index: mln/core/p_line_graph.hh --- mln/core/p_line_graph.hh (revision 1770) +++ mln/core/p_line_graph.hh (working copy) @@ -34,7 +34,6 @@ # include <mln/util/graph.hh> # include <mln/core/line_graph_psite.hh> # include <mln/core/p_line_graph_piter.hh> -# include <mln/core/point_pair.hh> /* FIXME: This class shares a lot with p_graph. Factor as much as possible. */ @@ -45,17 +44,9 @@ namespace mln { - - // FIXME: Dummy specialization, only to have this first version of - // our code compile. - template <typename P> - struct box_< point_pair > : public Box< box_ > - { - // Nothing. - }; - - - template<typename P> class p_line_graph_piter_; + /* FIXME: Contray to, e.g., p_array, the sole parameter P of + p_line_graph is expected to be a point, not a psite!! We should + have a uniform scheme for point site sets. */ template<typename P> struct p_line_graph @@ -69,24 +60,24 @@ /// Point_Site associated type. typedef line_graph_psite psite; - /// Point associated type. - typedef point_pair point; - /// Forward Point_Iterator associated type. - typedef p_line_graph_piter_ fwd_piter; + typedef p_line_graph_fwd_piter_ fwd_piter; /// Backward Point_Iterator associated type. - typedef p_line_graph_piter_ bkd_piter; + typedef p_line_graph_bkd_piter_ bkd_piter; - /// Return The number of points (i.e., nodes) in the graph. + /// Return The number of points (sites) of the set, i.e., the + /// number of \em edges, since this is a point set based on a line + /// graph. std::size_t npoints() const; - /// Return The number of lines (i.e., edges) in the graph. - std::size_t nlines() const; + /// Return The number of nodes (vertices) in the graph. + std::size_t nnodes() const; + /// Return The number of edges in the graph. + std::size_t nedges() const; /// Give the exact bounding box. - // FIXME: Dummy. - const box_<point>& bbox() const; + const box_& bbox() const; bool has(const psite& p) const; @@ -95,12 +86,20 @@ // FIXME: (Roland) Is it really useful/needed? /* 2007-12-19: It seems so, since graph_image must implement a method named bbox(). Now the question is: should each image - type have a bounding box? In particular, an image whose sites - are actually /pairs of points/! */ - // FIXME: Dummy. - box_<point> bb_; + type have a bounding box? */ + box_ bb_; }; + + /// \brief Comparison between two mln::p_line_graph's. + /// + /// Two mln::p_line_graph's are considered equal if they have the + /// same address. + template <typename P> + bool + operator==(const p_line_graph& lhs, const p_line_graph& rhs); + + # ifndef MLN_INCLUDE_ONLY template<typename P> @@ -108,37 +107,41 @@ p_line_graph::p_line_graph (util::graph& gr) : gr_ (gr) { - // FIXME: Dummy initialization of bb_. -// // FIXME: Warning: if the underlying graph is updated later, this -// // won't be taken into account by this p_line_graph! -// accu::bbox<point> a; -// for (util::edge_id e = 0; e < nlines(); ++e) -// a.take(point(gr_.node_data(gr_.edge(e).n1()), -// gr_.node_data(gr_.edge(e).n2()))); -// bb_ = a.to_result(); + // FIXME: Warning: if the underlying graph is updated later, this + // won't be taken into account by this p_line_graph! + accu::bbox a; + for (unsigned i = 0; i < nnodes(); ++i) + a.take(gr_.node_data(i)); + bb_ = a.to_result(); } - // FIXME: Rename to npsites? In fact, this depends on the - // interface expected from models of Point_Sets. template<typename P> inline std::size_t p_line_graph::npoints() const { + return nedges(); + } + + template<typename P> + inline + std::size_t + p_line_graph::nnodes() const + { return this->gr_.nnodes(); } template<typename P> inline std::size_t - p_line_graph::nlines() const + p_line_graph::nedges() const { return this->gr_.nedges(); } template<typename P> inline - const box_< point_pair >& + const box_& p_line_graph::bbox() const { return bb_; @@ -156,6 +159,14 @@ (p.id() < gr_.nedges()); } + + template <typename P> + bool + operator==(const p_line_graph& lhs, const p_line_graph& rhs) + { + return &lhs == &rhs; + } + # endif // ! MLN_INCLUDE_ONLY } // end of mln

1 0

1770: Add a backward iterator on p_graph.
by Roland Levillain 12 Mar '08

12 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add a backward iterator on p_graph. * mln/core/p_graph_piter.hh (p_graph_piter_): Rename as... (p_graph_fwd_piter_): ...this. (p_graph_fwd_piter_::operator point): Remove. (p_graph_fwd_piter_::pg_): Change the type of this member from const p_graph& to const p_graph*. (p_graph_fwd_piter_::p_graph_fwd_piter_(const p_graph&)) (p_graph_fwd_piter_::is_valid) (p_graph_fwd_piter_::invalidate) (p_graph_fwd_piter_::update_): Adjust. (p_graph_fwd_piter_::coord): New typedef. (p_graph_fwd_piter_(const p_graph_fwd_piter_&)): New ctor. (p_graph_fwd_piter_::operator= (const p_graph_fwd_piter_&)): New operator. (p_graph_piter_::operator P): Remove. (p_graph_bkd_piter_): New. (operator<<(std::ostream&, const p_graph_fwd_piter_&)) (operator<<(std::ostream&, const p_graph_bkd_piter_&)): New. * mln/core/p_graph.hh (mln::p_graph::fwd_piter): Adjust to the new name of mln::p_graph_fwd_piter_. (mln::p_graph::bkd_piter): New typedef. (mln::p_graph::nlines): Rename as... (mln::p_graph::nedges): ..this. (mln::p_graph::npoints): Rename as... (mln::p_graph::nnodes): ...this. (mln::p_graph::npoints): New. (operator==(const p_graph&, const p_graph&)): New. * mln/draw/graph.hh (graph(Image&, const graph_image<P, V>&, mln_value(I))): Adjust. core/p_graph.hh | 51 +++++-- core/p_graph_piter.hh | 350 ++++++++++++++++++++++++++++++++++++++++++++------ draw/graph.hh | 4 3 files changed, 353 insertions(+), 52 deletions(-) Index: mln/core/p_graph_piter.hh --- mln/core/p_graph_piter.hh (revision 1769) +++ mln/core/p_graph_piter.hh (working copy) @@ -32,10 +32,8 @@ # include <mln/core/p_graph.hh> # include <mln/core/graph_psite.hh> -/*! \file mln/core/p_graph_piter.hh - * - * \brief Definition of point iterator on graph-based point set. - */ +/// \file mln/core/p_graph_piter.hh +/// \brief Definition of point iterator on graph-based point set. namespace mln { @@ -44,57 +42,140 @@ template<typename P> class graph_psite; - // FIXME: Why `p_graph_piter_' and not `p_graph_piter' (without `_')? + /*------------------------. + | p_graph_fwd_piter_. | + `------------------------*/ + /// \brief Forward iterator on point sites of a mln::p_graph. template<typename P> - class p_graph_piter_ - : public internal::point_iterator_base_< P, p_graph_piter_ > + class p_graph_fwd_piter_ + : public internal::point_iterator_base_< P, p_graph_fwd_piter_ > { - typedef p_graph_piter_ self_; + typedef p_graph_fwd_piter_ self_; typedef internal::point_iterator_base_< P, self_ > super_; public: - // Make definitions from super class available. enum { dim = super_::dim }; + typedef graph_psite psite; typedef P point; + typedef mln_coord(point) coord; + + /// Construction and assignment. + /// \{ + p_graph_fwd_piter_(const p_graph& pg); + p_graph_fwd_piter_(const self_& rhs); + self_& operator= (const self_& rhs); + /// \} - p_graph_piter_(const p_graph& pg); + /// Manipulation. + /// \{ + /// Test if the iterator is valid. + bool is_valid() const; + /// Invalidate the iterator. + void invalidate(); + /// Start an iteration. + void start(); + + /// Go to the next point. + void next_(); + /// Update the internal data of the iterator. + void update_(); + /// \} + + /// Conversion and accessors. + /// \{ + /// Reference to the corresponding point. + const point& to_point () const; + /// Reference to the corresponding point site. + const psite& to_psite () const; + /// Convert the iterator into a graph psite. + operator psite() const; /// Read-only access to the \p i-th coordinate. mln_coord(P) operator[](unsigned i) const; + /// \} + + private: + /// The p_graph this point site belongs to. + const p_graph* pg_; + /// The id of the node this psite is pointing towards. + unsigned id_; + /// The psite corresponding to this iterator. + psite psite_; + /// The point corresponding to this iterator. + point p_; + }; + + /* FIXME: This hand-made delegation is painful. We should rely on + the general mechanism provided by Point_Site. But then again, we + need to refine/adjust the interface of Point_Site w.r.t. the + mandatory conversions to points. */ + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const p_graph_fwd_piter_& p); + + + /*------------------------. + | p_graph_bkd_piter_. | + `------------------------*/ + + /// \brief Backward iterator on point sites of a mln::p_graph. + template<typename P> + class p_graph_bkd_piter_ + : public internal::point_iterator_base_< P, p_graph_bkd_piter_ > + { + typedef p_graph_bkd_piter_ self_; + typedef internal::point_iterator_base_< P, self_ > super_; + + public: + // Make definitions from super class available. + enum { dim = super_::dim }; + + typedef graph_psite psite; + typedef P point; + typedef mln_coord(point) coord; + + /// Construction and assignment. + /// \{ + p_graph_bkd_piter_(const p_graph& pg); + p_graph_bkd_piter_(const self_& rhs); + self_& operator= (const self_& rhs); + /// \} + /// Manipulation. + /// \{ /// Test if the iterator is valid. bool is_valid() const; - /// Invalidate the iterator. void invalidate(); - /// Start an iteration. void start(); /// Go to the next point. void next_(); - /// Update the internal data of the iterator. void update_(); + /// \} + /// Conversion and accessors. + /// \{ /// Reference to the corresponding point. const point& to_point () const; - /// Reference to the corresponding point site. const psite& to_psite () const; - - /// Convert the iterator into a point. - operator point() const; - /// Convert the iterator into a graph psite. operator psite() const; - protected: + /// Read-only access to the \p i-th coordinate. + coord operator[](unsigned i) const; + /// \} + + private: /// The p_graph this point site belongs to. - const p_graph& pg_; + const p_graph* pg_; /// The id of the node this psite is pointing towards. unsigned id_; /// The psite corresponding to this iterator. @@ -104,16 +185,28 @@ }; + /* FIXME: This hand-made delegation is painful. We should rely on + the general mechanism provided by Point_Site. But then again, we + need to refine/adjust the interface of Point_Site w.r.t. the + mandatory conversions to points. */ + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const p_graph_bkd_piter_& p); + # ifndef MLN_INCLUDE_ONLY + /*------------------------. + | p_graph_fwd_piter_. | + `------------------------*/ + template<typename P> inline - p_graph_piter_::p_graph_piter_(const p_graph& pg) - : pg_(pg), + p_graph_fwd_piter_::p_graph_fwd_piter_(const p_graph& pg) + : pg_(&pg), // Initialize psite_ to a dummy value. - psite_(pg, pg_.npoints()), - p_() + psite_(pg, -1) { // Invalidate id_. invalidate(); @@ -121,8 +214,32 @@ template<typename P> inline + p_graph_fwd_piter_::p_graph_fwd_piter_(const p_graph_fwd_piter_& rhs) + : pg_(rhs.pg_), + id_(rhs.id_), + psite_(rhs.psite_), + p_(rhs.p_) + { + } + + template<typename P> + inline + p_graph_fwd_piter_& + p_graph_fwd_piter_::operator=(const p_graph_fwd_piter_& rhs) + { + if (&rhs == this) + return *this; + pg_ = rhs.pg_; + id_ = rhs.id_; + psite_ = rhs.psite_; + p_ = rhs.p_; + return *this; + } + + template<typename P> + inline mln_coord(P) - p_graph_piter_::operator[](unsigned i) const + p_graph_fwd_piter_::operator[](unsigned i) const { return p_[i]; } @@ -130,23 +247,23 @@ template<typename P> inline bool - p_graph_piter_::is_valid() const + p_graph_fwd_piter_::is_valid() const { - return id_ < pg_.npoints(); + return pg_ && id_ < pg_->nnodes(); } template<typename P> inline void - p_graph_piter_::invalidate() + p_graph_fwd_piter_::invalidate() { - id_ = pg_.npoints(); + id_ = -1; } template<typename P> inline void - p_graph_piter_::start() + p_graph_fwd_piter_::start() { id_ = 0; if (is_valid()) @@ -156,7 +273,7 @@ template<typename P> inline void - p_graph_piter_::next_() + p_graph_fwd_piter_::next_() { ++id_; if (is_valid()) @@ -166,18 +283,18 @@ template<typename P> inline void - p_graph_piter_::update_() + p_graph_fwd_piter_::update_() { // Update psite_. - psite_ = graph_psite(pg_, id_); + psite_ = graph_psite(*pg_, id_); // Update p_. - p_ = pg_.point_from_id(id_); + p_ = pg_->point_from_id(id_); } template<typename P> inline const P& - p_graph_piter_::to_point() const + p_graph_fwd_piter_::to_point() const { /* We don't check whether the iterator is valid before returning the value using @@ -196,7 +313,7 @@ template<typename P> inline const graph_psite& - p_graph_piter_::to_psite() const + p_graph_fwd_piter_::to_psite() const { /* We don't check whether the iterator is valid before returning the value using @@ -214,23 +331,178 @@ template<typename P> inline - p_graph_piter_::operator P() const + p_graph_fwd_piter_::operator graph_psite() const + { + mln_precondition(is_valid()); + return psite_; + } + + + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const p_graph_fwd_piter_& p) + { + // FIXME: We should use p.to_psite() here, but as it lacks the + // precondition the conversion operator has, we use the latter. + return ostr << static_cast< graph_psite >(p); + } + + + /*------------------------. + | p_graph_bkd_piter_. | + `------------------------*/ + + template<typename P> + inline + p_graph_bkd_piter_::p_graph_bkd_piter_(const p_graph& pg) + : pg_(&pg), + // Initialize psite_ to a dummy value. + psite_(pg, -1) + { + // Invalidate id_. + invalidate(); + } + + template<typename P> + inline + p_graph_bkd_piter_::p_graph_bkd_piter_(const p_graph_bkd_piter_& rhs) + : pg_(rhs.pg_), + id_(rhs.id_), + psite_(rhs.psite_), + p_(rhs.p_) + { + } + + template<typename P> + inline + p_graph_bkd_piter_& + p_graph_bkd_piter_::operator=(const p_graph_bkd_piter_& rhs) + { + if (&rhs == this) + return *this; + pg_ = rhs.pg_; + id_ = rhs.id_; + psite_ = rhs.psite_; + p_ = rhs.p_; + return *this; + } + + template<typename P> + inline + mln_coord(P) + p_graph_bkd_piter_::operator[](unsigned i) const + { + return p_[i]; + } + + template<typename P> + inline + bool + p_graph_bkd_piter_::is_valid() const + { + return pg_ && id_ < pg_->nnodes(); + } + + template<typename P> + inline + void + p_graph_bkd_piter_::invalidate() + { + id_ = -1; + } + + template<typename P> + inline + void + p_graph_bkd_piter_::start() + { + id_ = pg_->nnodes() - 1; + if (is_valid()) + update_(); + } + + template<typename P> + inline + void + p_graph_bkd_piter_::next_() + { + --id_; + if (is_valid()) + update_(); + } + + template<typename P> + inline + void + p_graph_bkd_piter_::update_() + { + // Update psite_. + psite_ = graph_psite(*pg_, id_); + // Update p_. + p_ = pg_->point_from_id(id_); + } + + template<typename P> + inline + const P& + p_graph_bkd_piter_::to_point() const { + /* We don't check whether the iterator is valid before returning + the value using + mln_precondition(is_valid()); + + since this method may be called *before* the iterator is + actually initialized. This is the case for instance when this + point iterator (say, P) is used to initialize another iterator + on window or neighborhood (say, Q); most of the time, for_all() + is responsible for the initialization of P, but it takes place + *after* the creation of Q. */ return p_; } template<typename P> inline - p_graph_piter_::operator graph_psite() const + const graph_psite& + p_graph_bkd_piter_::to_psite() const + { + /* We don't check whether the iterator is valid before returning + the value using + + mln_precondition(is_valid()); + + since this method may be called *before* the iterator is + actually initialized. This is the case for instance when this + point iterator (say, P) is used to initialize another iterator + on window or neighborhood (say, Q); most of the time, for_all() + is responsible for the initialization of P, but it takes place + *after* the creation of Q. */ + return psite_; + } + + template<typename P> + inline + p_graph_bkd_piter_::operator graph_psite() const { mln_precondition(is_valid()); return psite_; } + + template <typename P> + inline + std::ostream& + operator<<(std::ostream& ostr, const p_graph_bkd_piter_& p) + { + // FIXME: We should use p.to_psite() here, but as it lacks the + // precondition the conversion operator has, we use the latter. + return ostr << static_cast< graph_psite >(p); + } + # endif // ! MLN_INCLUDE_ONLY } // end of mln -#endif // MLN_P_GRAPH_PITER_HH +#endif // ! MLN_CORE_P_GRAPH_PITER_HH Index: mln/core/p_graph.hh --- mln/core/p_graph.hh (revision 1769) +++ mln/core/p_graph.hh (working copy) @@ -40,8 +40,9 @@ namespace mln { - - template<typename P> class p_graph_piter_; + /* FIXME: Contray to, e.g., p_array, the sole parameter P of p_graph + is expected to be a point, not a psite!! We should have a + uniform scheme for point site sets. */ template<typename P> struct p_graph @@ -56,16 +57,19 @@ typedef graph_psite psite; /// Forward Point_Iterator associated type. - typedef p_graph_piter_ fwd_piter; + typedef p_graph_fwd_piter_ fwd_piter; /// Backward Point_Iterator associated type. - typedef p_graph_piter_ bkd_piter; + typedef p_graph_bkd_piter_ bkd_piter; - /// Return The number of points (i.e., nodes) in the graph. + /// Return The number of points (sites) of the set, i.e., the + /// number of \em vertices. std::size_t npoints() const; - /// Return The number of lines (i.e., edges) in the graph. - std::size_t nlines() const; + /// Return The number of nodes (vertices) in the graph. + std::size_t nnodes() const; + /// Return The number of edges in the graph. + std::size_t nedges() const; /// Give the exact bounding box. const box_& bbox() const; @@ -96,15 +100,27 @@ graph& to_graph(); - private: + // FIXME: Should be private. + public: graph gr_; // FIXME: (Roland) Is it really useful/needed? /* 2007-12-19: It seems so, since graph_image must implement a method named bbox(). Now the question is: should each image type have a bounding box? */ + private: box_ bb_; }; + + /// \brief Comparison between two mln::p_graph's. + /// + /// Two mln::p_graph's are considered equal if they have the + /// same address. + template <typename P> + bool + operator==(const p_graph& lhs, const p_graph& rhs); + + # ifndef MLN_INCLUDE_ONLY template<typename P> @@ -120,20 +136,26 @@ bb_ = a.to_result(); } - // FIXME: Rename to npsites? In fact, this depends on the - // interface expected from models of Point_Sets. template<typename P> inline std::size_t p_graph::npoints() const { + return nnodes(); + } + + template<typename P> + inline + std::size_t + p_graph::nnodes() const + { return this->gr_.nnodes(); } template<typename P> inline std::size_t - p_graph::nlines() const + p_graph::nedges() const { return this->gr_.nedges(); } @@ -238,6 +260,13 @@ } + template <typename P> + bool + operator==(const p_graph& lhs, const p_graph& rhs) + { + return &lhs == &rhs; + } + # endif // ! MLN_INCLUDE_ONLY } // end of mln Index: mln/draw/graph.hh --- mln/draw/graph.hh (revision 1769) +++ mln/draw/graph.hh (working copy) @@ -116,10 +116,10 @@ // Draw the background. level::fill(ima, 0); // Draw the lines (edges). - for (size_t l = 0; l < gi.domain().nlines(); ++l) + for (size_t l = 0; l < gi.domain().nedges(); ++l) line (exact(ima), gi.node1(l), gi.node2(l), link_v); // Draw the points (nodes). - for (size_t p = 0; p < gi.domain().npoints(); ++p) + for (size_t p = 0; p < gi.domain().nnodes(); ++p) exact(ima)(gi.domain().point_from_id(p)) = gi.node_values()[p]; }

1 0

1769: Fix mln::line_graph_image initializations and associated entitites.
by Roland Levillain 12 Mar '08

12 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix mln::line_graph_image initializations and associated entitites. * mln/core/line_graph_image.hh: Add some more documentation. (mln::init_(tag::image_t, line_graph_image<P,V>&, const line_graph_image<P,V>): Turn the signature of this routine into... (mln::init_(tag::image_t, line_graph_image<P,V>&, const line_graph_image<P,W>): ...this. Don't copy values from the model. Instead, initialize with a vector of the same size. (mln::line_graph_image<P, V>::line_graph_image(const p_line_graph&)): s/g.npoints()/g.nnodes()/. s/g.nlines()/g.nedges()/. (mln::line_graph_image<P, V>::init_): Ensure there are no data before initializing new ones. * mln/core/internal/image_morpher.hh: Remove spurious FIXMEs. * mln/core/line_graph_psite.hh (mln::line_graph_psite::point): Set typedef to P. (mln::line_graph_psite::operator[]): Adjust return type. (mln::line_graph_psite::line_graph_psite): New ctor. (mln::line_graph_psite::plg_): Change the type of this member from const p_line_graph& to const p_line_graph*. (line_graph_psite(const p_line_graph&, util::node_id)) (mln::line_graph_psite::operator= (const mln::line_graph_psite&)) (mln::line_graph_psite::to_point) (line_graph_psite::is_valid_): Adjust. (mln::line_graph_psite::plg): Likewise: ensure member plg_ is not null. (mln::line_graph_psite::id): Fix return type. (mln::line_graph_psite::first) (mln::line_graph_psite::second): New accessors. (mln::line_graph_psite::update_): Remove. (mln::line_graph_psite::operator P): Remove. (operator<<(std::ostream&, const line_graph_psite&)): Adjust implementation accordingly. (operator==(const line_graph_psite&, const line_graph_psite&)): New. internal/image_morpher.hh | 4 - line_graph_image.hh | 36 ++++++--------- line_graph_psite.hh | 106 +++++++++++++++++++++++++++++----------------- 3 files changed, 82 insertions(+), 64 deletions(-) Index: mln/core/line_graph_image.hh --- mln/core/line_graph_image.hh (revision 1768) +++ mln/core/line_graph_image.hh (working copy) @@ -107,21 +107,22 @@ } // end of namespace mln::trait - /*! \brief Kind of image based on graph structure. - * - */ + + /// \brief Image based on a graph. + /// + /// Values are stored on the vertices of the graph. template <typename P, typename V> struct line_graph_image : public internal::image_primary_< p_line_graph, line_graph_image<P, V> > { - + /// Super type. typedef mln::internal::image_base_< p_line_graph, line_graph_image<P, V> > super_; /// Value associated type. typedef V value; - /// Return type of read-write access. + /// \brief Return type of read-write access. /// /// We use the associated type \c reference instead of a plain /// reference on th value type (\v V), because it's the only way @@ -135,7 +136,6 @@ /// Value set associated type. typedef mln::value::set<value> vset; - /// Skeleton. typedef line_graph_image< tag::psite_, tag::value_<V> > skeleton; @@ -184,10 +184,10 @@ }; // Fwd decl. - template <typename P, typename V> + template <typename P, typename V, typename W> void init_(tag::image_t, line_graph_image<P, V>& target, - const line_graph_image<P, V>& model); + const line_graph_image<P, W>& model); # ifndef MLN_INCLUDE_ONLY @@ -196,17 +196,15 @@ | Initialization. | `-----------------*/ - /* FIXME: We should check the expected behavior of init_ here. As - far as I (Roland) can recall, it was not meant to initialize - data/values. We should probably just create vectors of values of - the same size, not copy the values. */ - template <typename P, typename V> + template <typename P, typename V, typename W> inline void init_(tag::image_t, line_graph_image<P, V>& target, - const line_graph_image<P, V>& model) + const line_graph_image<P, W>& model) { - target.init_(model.domain(), model.node_values(), model.edge_values()); + target.init_(model.domain(), + std::vector<V>(model.node_values().size()), + std::vector<V>(model.edge_values().size())); } /*-------. @@ -242,7 +240,7 @@ inline line_graph_image<P, V>::line_graph_image(const p_line_graph& g) { - init_(g, std::vector<V>(g.npoints()), std::vector<V>(g.nlines())); + init_(g, std::vector<V>(g.nnodes()), std::vector<V>(g.nedges())); } template <typename P, typename V> @@ -261,11 +259,7 @@ const std::vector<V>& node_val, const std::vector<V>& edge_val) { - /* FIXME: We leak memory here: calling init_ twice loses the - previous content pointed by data_. - - We should definitely write down formal guidelines on - initialization and memory management in general! */ + mln_precondition(! this->has_data()); this->data_ = new internal::data_< line_graph_image<P, V> >(g, node_val, edge_val); } Index: mln/core/internal/image_morpher.hh --- mln/core/internal/image_morpher.hh (revision 1768) +++ mln/core/internal/image_morpher.hh (working copy) @@ -55,13 +55,9 @@ typedef I delegatee; - /* FIXME: Change the interface of this method: return a reference - instead of a pointer. */ /// Return the delegatee_ pointer; default code. mlc_const(I)* delegatee_() const; - /* FIXME: Change the interface of this method: return a reference - instead of a pointer. */ /// Return the delegatee_ pointer (non-const version); default code. I* delegatee_(); Index: mln/core/line_graph_psite.hh --- mln/core/line_graph_psite.hh (revision 1768) +++ mln/core/line_graph_psite.hh (working copy) @@ -32,7 +32,6 @@ /// \brief Definition of a line graph-based point site. # include <mln/core/p_line_graph.hh> -# include <mln/core/point_pair.hh> /* FIXME: This class shares a lot with graph_psite. Factor as much as possible. */ @@ -52,7 +51,7 @@ typedef line_graph_psite self_; public: - typedef point_pair point; + typedef P point; typedef mln_mesh(point) mesh; enum { dim = point::dim }; typedef mln_dpoint(point) dpoint; @@ -60,9 +59,9 @@ /// Construction and assignment. /// \{ - line_graph_psite(const p_line_graph& plg_, unsigned id); + line_graph_psite(); + line_graph_psite(const p_line_graph& plg, unsigned id); line_graph_psite(const self_& rhs); - /// \pre This psite must have the same graph point set as \a rhs. self_& operator= (const self_& rhs); /// \} @@ -71,25 +70,27 @@ /// Access to point. /// \{ - operator point() const; const point& to_point() const; coord operator[](unsigned id) const; /// \} /// Return the mln::p_line_graph this point site belongs to. const p_line_graph& plg() const; - /// Return the node id of this point site. - util::node_id id() const; + /// Return the edge id of this point site. + util::edge_id id() const; + + /// Return the first associated point (vertex). + P first() const; + /// Return the second associated point (vertex). + P second() const; private: - /// Update \a p_. - void update_(); /// Is this psite valid? bool is_valid_() const; private: /// The p_line_graph this point site belongs to. - const p_line_graph& plg_; + const p_line_graph* plg_; /// The id of the edge this psite is pointing towards. util::edge_id id_; /** \brief The point associated to this psite. @@ -101,9 +102,17 @@ since points associated to edges are computed on the fly (storing them in the graph could be possible, but too costly in space). */ + // FIXME: Actually, this is a dummy value! point p_; }; + /// Compare two mln::line_graph_psite instances. + /* FIXME: Shouldn't this comparison be part of a much general + mechanism? */ + template <typename P> + bool + operator==(const line_graph_psite& lhs, const line_graph_psite& rhs); + /* FIXME: This hand-made delegation is painful. We should rely on the general mechanism provided by Point_Site. But then again, we need to refine/adjust the interface of Point_Site w.r.t. the @@ -123,9 +132,19 @@ template<typename P> inline - line_graph_psite::line_graph_psite(const p_line_graph& g, + line_graph_psite::line_graph_psite() + // Dummy initializations. + : plg_(0), + id_(-1), + p_() + { + } + + template<typename P> + inline + line_graph_psite::line_graph_psite(const p_line_graph& plg, util::edge_id id) - : plg_(g), + : plg_(&plg), id_(id), p_() { @@ -135,7 +154,8 @@ inline line_graph_psite::line_graph_psite(const line_graph_psite& rhs) : plg_(rhs.plg_), - id_(rhs.id_) + id_(rhs.id_), + p_() { } @@ -146,28 +166,17 @@ { if (&rhs == this) return *this; - // Assigning a psite from a line graph point set to a psite from - // another line graph point set is meaningless. - mln_assertion(&plg_ == &rhs.plg_); + plg_ = rhs.plg_; id_ = rhs.id_; - update_(); return *this; } template<typename P> inline - line_graph_psite::operator point_pair() const - { - mln_assertion (is_valid_()); - return p_; - } - - template<typename P> - inline bool line_graph_psite::is_valid_() const { - return id_ < plg_.gr_.nedges(); + return plg_ && id_ < plg_->gr_.nedges(); } template<typename P> @@ -180,15 +189,16 @@ template<typename P> inline - const point_pair& + const P& line_graph_psite::to_point() const { + // Dummy value. return p_; } template<typename P> inline - mln_coord(point_pair) + mln_coord(P) line_graph_psite::operator[](unsigned i) const { mln_assertion (is_valid_()); @@ -197,19 +207,11 @@ template<typename P> inline - void - line_graph_psite::update_() - { - p_ = point(plg_.gr_.node_data(plg_.gr_.edge(id_).n1()), - plg_.gr_.node_data(plg_.gr_.edge(id_).n2())); - } - - template<typename P> - inline const p_line_graph& line_graph_psite::plg() const { - return plg_; + mln_assertion(plg_); + return *plg_; } template<typename P> @@ -220,13 +222,39 @@ return id_; } + template<typename P> + inline + P + line_graph_psite::first() const + { + mln_assertion(is_valid_()); + return plg().gr_.node_data(plg().gr_.edge(id_).n1()); + } + + template<typename P> + inline + P + line_graph_psite::second() const + { + mln_assertion(is_valid_()); + return plg().gr_.node_data(plg().gr_.edge(id_).n2()); + } + + + template <typename P> + bool + operator==(const line_graph_psite& lhs, const line_graph_psite& rhs) + { + return &lhs.plg() == &rhs.plg() && lhs.id() == rhs.id(); + } + template <typename P> inline std::ostream& operator<<(std::ostream& ostr, const line_graph_psite& p) { - return ostr << p.to_point(); + return ostr << '(' << p.first() << " -- " << p.second() << ')'; } # endif // ! MLN_INCLUDE_ONLY

1 0

1768: Fix mln::graph_image initializations and associated entitites.
by Roland Levillain 12 Mar '08

12 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix mln::graph_image initializations and associated entitites. * mln/core/graph_image.hh: Add some more documentation. (mln::init_(tag::image_t, graph_image<P,V>&, const graph_image<P,V>): Turn the signature of this routine into... (mln::init_(tag::image_t, graph_image<P,V>&, const graph_image<P,W>): ...this. Don't copy values from the model. Instead, initialize with a vector of the same size. (mln::graph_image<P, V>::graph_image(const p_graph&)): s/g.npoints()/g.nnodes()/. (mln::graph_image<P, V>::init_): Ensure there are no data before initializing new ones. * mln/core/graph_psite.hh (mln::graph_psite::graph_psite): New ctor. (mln::graph_psite::pg_): Change the type of this member from const p_graph& to const p_graph*. (mln::graph_psite::graph_psite(const p_graph&, util::node_id)) (mln::graph_psite::operator= (const mln::graph_psite&)) (mln::graph_psite::to_point): Adjust. (mln::graph_psite::pg): Likewise: ensure member pg_ is not null. (mln::graph_psite::is_valid_): New method. Use it... (mln::graph_psite::operator[]): ...here. (mln::graph_psite::operator P): Remove. (operator==(const graph_psite&, const graph_psite&)): New. * mln/util/graph.hh, mln/util/internal/graph_base.hh: More FIXMEs. core/graph_image.hh | 31 +++++++++++------------- core/graph_psite.hh | 55 ++++++++++++++++++++++++++++++++------------ util/graph.hh | 2 + util/internal/graph_base.hh | 2 + 4 files changed, 59 insertions(+), 31 deletions(-) Index: mln/core/graph_image.hh --- mln/core/graph_image.hh (revision 1767) +++ mln/core/graph_image.hh (working copy) @@ -90,20 +90,21 @@ } // end of namespace mln::trait - /*! \brief Kind of image based on graph structure. - * - */ + + /// \brief Image based on a line graph. + /// + /// Values are stored on the edges of the graph, not on its vertices. template <typename P, typename V> struct graph_image : public internal::image_primary_< p_graph, graph_image<P, V> > { - + /// Super type. typedef mln::internal::image_base_< p_graph, graph_image<P, V> > super_; /// Value associated type. typedef V value; - /// Return type of read-write access. + /// \brief Return type of read-write access. /// /// We use the associated type \c reference instead of a plain /// reference on th value type (\v V), because it's the only way @@ -117,7 +118,6 @@ /// Value set associated type. typedef mln::value::set<value> vset; - /// Skeleton. typedef graph_image< tag::psite_, tag::value_<V> > skeleton; @@ -160,9 +160,9 @@ }; // Fwd decl. - template <typename P, typename V> + template <typename P, typename V, typename W> void init_(tag::image_t, - graph_image<P, V>& target, const graph_image<P, V>& model); + graph_image<P, V>& target, const graph_image<P, W>& model); # ifndef MLN_INCLUDE_ONLY @@ -171,12 +171,13 @@ | Initialization. | `-----------------*/ - template <typename P, typename V> + template <typename P, typename V, typename W> inline void init_(tag::image_t, - graph_image<P, V>& target, const graph_image<P, V>& model) + graph_image<P, V>& target, const graph_image<P, W>& model) { - target.init_(model.domain(), model.node_values ()); + target.init_(model.domain(), + std::vector<V>(model.node_values().size())); } /*-------. @@ -210,7 +211,7 @@ inline graph_image<P, V>::graph_image(const p_graph& g) { - init_(g, std::vector<V>(g.npoints())); + init_(g, std::vector<V>(g.nnodes())); } template <typename P, typename V> @@ -225,11 +226,7 @@ void graph_image<P, V>::init_(const p_graph& g, const std::vector<V>& val) { - /* FIXME: We leak memory here: calling init_ twice loses the - previous content pointed by data_. - - We should definitely write down formal guidelines on - initialization and memory management in general! */ + mln_precondition(! this->has_data()); this->data_ = new internal::data_< graph_image<P, V> > (g, val); } Index: mln/core/graph_psite.hh --- mln/core/graph_psite.hh (revision 1767) +++ mln/core/graph_psite.hh (working copy) @@ -56,9 +56,9 @@ /// Construction and assignment. /// \{ + graph_psite(); graph_psite(const p_graph& pg_, unsigned id); graph_psite(const self_& rhs); - /// \pre This psite must have the same graph point set as \a rhs. self_& operator= (const self_& rhs); /// \} @@ -67,7 +67,6 @@ /// Access to point. /// \{ - operator P() const; const point& to_point() const; coord operator[](unsigned id) const; /// \} @@ -78,20 +77,39 @@ util::node_id id() const; private: + /// Is this psite valid? + bool is_valid_() const; + + private: /// The p_graph this point site belongs to. - const p_graph& pg_; + const p_graph* pg_; /// The id of the node this psite is pointing towards. util::node_id id_; }; + /// Compare two mln::graph_psite instances. + /* FIXME: Shouldn't this comparison be part of a much general + mechanism? */ + template <typename P> + bool + operator==(const graph_psite& lhs, const graph_psite& rhs); # ifndef MLN_INCLUDE_ONLY template<typename P> inline + graph_psite::graph_psite() + // Dummy initializations. + : pg_(0), + id_(-1) + { + } + + template<typename P> + inline graph_psite::graph_psite(const p_graph& g, util::node_id id) - : pg_(g), + : pg_(&g), id_(id) { } @@ -111,26 +129,25 @@ { if (&rhs == this) return *this; - // Assigning a psite from a graph point set to a psite from - // another graph point set is meaningless. - mln_assertion(&pg_ == &rhs.pg_); + pg_ = rhs.pg_; id_ = rhs.id_; return *this; } template<typename P> inline - const graph_psite& - graph_psite::to_psite() const + bool + graph_psite::is_valid_() const { - return *this; + return pg_ && id_ < pg_->gr_.nnodes(); } template<typename P> inline - graph_psite::operator P() const + const graph_psite& + graph_psite::to_psite() const { - return pg_.point_from_id(id_); + return *this; } template<typename P> @@ -138,7 +155,7 @@ const P& graph_psite::to_point() const { - return pg_.point_from_id(id_); + return pg().point_from_id(id_); } template<typename P> @@ -146,6 +163,7 @@ mln_coord(P) graph_psite::operator[](unsigned i) const { + mln_assertion(is_valid_()); return to_point()[i]; } @@ -154,7 +172,8 @@ const p_graph& graph_psite::pg() const { - return pg_; + mln_assertion(pg_); + return *pg_; } template<typename P> @@ -165,6 +184,14 @@ return id_; } + template <typename P> + bool + operator==(const graph_psite& lhs, const graph_psite& rhs) + { + return &lhs.pg() == &rhs.pg() && lhs.id() == rhs.id(); + } + + # endif // ! MLN_INCLUDE_ONLY Index: mln/util/graph.hh --- mln/util/graph.hh (revision 1767) +++ mln/util/graph.hh (working copy) @@ -36,6 +36,8 @@ // FIXME: More doc! +// FIXME: Rename node(s) as vertex (vertices). + namespace mln { Index: mln/util/internal/graph_base.hh --- mln/util/internal/graph_base.hh (revision 1767) +++ mln/util/internal/graph_base.hh (working copy) @@ -39,6 +39,8 @@ # include <algorithm> # include <mln/util/ordpair.hh> +// FIXME: Rename node(s) as vertex (vertices). + namespace mln {

1 0

1767: Start a site/psite refactorization example.
by Nicolas Ballas 10 Mar '08

10 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Start a site/psite refactorization example. * sandbox/ballas/refactorization: New. * sandbox/ballas/refactorization/test: New. * sandbox/ballas/refactorization/test/test.cc: New. * sandbox/ballas/refactorization/metal: New. * sandbox/ballas/refactorization/metal/equal.hh: New. * sandbox/ballas/refactorization/metal/bool.hh: New. * sandbox/ballas/refactorization/metal/bexpr.hh: New. * sandbox/ballas/refactorization/exact.hh: New. * sandbox/ballas/refactorization/concept.hh: New. * sandbox/ballas/refactorization/internal: New. * sandbox/ballas/refactorization/internal/exact.hh: New. * sandbox/ballas/refactorization/internal/pset_base.hh: New. * sandbox/ballas/refactorization/internal/image_base.hh: New. * sandbox/ballas/refactorization/internal/piter_base.hh: New. * sandbox/ballas/refactorization/internal/site_base.hh: New. * sandbox/ballas/refactorization/internal/psite_base.hh: New. concept.hh | 182 +++++++++++++++++++++++++++++++++++++++++++++++++ exact.hh | 95 +++++++++++++++++++++++++ internal/exact.hh | 124 +++++++++++++++++++++++++++++++++ internal/image_base.hh | 39 ++++++++++ internal/piter_base.hh | 74 +++++++++++++++++++ internal/pset_base.hh | 22 +++++ internal/psite_base.hh | 40 ++++++++++ internal/site_base.hh | 21 +++++ metal/bexpr.hh | 80 +++++++++++++++++++++ metal/bool.hh | 99 ++++++++++++++++++++++++++ metal/equal.hh | 63 ++++++++++++++++ test/test.cc | 7 + 12 files changed, 846 insertions(+) Index: sandbox/ballas/refactorization/test/test.cc --- sandbox/ballas/refactorization/test/test.cc (revision 0) +++ sandbox/ballas/refactorization/test/test.cc (revision 0) @@ -0,0 +1,7 @@ +#include <internal/image_base.hh> + + +int main() +{ + return 0; +} Index: sandbox/ballas/refactorization/metal/equal.hh --- sandbox/ballas/refactorization/metal/equal.hh (revision 0) +++ sandbox/ballas/refactorization/metal/equal.hh (revision 0) @@ -0,0 +1,63 @@ +// 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 MLN_METAL_EQUAL_HH +# define MLN_METAL_EQUAL_HH + +/*! + * \file mln/metal/equal.hh + * + * \brief FIXME. + */ + +# include <metal/bool.hh> + + +# define mlc_equal(T1, T2) mln::metal::equal< T1, T2 > + + +namespace mln +{ + + namespace metal + { + + template <typename T1, typename T2> + struct equal : false_ + {}; + + template <typename T> + struct equal< T, T > : true_ + {}; + + + } // end of namespace mln::metal + +} // end of namespace mln + + +#endif // ! MLN_METAL_EQUAL_HH Index: sandbox/ballas/refactorization/metal/bool.hh --- sandbox/ballas/refactorization/metal/bool.hh (revision 0) +++ sandbox/ballas/refactorization/metal/bool.hh (revision 0) @@ -0,0 +1,99 @@ +// 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 MLN_METAL_BOOL_HH +# define MLN_METAL_BOOL_HH + +/*! \file mln/metal/bool.hh + * + * \brief Definition of a Boolean value type. + */ + +# include <string> + + +namespace mln +{ + + namespace metal + { + + // Fwd decl. + template <bool b> struct bool_; + + + /// "true" type. + template <> + struct bool_< true > + { + typedef bool_<true> check_t; + static const bool value = true; + typedef bool_<true> eval; + static void check(); + std::string name() const { return "true"; } + }; + + typedef bool_<true> true_; + + + /// "false" type. + template <> + struct bool_< false > + { + typedef bool_<false> check_not_t; + static const bool value = false; + typedef bool_<false> eval; + static void check_not(); + std::string name() const { return "false"; } + }; + + typedef bool_<false> false_; + + +# ifndef MLN_INCLUDE_ONLY + + inline + void true_::check() + { + } + + inline + void false_::check_not() + { + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::metal + +} // end of namespace mln + + +# include <metal/bexpr.hh> + + +#endif // ! MLN_METAL_BOOL_HH Index: sandbox/ballas/refactorization/metal/bexpr.hh --- sandbox/ballas/refactorization/metal/bexpr.hh (revision 0) +++ sandbox/ballas/refactorization/metal/bexpr.hh (revision 0) @@ -0,0 +1,80 @@ +// 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 MLN_METAL_BEXPR_HH +# define MLN_METAL_BEXPR_HH + +/*! \file mln/metal/bexpr.hh + * + * \brief Definition of types for static Boolean expressions. + */ + +# include <metal/bool.hh> + + +# define mlc_not( B ) mln::metal::not_ +# define mlc_and( B1, B2 ) mln::metal::and_< B1, B2 > +# define mlc_or( B1, B2 ) mln::metal::or_ < B1, B2 > +# define mlc_xor( B1, B2 ) mln::metal::xor_< B1, B2 > + + +namespace mln +{ + + namespace metal + { + + /// Negate type. + template <typename B> + struct not_ : bool_<( ! B::value )> + {}; + + + /// And type. + template <typename L, typename R> + struct and_ : bool_<( L::value && R::value )> + {}; + + + /// Or type. + template <typename L, typename R> + struct or_ : bool_<( L::value || R::value )> + {}; + + + /// Xor type. + template <typename L, typename R> + struct xor_ : bool_<( L::value ^ R::value )> + {}; + + + } // end of namespace mln::metal + +} // end of namespace mln + + +#endif // ! MLN_METAL_BOOL_HH Index: sandbox/ballas/refactorization/exact.hh --- sandbox/ballas/refactorization/exact.hh (revision 0) +++ sandbox/ballas/refactorization/exact.hh (revision 0) @@ -0,0 +1,95 @@ +// 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 MLN_CORE_EXACT_HH +# define MLN_CORE_EXACT_HH + +/*! \file mln/core/exact.hh + * \brief Definition of the mln::exact downcast routines. + */ + +#include <internal/exact.hh> + + +/// FIXME: Doc! +#define mln_exact(T) typename internal::exact_<T>::ret + + + +namespace mln +{ + + /*! \brief Exact cast routine for mln objects. + * + * This set of routines can be used to downcast an object towards + * its exact type. The only argument, respectively \p ptr or \p + * ref, should be an mln::Object. + * + * \c The parameter E is the exact type of the object. + * + * \return The return follows the nature of the argument (either a + * pointer or a reference, const or not). + */ + /// \{ + + template <typename T> + typename internal::exact_<T>::ret* + exact(T* ptr); + + template <typename T> + typename internal::exact_<T>::ret& + exact(T& ref); + + /// \} + + +# ifndef MLN_INCLUDE_ONLY + + // exact + + template <typename T> + inline + typename internal::exact_<T>::ret* + exact(T* ptr) + { + return internal::exact_<T>::run(ptr); + } + + template <typename T> + inline + typename internal::exact_<T>::ret& + exact(T& ref) + { + return *exact(&ref); + } + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + + +#endif // ! MLN_CORE_EXACT_HH Index: sandbox/ballas/refactorization/concept.hh --- sandbox/ballas/refactorization/concept.hh (revision 0) +++ sandbox/ballas/refactorization/concept.hh (revision 0) @@ -0,0 +1,182 @@ +#ifndef CORE_CONCEPT_HH_ +# define CORE_CONCEPT_HH_ + +# include <cassert> + +/// This file describes all the concepts + +namespace mln +{ + + /// Object + template <typename E> + struct Object + { + typedef E exact_t; + protected: + Object(); + }; + + /// Site concept + template <typename E> + struct Site : public Object<E> + { + /* + typedef site + typedef dsite; + + const psite& ref_(); + */ + protected: + Site(); + }; + + + /// Psite Concept + /// Do we need a concept for representing psite? + template <typename E> + struct Psite : public Object<E> + { + /* + // Site must be different from psite, + // if site = psite, then the psite has no sense. + typedef site; + typedef psite; + + // Site conversion + const site& to_site() const; + operator point() const; + + + const psite& ref_(); + */ + + protected: + Psite(); + }; + + /// Piter concept + /// Psite iterator + /// use template specializaion for psite == site or psite != psite + /// to deal with the cast problem + template <typename E> + struct Piter : public Object<E> + { + /* + bool is_valid() const; + void start(); + void next_(); + + typedef psite; + const psite& to_psite() const; + operator psite() const; + + typedef site; + const site& to_site() const; + operator site() const; + */ + + void next(); + protected: + Piter(); + }; + + /// Pset + /// Psite set + template <typename E> + struct Pset : public Object<E> + { + /* + typedef psite; + typedef fwd_piter; + typedef bkd_piter; + + bool has(const psite& p) const; + */ + protected: + Pset(); + }; + + + ///FIXME values concepts:.... + + /// Image concept: + template <typename E> + struct Image : public Object<E> + { + /* + typedef values; + typedef rvalues; + typedef lvalues; + //typedef vset; + //const vset& destination() const; + // const vset& values() const; + bool is_ready(); + + typedef site; + typedef psite; + rvalue operator() (const psite&) const; + lvalue operator() (const psite); + bool owns_(const psite&) const; + bool has(const psite&) const; + + typedef fwd_piter; + typedef bkd_piter; + */ + + protected: + Image(); + }; + + +# ifndef MLN_INCLUDE_ONLY + + /// Object + template <typename E> + inline + Object<E>::Object() + { + } + + /// Site + template <typename E> + inline + Site<E>::Site() + { + /// FIXME + } + + /// Psite + template <typename E> + inline + Psite<E>::Psite() + { + } + + /// Piter + template <typename E> + inline + Piter<E>::Piter() + { + } + + template <typename E> + void + Piter<E>::next() + { + exact(this)->next_(); + } + + template <typename E> + Image<E>::Image() + { + /// FIXME + } + +# endif // ! MLN_INCLUDE_ONLY + +} + + + +#endif // ! CORE_CONCEPT_HH_ Index: sandbox/ballas/refactorization/internal/exact.hh --- sandbox/ballas/refactorization/internal/exact.hh (revision 0) +++ sandbox/ballas/refactorization/internal/exact.hh (revision 0) @@ -0,0 +1,124 @@ +// 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 MLN_CORE_INTERNAL_EXACT_HH +# define MLN_CORE_INTERNAL_EXACT_HH + +/*! \file mln/core/internal/exact.hh + * \brief Meta-code for the mln::exact downcast routines. + */ + +# include <concept.hh> + +namespace mln +{ + + namespace internal + { + + typedef char yes_; + struct no_ { char dummy[2]; }; + + template <typename T> + struct make_ + { + static T* ptr(); + }; + + template <unsigned id, typename T> + struct exact_ret_; + + template <typename T> + struct exact_ret_< 1, T > + { + typedef typename T::exact_t ret; + }; + + template <typename T> + struct exact_ret_< 2, T > + { + typedef T ret; + }; + + template <typename E> + yes_ exact_selector_(Object<E>*); + + no_ exact_selector_(void*); + + template <typename E, typename T> + E* exact_run_(Object<E>* t, T*); + + template <typename T> + T* exact_run_(void*, T* t); + + template <typename T> + struct exact_ + { + enum { id = sizeof(exact_selector_(make_<T>::ptr())) }; + typedef typename exact_ret_<id, T>::ret ret; + static ret* run(T* t) + { + return exact_run_(t, t); + } + }; + + template <typename T> + struct exact_<const T> + { + enum { id = sizeof(exact_selector_(make_<T>::ptr())) }; + typedef const typename exact_ret_<id, T>::ret ret; + static ret* run(const T* t) + { + return exact_run_((T*)t, (T*)t); + } + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename E, typename T> + inline + E* exact_run_(Object<E>* t, T*) + { + return (E*)(void*)t; + } + + template <typename T> + inline + T* exact_run_(void*, T* t) + { + return t; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::internal + +} // end of namespace mln + + +#endif // ! MLN_CORE_INTERNAL_EXACT_HH Index: sandbox/ballas/refactorization/internal/pset_base.hh --- sandbox/ballas/refactorization/internal/pset_base.hh (revision 0) +++ sandbox/ballas/refactorization/internal/pset_base.hh (revision 0) @@ -0,0 +1,22 @@ +#ifndef INTERNAL_PSET_BASE_HH_ +# define INTERNAL_PSET_BASE_HH_ + + +namespace mln +{ + namespace internal + { + /// pset base class + /// P is the psite type + /// FIXME: psite = site => Do we declare a site + /// typedef in site_base class? + template <typename P, typename E> + struct pset_base_ + { + typedef typename P::site site; + typedef P psite; + }; + } +} + +#endif // ! INTENAL_PSET_BASE_HH_ Index: sandbox/ballas/refactorization/internal/image_base.hh --- sandbox/ballas/refactorization/internal/image_base.hh (revision 0) +++ sandbox/ballas/refactorization/internal/image_base.hh (revision 0) @@ -0,0 +1,39 @@ +#ifndef INTERNAL_IMAGE_BASE_HH_ +# define INTERNAL_IMAGE_BASE_HH_ + +#include <concept.hh> + +namespace mln +{ + namespace internal + { + /// Image base + /// S is the point set type + template <typename S, typename E> + struct image_base_ : public Image<E> + { + typedef S pset; + typedef typename S::psite psite; + typedef typename S::site site; + + typedef typename S::fwd_piter fwd_piter; + typedef typename S::bkd_piter bkd_piter; + + protected: + image_base_(); + }; + + ///FIXME: is_ready + +# ifndef MLN_INCLUDE_ONLY + + template <typename S, typename E> + image_base_<S, E>::image_base_() + { + } + +# endif // ! MLN_INCLUDE_ONLY + } +} + +#endif // ! INTERNAL_IMAGE_BASE_HH_ Index: sandbox/ballas/refactorization/internal/piter_base.hh --- sandbox/ballas/refactorization/internal/piter_base.hh (revision 0) +++ sandbox/ballas/refactorization/internal/piter_base.hh (revision 0) @@ -0,0 +1,74 @@ +#ifndef INTERNAL_PITER_BASE_HH_ +# define INTERNAL_PITER_BASE_HH_ + +# include <concept.hh> +# include <exact.hh> +# include <metal/bool.hh> +# include <metal/equal.hh> + +namespace mln +{ + + namespace internal + { + + /// fwd declaration + template <typename E, typename B> + struct piter_base_site_cast; + + /// Psite = Site + template <typename E> + struct piter_base_site_cast<E, metal::true_> : public Piter<E> + { + }; + + /// Psite != site + template <typename E> + struct piter_base_site_cast<E, metal::false_> : public Piter<E> + { + operator typename E::site() const; + }; + + /// Piter base + template <typename E> + struct piter_base_ : + public piter_base_site_cast<E, + typename mlc_equal(typename E::site, + typename E::psite)::eval> + { + operator typename E::psite() const; + + protected: + piter_base_(); + + }; + +# ifndef MLN_INCLUDE_ONLY + + template <typename E> + piter_base_site_cast<E, metal::false_>::operator typename E::site () const + { + return exact(this)->to_site(); + } + + + template <typename E> + piter_base_<E>::operator typename E::psite () const + { + return exact(this)->to_site(); + } + + + template <typename E> + piter_base_<E>::piter_base_() + { + } + +# endif // ! MLN_INCLUDE_ONLY + + } + +} + + +#endif // !INTERNAL_PITER_BASE_HH_ Index: sandbox/ballas/refactorization/internal/site_base.hh --- sandbox/ballas/refactorization/internal/site_base.hh (revision 0) +++ sandbox/ballas/refactorization/internal/site_base.hh (revision 0) @@ -0,0 +1,21 @@ +#ifndef INTERNAL_SITE_BASE_HH_ +# define INTERNAL_SITE_BASE_HH_ + +# include <concept> + +namespace mln +{ + namespace internal + { + + /// Site base class + template <typename S, typename E> + struct site_base_ : public site_base_<E> + { + typedef S site; + }; + } +} + + +#endif // ! INTERNAL_SITE_BASE_HH_ Index: sandbox/ballas/refactorization/internal/psite_base.hh --- sandbox/ballas/refactorization/internal/psite_base.hh (revision 0) +++ sandbox/ballas/refactorization/internal/psite_base.hh (revision 0) @@ -0,0 +1,40 @@ +#ifndef INTERNAL_PSITE_BASE_HH_ +# define INTERNAL_PSITE_BASE_HH_ + +# include <concept.hh> +# include <exact.hh> + +namespace mln +{ + namespace internal + { + + template <typename E> + struct psite_base : public Psite<E> + /// FIXME Get implementation + { + operator typename E::psite () const; + + protected: + psite_base(); + }; + +# ifndef MLN_INCLUDE_ONLY + + template <typename E> + psite_base<E>::operator typename E::psite () const + { + return exact(this)->to_site(); + } + + template <typename E> + psite_base<E>::psite_base() + { + } + +# endif // !MLN_INCLUDE_ONLY + + } +} + +#endif // ! INTERNAL_PSITE_BASE_HH_

1 0

1766: Subsampling. Draft icp.
by Ugo Jardonnet 06 Mar '08

06 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Subsampling. Draft icp. * mln/subsampling: New. * mln/subsampling/subsampling.hh: New. * mln/subsampling/gaussian_subsampling.hh: gaussian blur + subsampling. * mln/algebra: New. * mln/algebra/vec.hh: Copy of metal::vec. * sandbox/jardonnet/test/gaussian_subsampling.cc: New Test. * sandbox/jardonnet/subsampling/subsampling_2d.hh: Remove. * sandbox/jardonnet/subsampling/gaussian_subsampling.hh: New. * sandbox/jardonnet/registration: New. * sandbox/jardonnet/registration/icp.hh: Draft. mln/algebra/vec.hh | 562 ++++++++++++++++++ mln/linear/gaussian.hh | 1 mln/subsampling/gaussian_subsampling.hh | 93 ++ mln/subsampling/subsampling.hh | 117 +++ sandbox/jardonnet/registration/icp.hh | 122 +++ sandbox/jardonnet/subsampling/gaussian_subsampling.hh | 93 ++ sandbox/jardonnet/test/Makefile | 12 sandbox/jardonnet/test/gaussian_subsampling.cc | 21 sandbox/jardonnet/test/subsampling.cc | 6 9 files changed, 1021 insertions(+), 6 deletions(-) Index: mln/subsampling/subsampling.hh --- mln/subsampling/subsampling.hh (revision 0) +++ mln/subsampling/subsampling.hh (revision 0) @@ -0,0 +1,117 @@ +// Copyright (C) 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 +// 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 MLN_SUBSAMPLING_SUBSAMPLING_HH +# define MLN_SUBSAMPLING_SUBSAMPLING_HH + +/*! \file mln/binarization/threshold.hh + * + * \brief Produce a subsampled image + */ + +# include <mln/geom/ncols.hh> +# include <mln/geom/nrows.hh> + + +namespace mln +{ + + namespace subsampling + { + + /*! Subsampling FIXME : doxy + * + * + */ + template <typename I> + inline + mln_concrete(I) + subsampling(const Image& input, + const mln_dpoint(I)& first_p, + const mln_coord(I)& gap); + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + //FIXME : add version for every image types. + + template <typename T> + inline + mln_concrete(image2d<T>) + subsampling_(const image2d<T>& input, + const mln_dpoint(image2d<T>)& first_p, + const mln_coord(image2d<T>)& gap) + { + trace::entering("subsampling::impl::subsampling_"); + mln_concrete(image2d<T>) output(geom::nrows(input) / gap, + geom::ncols(input) / gap); + + for (unsigned j = 0; j < geom::ncols(output); ++j) + for (unsigned i = 0; i < geom::nrows(output); ++i) + { + point2d p1(i, j); + point2d p2(first_p[0] + i * gap, first_p[1] + j * gap); + + output(p1) = input(p2); + } + + trace::exiting("subsampling::impl::subsampling_"); + return output; + } + + } // end of namespace mln::subsampling::impl + + + template <typename I> + inline + mln_concrete(I) + subsampling(const Image& input, + const mln_dpoint(I)& first_p, + const mln_coord(I)& gap) + { + trace::entering("subsampling::subsampling"); + mln_precondition(exact(input).has_data()); + + mln_concrete(I) output(geom::nrows(input) / gap, + geom::ncols(input) / gap); // FIXME: only 2d here + + output = impl::subsampling_(exact(input), first_p, gap); + + trace::exiting("subsampling::subsampling"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::subsampling + +} // end of namespace mln + + +#endif // ! MLN_SUBSAMPLING_SUBSAMPLING_HH Index: mln/subsampling/gaussian_subsampling.hh --- mln/subsampling/gaussian_subsampling.hh (revision 0) +++ mln/subsampling/gaussian_subsampling.hh (revision 0) @@ -0,0 +1,93 @@ +// Copyright (C) 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 +// 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 MLN_SUBSAMPLING_GAUSSIAN_SUBSAMPLING_HH +# define MLN_SUBSAMPLING_GAUSSIAN_SUBSAMPLING_HH + +/*! \file mln/binarization/threshold.hh + * + * \brief Produce a subsampled image + */ + +# include <mln/geom/ncols.hh> +# include <mln/geom/nrows.hh> + + +# include <mln/linear/gaussian.hh> +# include <mln/subsampling/subsampling.hh> + + + +namespace mln +{ + + namespace subsampling + { + + /*! Gaussian subsampling FIXME : doxy + * + * + */ + template <typename I> + inline + mln_concrete(I) + gaussian_subsampling(const Image& input, float sigma + const mln_dpoint(I)& first_p, + const mln_coord(I)& gap); + +# ifndef MLN_INCLUDE_ONLY + + + template <typename I> + inline + mln_concrete(I) + gaussian_subsampling(const Image& input, float sigma, + const mln_dpoint(I)& first_p, + const mln_coord(I)& gap) + { + trace::entering("subsampling::gaussian_subsampling"); + mln_precondition(exact(input).has_data()); + + mln_concrete(I) temp(exact(input).domain()); + mln_concrete(I) output(geom::nrows(input) / gap, + geom::ncols(input) / gap); //FIXME : image2d only + + linear::gaussian(input, 0.1, temp); + output = impl::subsampling_(exact(temp), first_p, gap); + + trace::exiting("subsampling::gaussian_subsampling"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::subsampling + +} // end of namespace mln + + +#endif // ! MLN_SUBSAMPLING_GAUSSIAN_SUBSAMPLING_HH Index: mln/linear/gaussian.hh --- mln/linear/gaussian.hh (revision 1765) +++ mln/linear/gaussian.hh (working copy) @@ -1,3 +1,4 @@ + // Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development // Laboratory // Index: mln/algebra/vec.hh --- mln/algebra/vec.hh (revision 0) +++ mln/algebra/vec.hh (revision 0) @@ -0,0 +1,562 @@ +// Copyright (C) 2006 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 MLN_ALGEBRA_VEC_HH +# define MLN_ALGEBRA_VEC_HH + +/*! + * \file mln/algebra/vec.hh + * + * \brief Definition of a generic vector class. + */ + +# include <iostream> +# include <cmath> + +# include <mln/core/concept/object.hh> + +# include <mln/trait/all.hh> +# include <mln/trait/value_.hh> +# include <mln/fun/i2v/all_to.hh> +# include <mln/debug/format.hh> + +# include <mln/value/ops.hh> + + +// FIXME: Document. + + +namespace mln +{ + + // Fwd decls. + namespace algebra { + template <unsigned n, typename T> class vec; + } + namespace literal { + struct zero_t; + } + template <unsigned d, typename C> struct h_vec; + + + + namespace trait + { + + template <unsigned n, typename T> + struct value_< mln::algebra::vec<n,T> > + { + typedef trait::value::nature::vectorial nature; + typedef trait::value::kind::data kind; + + enum { + nbits = n * mln_nbits(T), + card = n * mln_card(T) + }; + typedef mln_value_quant_from_(card) quant; + + typedef algebra::vec<n, mln_sum(T)> sum; + }; + + } // end of namespace mln::trait + + + + namespace algebra + { + + namespace internal + { + + template <unsigned n, typename T> + class vec_base_ : public Object< vec<n,T> > + { + protected: + T data_[n]; + }; + + template <typename T> + class vec_base_ <1, T> : public Object< vec<1,T> > + { + public: + void set(const T& val0) + { + data_[0] = val0; + } + protected: + T data_[1]; + }; + + template <typename T> + class vec_base_ <2, T> : public Object< vec<2,T> > + { + public: + void set(const T& val0, const T& val1) + { + data_[0] = val0; + data_[1] = val1; + } + protected: + T data_[2]; + }; + + template <typename T> + class vec_base_ <3, T> : public Object< vec<3,T> > + { + public: + void set(const T& val0, const T& val1, const T& val2) + { + data_[0] = val0; + data_[1] = val1; + data_[2] = val2; + } + protected: + T data_[3]; + }; + + template <typename T> + class vec_base_ <4, T> : public Object< vec<4,T> > + { + public: + void set(const T& val0, const T& val1, const T& val2, const T& val3) + { + data_[0] = val0; + data_[1] = val1; + data_[2] = val2; + data_[3] = val3; + } + protected: + T data_[4]; + }; + + + } // end of namespace mln::algebra::internal + + + + template <unsigned n, typename T> + class vec : public internal::vec_base_<n, T> + { + typedef internal::vec_base_<n, T> super_; + + protected: + using super_::data_; + + public: + + typedef T equiv[n]; + typedef T enc[n]; + + typedef T coord; + enum { dim = n }; + + vec(); + + /// \{ Constructors/assignments with literal zero. + vec(const literal::zero_t&); + vec& operator=(const literal::zero_t&); + /// \} + + vec(const vec<n, T>& rhs); + + template <typename U> + vec(const vec<n, U>& rhs); + + template <typename U> + vec& operator=(const vec<n, U>& rhs); + + + // Immersion of the vector into its homogeneous space. + h_vec<n, T> to_h_vec() const; + + + const T& operator[](unsigned i) const; + + T& operator[](unsigned i); + + void set_all(const T& val); + + unsigned size() const; + + const vec<n, T>& normalize(); + + /// Constructor; coordinates are set by function \p f. + template <typename F> + vec(const Function_i2v<F>& f); + + /// Zero value. + static const vec<n, T> zero; + + /// Origin value. + static const vec<n, T> origin; + }; + + } // end of namespace mln::algebra + + + namespace trait + { + + // For unary traits. + + template < template <class> class Name, + unsigned n, typename T > + struct set_precise_unary_< Name, algebra::vec<n, T> > + { + typedef mln_trait_unary(Name, T) V; + typedef algebra::vec<n, V> ret; + }; + + // For binary traits. + + template < template <class, class> class Name, + unsigned n, typename T, + typename U > + struct set_precise_binary_< Name, + algebra::vec<n, T>, algebra::vec<n, U> > + { + typedef mln_trait_binary(Name, T, U) V; + typedef algebra::vec<n, V> ret; + }; + + template < unsigned n, typename T, + typename U > + struct set_precise_binary_< op::times, + algebra::vec<n, T>, algebra::vec<n, U> > + { + typedef mln_sum_x(T,U) ret; + }; + + template < template <class, class> class Name, + unsigned n, typename T, + typename S > + struct set_precise_binary_< Name, + algebra::vec<n, T>, mln::value::scalar_<S> > + { + typedef mln_trait_binary(Name, T, S) V; + typedef algebra::vec<n, V> ret; + }; + + template < template<class, class> class Name, + unsigned n, typename T, + typename S > + struct set_binary_< Name, + mln::Object, algebra::vec<n, T>, + mln::value::Scalar, S > + { + typedef mln_trait_binary(Name, T, S) V; + typedef algebra::vec<n, V> ret; + }; + + } // end of namespace mln::trait + + + + namespace algebra + { + + // eq + + template <unsigned n, typename T, typename U> + bool operator==(const vec<n,T>& lhs, const vec<n,U>& rhs); + + // + + + template <unsigned n, typename T, typename U> + vec<n, mln_trait_op_plus(T,U)> + operator+(const vec<n,T>& lhs, const vec<n,U>& rhs); + + // - + + template <unsigned n, typename T, typename U> + vec<n, mln_trait_op_minus(T,U)> + operator-(const vec<n,T>& lhs, const vec<n,U>& rhs); + + // vec * vec + + template <unsigned n, typename T, typename U> + mln_sum_x(T,U) + operator*(const vec<n,T>& lhs, const vec<n,U>& rhs); + + // vec * s + + template <unsigned n, typename T, typename S> + vec<n, mln_trait_op_times(T, S)> + operator*(const vec<n,T>& lhs, const mln::value::scalar_<S>& s); + + // vec / s + + template <unsigned n, typename T, typename S> + vec<n, mln_trait_op_div(T, S)> + operator/(const vec<n,T>& lhs, const mln::value::scalar_<S>& s); + + // << + + template <unsigned n, typename T> + std::ostream& + operator<<(std::ostream& ostr, const vec<n,T>& v); + + // vprod // FIXME: Generalize... + + template <typename T, typename U> + vec<3, mln_trait_op_times(T,U)> // FIXME: Sum of product... + vprod(const vec<3, T>& lhs, const vec<3, U>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + template <unsigned n, typename T> + inline + vec<n,T>::vec() + { + } + + template <unsigned n, typename T> + inline + vec<n,T>::vec(const literal::zero_t&) + { + this->set_all(0); + } + + template <unsigned n, typename T> + inline + vec<n,T>& + vec<n,T>::operator=(const literal::zero_t&) + { + this->set_all(0); + return *this; + } + + template <unsigned n, typename T> + inline + vec<n,T>::vec(const vec<n,T>& rhs) + : super_() + { + for (unsigned i = 0; i < n; ++i) + data_[i] = rhs[i]; + } + + template <unsigned n, typename T> + template <typename U> + inline + vec<n,T>::vec(const vec<n, U>& rhs) + : super_() + { + for (unsigned i = 0; i < n; ++i) + data_[i] = rhs[i]; + } + + template <unsigned n, typename T> + template <typename U> + inline + vec<n,T>& vec<n,T>::operator=(const vec<n, U>& rhs) + { + for (unsigned i = 0; i < n; ++i) + data_[i] = rhs[i]; + return *this; + } + + template <unsigned n, typename T> + inline + const T& vec<n,T>::operator[](unsigned i) const + { + mln_precondition(i < dim); + return data_[i]; + } + + template <unsigned n, typename T> + inline + T& vec<n,T>::operator[](unsigned i) + { + mln_precondition(i < dim); + return data_[i]; + } + + template <unsigned n, typename T> + inline + void vec<n,T>::set_all(const T& val) + { + for (unsigned i = 0; i < n; ++i) + data_[i] = val; + } + + template <unsigned n, typename T> + inline + unsigned vec<n,T>::size() const + { + return n; + } + + template <unsigned n, typename T> + inline + const vec<n, T>& vec<n, T>::normalize() + { + float n_l2 = 0; + for (unsigned i = 0; i < n; ++i) + n_l2 += data_[i] * data_[i]; + n_l2 = sqrt(n_l2); + for (unsigned i = 0; i < n; ++i) + data_[i] = T(data_[i] / n_l2); + return *this; + } + + template <unsigned n, typename T> + template <typename F> + inline + vec<n, T>::vec(const Function_i2v<F>& f_) + { + mlc_converts_to(mln_result(F), T)::check(); + const F& f = exact(f_); + for (unsigned i = 0; i < n; ++i) + data_[i] = f(i); + } + + + template <unsigned n, typename T> + const vec<n, T> vec<n, T>::zero = all_to(0); + + template <unsigned n, typename T> + const vec<n, T> vec<n, T>::origin = all_to(0); + + + // Operators. + + + template <unsigned n, typename T, typename U> + inline + bool operator==(const vec<n,T>& lhs, const vec<n,U>& rhs) + { + for (unsigned i = 0; i < n; ++i) + if (lhs[i] != rhs[i]) + return false; + return true; + } + + + template <unsigned n, typename T, typename U> + inline + vec<n, mln_trait_op_plus(T,U)> + operator+(const vec<n,T>& lhs, const vec<n,U>& rhs) + { + vec<n, mln_trait_op_plus(T,U)> tmp; + for (unsigned i = 0; i < n; ++i) + tmp[i] = lhs[i] + rhs[i]; + return tmp; + } + + template <unsigned n, typename T, typename U> + inline + vec<n, mln_trait_op_minus(T,U)> + operator-(const vec<n,T>& lhs, const vec<n,U>& rhs) + { + vec<n, mln_trait_op_minus(T,U)> tmp; + for (unsigned i = 0; i < n; ++i) + tmp[i] = lhs[i] - rhs[i]; + return tmp; + } + + template <unsigned n, typename T, typename U> + inline + mln_sum_x(T,U) + operator*(const vec<n,T>& lhs, const vec<n,U>& rhs) + { + mln_sum_x(T,U) tmp(literal::zero); + for (unsigned i = 0; i < n; ++i) + tmp += lhs[i] * rhs[i]; + return tmp; + } + + template <unsigned n, typename T, typename S> + inline + vec<n, mln_trait_op_times(T, S)> + operator*(const vec<n,T>& lhs, const mln::value::scalar_<S>& s) + { + // FIXME: We made a choice here but is it correct? + // FIXME: We "un-scalar" s so that the scalar status do not propagate. + + // Think of the case: vec<mat> v * scalar(vec w) s + // It gives: for all i, v[i] * w so the i-th mat * vec w -> vec + // The result is a vec<vec> + + // If we really want to propage the "scalar" status then + // we shall allow for scalar(scalar(..)) !!! => FIXME + + vec<n, mln_trait_op_times(T, S)> tmp; + for (unsigned i = 0; i < n; ++i) + tmp[i] = lhs[i] * s.to_equiv(); + return tmp; + } + + template <unsigned n, typename T, typename S> + inline + vec<n, mln_trait_op_div(T, S)> + operator/(const vec<n,T>& lhs, const mln::value::scalar_<S>& s) + { + mln_precondition(value::equiv(s) != literal::zero); + vec<n, mln_trait_op_div(T, S)> tmp; + for (unsigned i = 0; i < n; ++i) + tmp[i] = lhs[i] / s.to_equiv(); + return tmp; + } + + + template <unsigned n, typename T> + inline + std::ostream& + operator<<(std::ostream& ostr, const vec<n,T>& v) + { + ostr << '('; + for (unsigned i = 0; i < n; ++i) + ostr << debug::format(v[i]) << (i == n - 1 ? ")" : ", "); + return ostr; + } + + // vprod + + template <typename T, typename U> + inline + vec<3, mln_trait_op_times(T,U)> // FIXME: typename binary_arith_trait<T, U>::ret> + vprod(const vec<3, T>& lhs, const vec<3, U>& rhs) + { + vec<3, mln_trait_op_times(T,U)> tmp; // FIXME: Likewise. + tmp[0] = lhs[1] * rhs[2] - lhs[2] * rhs[1]; + tmp[1] = lhs[2] * rhs[0] - lhs[0] * rhs[2]; + tmp[2] = lhs[0] * rhs[1] - lhs[1] * rhs[0]; + return tmp; + } + +# endif // MLN_INCLUDE_ONLY + + } // end of namespace mln::algebra + +} // end of namespace mln + + +# include <mln/make/vec.hh> + + +#endif // ! MLN_ALGEBRA_VEC_HH Index: sandbox/jardonnet/test/gaussian_subsampling.cc --- sandbox/jardonnet/test/gaussian_subsampling.cc (revision 0) +++ sandbox/jardonnet/test/gaussian_subsampling.cc (revision 0) @@ -0,0 +1,21 @@ +#include <mln/core/image2d.hh> + +#include <mln/io/pgm/load.hh> +#include <mln/io/pgm/save.hh> + +#include <sandbox/jardonnet/subsampling/gaussian_subsampling.hh> + + +int main(int argc, char*) +{ + using namespace mln; + using value::int_u8; + + image2d<int_u8> img; + + io::pgm::load(img, "../../../img/lena.pgm"); + + image2d<int_u8> output = subsampling::gaussian_subsampling(img, make::dpoint2d(1,1), argc); + + io::pgm::save(output, "gsub.pgm"); +} Index: sandbox/jardonnet/test/subsampling.cc --- sandbox/jardonnet/test/subsampling.cc (revision 1765) +++ sandbox/jardonnet/test/subsampling.cc (working copy) @@ -3,7 +3,7 @@ #include <mln/io/pgm/load.hh> #include <mln/io/pgm/save.hh> -#include <sandbox/jardonnet/subsampling/subsampling_2d.hh> +#include <mln/subsampling/subsampling.hh> int main(int argc, char*) @@ -16,7 +16,7 @@ io::pgm::load(img, "../../../img/lena.pgm"); std::cout << geom::nrows(img) << geom::ncols(img) << std::endl; - image2d<int_u8> output = subsampling::subsampling_2d(img, make::dpoint2d(1,1), argc); + image2d<int_u8> output = subsampling::subsampling(img, make::dpoint2d(1,1), argc); - io::pgm::save(output, "out1.pgm"); + io::pgm::save(output, "sub.pgm"); } Index: sandbox/jardonnet/test/Makefile --- sandbox/jardonnet/test/Makefile (revision 1765) +++ sandbox/jardonnet/test/Makefile (working copy) @@ -1,8 +1,14 @@ SOURCE=test.cc subsampling.cc FLAG=-Wall -W -I../../.. -g -all: - g++ $(SOURCE) $(FLAG) -o '+a.out' +all: sub gsub + sub: - g++ subsampling.cc $(FLAG) -o '+a.out' + g++ subsampling.cc $(FLAG) -o '+sub.exe' + +gsub: + g++ gaussian_subsampling.cc $(FLAG) -o '+gsub.exe' + +run: + time ./+sub.exe . . ; time ./+gsub.exe . . \ No newline at end of file Index: sandbox/jardonnet/subsampling/gaussian_subsampling.hh --- sandbox/jardonnet/subsampling/gaussian_subsampling.hh (revision 0) +++ sandbox/jardonnet/subsampling/gaussian_subsampling.hh (revision 0) @@ -0,0 +1,93 @@ +// Copyright (C) 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 +// 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 MLN_SUBSAMPLING_GAUSSIAN_SUBSAMPLING_HH +# define MLN_SUBSAMPLING_GAUSSIAN_SUBSAMPLING_HH + +/*! \file mln/binarization/threshold.hh + * + * \brief Produce a subsampled image + */ + +# include <mln/geom/ncols.hh> +# include <mln/geom/nrows.hh> + + +# include <mln/linear/gaussian.hh> +# include <mln/subsampling/subsampling.hh> + + + +namespace mln +{ + + namespace subsampling + { + + /*! Subsampling FIXME : doxy + * + * + */ + template <typename I> + inline + mln_concrete(I) + gaussian_subsampling(const Image& input, float sigma + const mln_dpoint(I)& first_p, + const mln_coord(I)& gap); + +# ifndef MLN_INCLUDE_ONLY + + + template <typename I> + inline + mln_concrete(I) + gaussian_subsampling(const Image& input, float sigma, + const mln_dpoint(I)& first_p, + const mln_coord(I)& gap) + { + trace::entering("subsampling::gaussian_subsampling"); + mln_precondition(exact(input).has_data()); + + mln_concrete(I) temp(exact(input).domain()); + mln_concrete(I) output(geom::nrows(input) / gap, + geom::ncols(input) / gap); //FIXME : only for image2d. + + linear::gaussian(input, 0.1, temp); + output = impl::subsampling_(exact(temp), first_p, gap); + + trace::exiting("subsampling::gaussian_subsampling"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::subsampling + +} // end of namespace mln + + +#endif // ! MLN_SUBSAMPLING_GAUSSIAN_SUBSAMPLING_HH Index: sandbox/jardonnet/registration/icp.hh --- sandbox/jardonnet/registration/icp.hh (revision 0) +++ sandbox/jardonnet/registration/icp.hh (revision 0) @@ -0,0 +1,122 @@ +// Copyright (C) 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 +// 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 MLN_REGISTRATION_REGISTRATION_HH +# define MLN_REGISTRATION_REGISTRATION_HH + +/*! \file mln/binarization/threshold.hh + * + * \brief Produce a subsampled image + */ + +# include <mln/value/quat.hh> +# include <mln/algebra/vec.hh> + +namespace mln +{ + + namespace registration + { + + /*! Registration FIXME : doxy + * + * + */ + template <typename I> + inline + void + icp(const Image& cloud, + const Image<J>& surface); + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + //FIXME : add version for every image types. + + template <typename I, typename J> + inline + void + icp_(const I& P, + const J& X) + { + trace::entering("registration::impl::icp_"); + + mln_concrete(I) Pk(cloud.domain()); + + const float epsilon = 1e-3; + float err, err_bis; + quat old_qk, qk; + unsigned int k; + + + k = 0; + Pk = P; + do { + //projection + + old_qk = qk; + + //qk = match(P, mu_P, Xk, mu_Xk); + + // error = + + } while (k < 3 || (qk - old_qk).sqr_norm() > epsilon); + + + trace::exiting("registration::impl::icp_"); + } + + } // end of namespace mln::registration::impl + + + template <typename I, typename J> + inline + void + icp(const Image& cloud, + const Image<J>& surface) + { + trace::entering("registration::icp"); + mln_precondition(exact(cloud).has_data()); + mln_precondition(exact(surface).has_data()); + + output = impl::icp_(exact(cloud), exact(surface)); + + trace::exiting("registration::icp"); + } + + //cloud == image ? + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::registration + +} // end of namespace mln + + +#endif // ! MLN_REGISTRATION_ICP_HH

1 0

1765: Fix bgraph_image construction bug.
by Nicolas Ballas 05 Mar '08

05 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Fix bgraph_image construction bug. * tests/core/bgraph_image.cc, * tests/core/p_bgraph.cc: update the tests. * mln/core/p_bgraph_piter.hh, * mln/core/bgraph_image.hh, * mln/core/p_bgraph.hh, * mln/core/bgraph_psite.hh: fix the bug (thanks to Theo). mln/core/bgraph_image.hh | 29 ++++++++++------------------- mln/core/bgraph_psite.hh | 4 +--- mln/core/p_bgraph.hh | 37 ++++++++++++++++++------------------- mln/core/p_bgraph_piter.hh | 22 ++++++++++++---------- tests/core/bgraph_image.cc | 23 ++++++++++++++++++----- tests/core/p_bgraph.cc | 2 +- 6 files changed, 60 insertions(+), 57 deletions(-) Index: tests/core/bgraph_image.cc --- tests/core/bgraph_image.cc (revision 1764) +++ tests/core/bgraph_image.cc (working copy) @@ -29,8 +29,13 @@ /// \brief Tests on mln::bgraph_image. #include <vector> -#include <mln/core/point2d.hh> + +#include <mln/value/int_u8.hh> +#include <mln/core/image2d.hh> #include <mln/core/bgraph_image.hh> +#include <mln/level/fill.hh> +#include <mln/level/paste.hh> +#include <mln/debug/println.hh> @@ -56,7 +61,7 @@ const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]); // declare a graph object - Graph g(num_vertices); + Graph& g = *new Graph(num_vertices); // add the edges to the graph object for (int i = 0; i < num_edges; ++i) @@ -85,10 +90,18 @@ values.push_back(4); values.push_back(5); - ima_type ima(g, values); + ima_type ima(&g, values); mln_piter_(ima_type) p(ima.domain()); for_all(p) - std::cout << ima(p) << std::endl; + std::cout < ima_(ima.bbox()); + level::fill(ima_, 0); + level::paste(ima, ima_); + debug::println(ima_); + } - return 0; + delete &g; } Index: tests/core/p_bgraph.cc --- tests/core/p_bgraph.cc (revision 1764) +++ tests/core/p_bgraph.cc (working copy) @@ -73,7 +73,7 @@ `-----------*/ /// Creation - p_bgraph<point2d> pset(g); + p_bgraph<point2d> pset(&g); /// Iterator p_bgraph_piter_<point2d> p(pset); Index: mln/core/p_bgraph_piter.hh --- mln/core/p_bgraph_piter.hh (revision 1764) +++ mln/core/p_bgraph_piter.hh (working copy) @@ -106,6 +106,7 @@ private: iterators_type_ iterators_; + typename p_bgraph::node_iterator cur_; }; @@ -120,9 +121,7 @@ psite_(pg, pg_.npoints()), p_() { - // Initialize the iterators - start(); - + iterators_ = boost::vertices(pg_.to_graph()); // Invalidate id_. invalidate(); } @@ -140,7 +139,7 @@ bool p_bgraph_piter_::is_valid() const { - return iterators_.first != iterators_.second; + return cur_ != iterators_.second; } template<typename P> @@ -148,7 +147,7 @@ void p_bgraph_piter_::invalidate() { - iterators_.first == iterators_.second; + cur_ = iterators_.second; // Past the end iterator. } template<typename P> @@ -156,8 +155,9 @@ void p_bgraph_piter_::start() { + cur_ = iterators_.first; /// FIXME: Hide implementation details? - iterators_ = boost::vertices(pg_.to_graph()); + if (is_valid()) update_(); } @@ -166,7 +166,8 @@ void p_bgraph_piter_::next_() { - ++iterators_.first; + ++cur_; + if (is_valid()) update_(); } @@ -176,9 +177,9 @@ p_bgraph_piter_::update_() { // Update psite_. - psite_ = bgraph_psite(pg_, *iterators_.first); + psite_ = bgraph_psite(pg_, *cur_); // Update p_. - p_ = pg_.point_from_id(*iterators_.first); + p_ = pg_.point_from_id(*cur_); } template<typename P> @@ -233,7 +234,8 @@ p_bgraph_piter_::operator bgraph_psite() const { mln_precondition(is_valid()); - return psite_; + bgraph_psite tmp(pg_, *cur_); + return tmp; // psite_; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/bgraph_image.hh --- mln/core/bgraph_image.hh (revision 1764) +++ mln/core/bgraph_image.hh (working copy) @@ -53,15 +53,15 @@ template <typename P, typename V> struct data_< bgraph_image<P, V> > { + /// Data stores a **copy** of the pset g. + /// But, the pset g and the data_ copy will shared the same + /// underlaying graph. data_(const p_bgraph& g, const std::vector<V>& val); + + p_bgraph pg_; + std::vector<V> val_; - /* The graph point set is handled by address, so that we can - check the compatibility of images w.r.t. to their point - sites. We could use a safer (and more complex) facility to - ensure (memory) equality of line graph point sets, but using - addresses is simple and efficient enough for the moment. */ - const p_bgraph& pg_; }; } // end of namespace mln::internal @@ -76,7 +76,6 @@ { typedef trait::image::category::primary category; - // FIXME: Is that right? typedef trait::image::access::random access; typedef typename trait::image::space_from_point::ret space; typedef trait::image::size::regular size; @@ -85,7 +84,6 @@ typedef trait::image::border::none border; typedef trait::image::data::stored data; typedef trait::image::io::read_write io; - // FIXME: Is that right? typedef trait::image::speed::fast speed; }; @@ -150,8 +148,6 @@ const std::vector<V>& node_values() const; /// \} - /* FIXME: Do we want to provide these two methods? (at least, in - the interface of the class? */ /// Return the point of the first node adjacent to the edge with /// id \a e. @@ -191,8 +187,8 @@ inline data_< bgraph_image<P, V> >::data_(const p_bgraph& g, const std::vector<V>& val) - : val_ (val), - pg_ (g) + : pg_ (g), + val_ (val) { } @@ -228,11 +224,6 @@ void bgraph_image<P, V>::init_(const p_bgraph& g, const std::vector<V>& val) { - /* FIXME: We leak memory here: calling init_ twice loses the - previous content pointed by data_. - - We should definitely write down formal guidelines on - initialization and memory management in general! */ this->data_ = new internal::data_< bgraph_image<P, V> > (g, val); } @@ -245,7 +236,7 @@ typename bgraph_image<P, V>::rvalue bgraph_image<P, V>::operator()(const bgraph_psite& p) const { - mln_precondition(&p.pg() == &this->data_->pg_); + mln_precondition(&p.pg().to_graph() == &this->data_->pg_.to_graph()); mln_precondition(p.id() < this->data_->val_.size()); return this->data_->val_[p.id()]; } @@ -255,7 +246,7 @@ typename bgraph_image<P, V>::lvalue bgraph_image<P, V>::operator()(const bgraph_psite& p) { - mln_precondition(&p.pg() == &this->data_->pg_); + mln_precondition(&p.pg().to_graph() == &this->data_->pg_.to_graph()); mln_precondition(p.id() < this->data_->val_.size()); return this->data_->val_[p.id()]; } Index: mln/core/p_bgraph.hh --- mln/core/p_bgraph.hh (revision 1764) +++ mln/core/p_bgraph.hh (working copy) @@ -53,9 +53,6 @@ { typedef util::internal::boost_graph<P, util::empty> graph; - /// Construct a graph psite set from a graph of points. - p_bgraph (graph& gr); - /// Point_Site associated type. typedef bgraph_psite psite; @@ -75,6 +72,11 @@ typedef std::pair<node_iterator, node_iterator> node_iterators; + /// Construct a graph psite set from a graph of points. + /// \p gr is a pointer on a boost graph. + /// This boost graph must have been allocated dynamically. + p_bgraph (graph* gr); + /// Return The number of points (i.e., nodes) in the graph. std::size_t npoints() const; @@ -103,11 +105,7 @@ private: - graph gr_; - // FIXME: (Roland) Is it really useful/needed? - /* 2007-12-19: It seems so, since graph_image must implement a method - named bbox(). Now the question is: should each image type have a - bounding box? */ + graph* gr_; box_ bb_; }; @@ -115,17 +113,18 @@ template<typename P> inline - p_bgraph::p_bgraph (typename p_bgraph::graph& gr) + p_bgraph::p_bgraph (typename p_bgraph::graph* gr) : gr_ (gr) { + mln_precondition(gr != 0); // FIXME: Warning: if the underlying graph is updated later, this // won't be taken into account by this p_bgraph! accu::bbox a; - for (node_iterators iter = boost::vertices(gr_); + for (node_iterators iter = boost::vertices(*gr_); iter.first != iter.second; ++iter.first) - a.take(gr_[*iter.first]); + a.take((*gr_)[*iter.first]); bb_ = a.to_result(); } @@ -134,7 +133,7 @@ std::size_t p_bgraph::npoints() const { - return boost::num_vertices((gr_)); + return boost::num_vertices(*gr_); } template<typename P> @@ -142,7 +141,7 @@ std::size_t p_bgraph::nlines() const { - return boost::num_edges(gr_.nedges()); + return boost::num_edges(gr_->nedges()); } template<typename P> @@ -170,14 +169,14 @@ const P& p_bgraph::point_from_id(const typename p_bgraph::node_id& id) const { - return this->gr_[id]; + return this->gr_->operator[](id); } template <typename P> P& p_bgraph::point_from_id(const typename p_bgraph::node_id& id) { - return this->gr_[id]; + return this->gr_->operator[](id); } @@ -187,7 +186,7 @@ const P& p_bgraph::node1(const typename p_bgraph::edge_id& e) const { - return this->point_from_id(source(e, this->gr_)); + return this->point_from_id(source(e, *this->gr_)); } /// FIXME: same as node1... @@ -195,21 +194,21 @@ const P& p_bgraph::node2(const typename p_bgraph::edge_id& e) const { - return this->point_from_id(target(e, this->gr_)); + return this->point_from_id(target(e, *this->gr_)); } template <typename P> const typename p_bgraph::graph& p_bgraph::to_graph() const { - return this->gr_; + return *this->gr_; } template <typename P> typename p_bgraph::graph& p_bgraph::to_graph() { - return this->gr_; + return *this->gr_; } Index: mln/core/bgraph_psite.hh --- mln/core/bgraph_psite.hh (revision 1764) +++ mln/core/bgraph_psite.hh (working copy) @@ -85,8 +85,6 @@ typename p_bgraph::node_id id_; }; - - # ifndef MLN_INCLUDE_ONLY template<typename P> @@ -118,7 +116,7 @@ return *this; // Assigning a psite from a graph point set to a psite from // another graph point set is meaningless. - mln_assertion(&pg_ == &rhs.pg_); + mln_assertion(&pg_.to_graph() == &rhs.pg_.to_graph()); id_ = rhs.id_; return *this; }

1 0

1764: Augment tutorial on image types.
by Thierry Geraud 05 Mar '08

05 Mar '08

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Augment tutorial on image types. * milena/doc/tutorial/image_types.txt: Augment. image_types.txt | 129 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 128 insertions(+), 1 deletion(-) Index: milena/doc/tutorial/image_types.txt --- milena/doc/tutorial/image_types.txt (revision 1763) +++ milena/doc/tutorial/image_types.txt (working copy) @@ -59,6 +59,14 @@ for all v of ima.values | print v. +For such image types, we have several points (sites) associated with a +single value cell. It is rather different from having couples (p,v); +we actually have one value cell -> a set of points. Such data +structure allows for compressing data because each value cell is +shared by several points. + +*** Example 1 + Consider for instance the following image: +-----+ @@ -67,6 +75,8 @@ | 22 | +-----+ +We have one value per run. + The value type is int_u2 (unsigned integer on 2 bit), that is, the type of the interval [0,3] of N. The image is defined by a run-length encoding with a single value per run. Precisely, this image is: @@ -93,6 +103,115 @@ v v v { ((a,1),2), ((b,3),1), ((c,2),2) } +**** A clue? + +***** part 1 + +When we have value cells, it is usually related to the fact that the +image is not point-wise writable. For instance, with the image type +having one value per run, the operation "ima(p) := v" is not possible. +Otherwise, that would mean that a run is split on such a write access, +which is too slow (thus not allowed). + +Some rare image types can be both point-wise writable and value cell +iterable. For instance: + + image<int_u8> data; + map<int_u8, rgb_3x8> lut; // with i != j => lut[i] != lut[j] + map<rgb_3x8, int_u8> reverse_lut; + +The keys, resp. the values, of the lut are the values, resp. the keys, +of the reverse_lut. With this structure, we can have a rather efficient +point-wise writable image. + +ima(p) <- v { + it <- reverse_lut.find(v) + if (it is not found) + ++n + lut(n) <- v + reverse_lut(v) <- n + data(p) <- n + else + data(p) <- it.key +} + +***** part 2 + +When an image is value-wise writable, we can form: + ima.value(red) = blue; +It means that we can quickly access to the cell (or the cells) +having the value 'red'. + +When an image is value-cell writable, we can have: + for v in ima.values() + ima.cell(v) = v' +In that case, a 'v' is a value cell, not a value. + +***** part 3 + +Is the notion of value-wise readable relevant? + ima.value(red) // read-access +gives: + - red, which is dummy! +or - the corresponding point set, which can be great! + +This is another property... + + +*** Example 2 + +Consider this image type: + +{ data + +-----------+ + | 0 2 1 0 2 | + | 0 0 3 2 1 | + | 2 1 2 2 0 | + +-----------+; + lut + +---+---------------+ + | 0 | (255, 0, 0) | red (r) + | 1 | (127,127,127) | medium grey (m) + | 2 | ( 0, 0,255) | blue (b) + | 3 | (127,127,127) | medium grey (m) again + +---+---------------+ +} + +This image is defined with a look-up table; its external +representation actually is: + + +-----------+ + | r b m r b | + | r r m b m | + | b m b b r | + +-----------+ + +(conversely, the internal representation is the 'data' image.) + +We have I::value = rgb_3x8 +so the image appears to be highly quantized (24 bit). + +Yet the number of possible values is limited (here up to 4, even if +two value cells are identical) and stored by the image in the look-up +table. + +It leads to: + code A) rbmrbrrmbmbmbbr + code B) rmb + code C) rmbm + +ima.destination (browsed by code B) is an instance of +value::subset<rgb_3x8>. + +FIXME: OR (?) + +It leads to: + code A) rbmrbrrmbmbmbbr + code B) impossible because 24bit data + code C) rmbm + +and I.destination gives value::set<rgb_3x8>. + ** associated types @@ -232,7 +351,15 @@ | + -- high -**** +**** low + +I::value defines a set of possible values whose cardinality is less +than or equal to 2^16. + +FIXME: OR (?) + +I.destination (same definition) + *** value |

1 0