Olena-patches April 2008

olena-patches@lrde.epita.fr

11 participants
119 discussions

1905: Speed up iterations on graph windows and neighborhoods.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Speed up iterations on graph windows and neighborhoods. * mln/core/internal/graph_vicinity_piter.hh (mln::internal::graph_vicinity_piter_<P, E>::graph_vicinity_piter_): Make this ctor protected. No longer invalidate the iterator. (mln::internal::graph_vicinity_piter_<P, E>::is_valid) (mln::internal::graph_vicinity_piter_<P, E>::invalidate) (mln::internal::graph_vicinity_piter_<P, E>::adjacent_to_p_ref_) (mln::internal::graph_vicinity_piter_<P, E>::adjacent_or_equal_to_p_ref_) (mln::internal::graph_vicinity_piter_<P, E>::update_): Remove. (mln::internal::graph_vicinity_piter_<P, E>::p_ref) (mln::internal::graph_vicinity_piter_<P, E>::pg) (mln::internal::graph_vicinity_piter_<P, E>::sites): New accessors. (mln::internal::graph_vicinity_piter_<P, E>::saved_p_ref_) (mln::internal::graph_vicinity_piter_<P, E>::p_ref_): New members. * mln/core/graph_window_piter.hh (mln::graph_window_fwd_piter::is_valid) (mln::graph_window_fwd_piter::invalidate) (mln::graph_window_fwd_piter::update) (mln::graph_window_bkd_piter::is_valid) (mln::graph_window_bkd_piter::invalidate) (mln::graph_window_bkd_piter::update): New methods. (mln::graph_window_fwd_piter::first_) (mln::graph_window_fwd_piter::step_) (mln::graph_window_bkd_piter::first_) (mln::graph_window_bkd_piter::step_): Remove methods. (mln::graph_window_fwd_piter::i_) (mln::graph_window_bkd_piter::i_): New members. (mln::graph_window_fwd_piter::graph_window_fwd_piter) (mln::graph_window_bkd_piter::graph_window_bkd_piter): Invalidate member i_. (mln::graph_window_fwd_piter::start) (mln::graph_window_fwd_piter::next) (mln::graph_window_bkd_piter::start) (mln::graph_window_bkd_piter::next): Change the algorithms used in these routines, so that they use a list of computed sites (super member sites_) instead of iterating over the whole set of vertices. * mln/core/graph_neighborhood_piter.hh: (mln::graph_neighborhood_fwd_piter::is_valid) (mln::graph_neighborhood_fwd_piter::invalidate) (mln::graph_neighborhood_fwd_piter::update) (mln::graph_neighborhood_bkd_piter::is_valid) (mln::graph_neighborhood_bkd_piter::invalidate) (mln::graph_neighborhood_bkd_piter::update): New methods. (mln::graph_neighborhood_fwd_piter::first_) (mln::graph_neighborhood_fwd_piter::step_) (mln::graph_neighborhood_bkd_piter::first_) (mln::graph_neighborhood_bkd_piter::step_): Remove methods. (mln::graph_neighborhood_fwd_piter::i_) (mln::graph_neighborhood_bkd_piter::i_): New members. (mln::graph_neighborhood_fwd_piter::graph_neighborhood_fwd_piter) (mln::graph_neighborhood_bkd_piter::graph_neighborhood_bkd_piter): Invalidate member i_. (mln::graph_neighborhood_fwd_piter::start) (mln::graph_neighborhood_fwd_piter::next) (mln::graph_neighborhood_bkd_piter::start) (mln::graph_neighborhood_bkd_piter::next): Change the algorithms used in these routines, so that they use a list of computed sites (super member sites_) instead of iterating over the whole set of vertices. * mln/core/graph_elt_window.hh: Catch up with the new interface of piters on line graph windows. (mln::graph_elt_window::sites_t): New typedef. (mln::graph_elt_window::graph_elt_window): Remove useless ctor. (mln::graph_elt_window::start) (mln::graph_elt_window::next_): Remove methods. (mln::graph_elt_window::compute_sites_): New method. * mln/core/graph_elt_neighborhood.hh: Catch up with the new interface of piters on line graph neighborhoods. (mln::graph_elt_neighborhood::neighbors_t): New typedef. (mln::graph_elt_neighborhood::start) (mln::graph_elt_neighborhood::next_): Remove methods. (mln::graph_elt_neighborhood::compute_sites_): New method. graph_elt_neighborhood.hh | 54 +++++++------ graph_elt_window.hh | 62 +++++++-------- graph_neighborhood_piter.hh | 153 ++++++++++++++++++++++++++------------- graph_window_piter.hh | 151 +++++++++++++++++++++++++------------- internal/graph_vicinity_piter.hh | 109 +++++++++++---------------- 5 files changed, 306 insertions(+), 223 deletions(-) Index: mln/core/internal/graph_vicinity_piter.hh --- mln/core/internal/graph_vicinity_piter.hh (revision 1904) +++ mln/core/internal/graph_vicinity_piter.hh (working copy) @@ -32,6 +32,11 @@ /// \brief Factored implementation for point iterators on a graph windows /// and graph neighborhoods, called "vicinities". +/* FIXME: Factor those classes: + + - mln::internal::graph_vicinity_piter.hh + - mln::internal::line_graph_vicinity_piter.hh */ + # include <mln/core/concept/point_iterator.hh> # include <mln/core/p_graph.hh> # include <mln/core/graph_psite.hh> @@ -72,28 +77,10 @@ // FIXME: Dummy value. typedef void mesh; - public: - /// Construction. - /// \{ - template <typename Pref> - graph_vicinity_piter_(const Point_Site<Pref>& p_ref); - /// \} - - /// Manipulation. - /// \{ - /// Test if the iterator is valid. - bool is_valid() const; - /// Invalidate the iterator. - void invalidate(); - - /// Is the piter adjacent to the reference point? - bool adjacent_to_p_ref_() const; - /// 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_(); - /// \} + // The type of the set of vicinity sites (adjacent vertex ids). + typedef std::set<util::node_id> sites_t; + public: /// Conversion and accessors. /// \{ /// Reference to the corresponding point. @@ -103,10 +90,24 @@ /// Convert the iterator into a line graph psite. operator psite() const; + /// Return the reference psite. + const psite& p_ref() const; + /// Return the mln::p_graph corresponding to this piter. + const p_graph& pg() const; + /// Return the set of sites (adjacent vertex ids). + sites_t& sites(); + /// Read-only access to the \a i-th coordinate. coord operator[](unsigned i) const; /// \} + protected: + /// Construction. + /// \{ + template <typename Pref> + graph_vicinity_piter_(const Point_Site<Pref>& p_ref); + /// \} + /// Internals, used by the vicinity. /// \{ public: @@ -120,7 +121,11 @@ /// piter). const psite& p_ref_; - private: + /// The last reference psite whose ajacent psites have been computed. + psite saved_p_ref_; + /// The set of edge ids adjacent to the reference psite. + sites_t sites_; + /// The psite corresponding to this iterator. psite psite_; /// The point corresponding to this iterator. @@ -140,78 +145,54 @@ psite_(), p_() { - // Invalidate id_. - invalidate(); - } - - template <typename P, typename E> - inline - bool - graph_vicinity_piter_<P, E>::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 p_ref_.is_valid() && id_ < p_ref_.pg().npoints(); - } - - template <typename P, typename E> - inline - void - graph_vicinity_piter_<P, E>::invalidate() - { - id_ = -1; } template <typename P, typename E> inline - bool - graph_vicinity_piter_<P, E>::adjacent_to_p_ref_() const + const P& + graph_vicinity_piter_<P, E>::to_point() const { - return p_ref_.pg().adjacent(p_ref_.id(), id_); + return p_; } template <typename P, typename E> inline - bool - graph_vicinity_piter_<P, E>::adjacent_or_equal_to_p_ref_() const + const graph_psite& + graph_vicinity_piter_<P, E>::to_psite() const { - return p_ref_.pg().adjacent_or_equal(p_ref_.id(), id_); + return psite_; } template <typename P, typename E> inline - void - graph_vicinity_piter_<P, E>::update_() + graph_vicinity_piter_<P, E>::operator graph_psite() const { - // Update psite_. - psite_ = graph_psite(p_ref_.pg(), id_); - // Update p_. - p_ = p_ref_.pg().point_from_id(id_); + mln_precondition(exact(*this).is_valid()); + return psite_; } template <typename P, typename E> inline - const P& - graph_vicinity_piter_<P, E>::to_point() const + const graph_psite& + graph_vicinity_piter_<P, E>::p_ref() const { - return p_; + return p_ref_; } template <typename P, typename E> inline - const graph_psite& - graph_vicinity_piter_<P, E>::to_psite() const + const p_graph& + graph_vicinity_piter_<P, E>::pg() const { - return psite_; + return p_ref_.pg(); } template <typename P, typename E> inline - graph_vicinity_piter_<P, E>::operator graph_psite() const + std::set<util::node_id>& + graph_vicinity_piter_<P, E>::sites() { - mln_precondition(is_valid()); - return psite_; + return sites_; } template <typename P, typename E> Index: mln/core/graph_window_piter.hh --- mln/core/graph_window_piter.hh (revision 1904) +++ mln/core/graph_window_piter.hh (working copy) @@ -31,17 +31,6 @@ /// \file mln/core/graph_window_piter.hh /// \brief Definition of a point iterator on a graph window. -/* FIXME: Factor those classes: - - - mln::graph_window_fwd_piter - - mln::graph_neighborhood_fwd_piter - - mln::line_graph_window_fwd_piter - - mln::line_graph_neighborhood_fwd_piter. - - mln::graph_window_bkd_piter - - mln::graph_neighborhood_bkd_piter - - mln::line_graph_window_bkd_piter - - mln::line_graph_neighborhood_bkd_piter. */ - # include <mln/core/internal/graph_vicinity_piter.hh> /* FIXME: Due to the poor interface of mln::p_graph and @@ -72,23 +61,25 @@ /// 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_(); - /// \} - - /// Internals, used by the window. - /// \{ - /// Set the iterator to the first site of the graph. - void first_(); - /// Advance the position of the iterator by one step. - void step_(); + /// Update the internal data of the iterator. + void update_(); /// \} private: /// The window. const W& win_; + + /// An iterator on the set of adjacent vertices. + typename super_::sites_t::const_iterator i_; }; @@ -113,23 +104,25 @@ /// 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_(); - /// \} - - /// Internals, used by the window. - /// \{ - /// Set the iterator to the first site of the graph. - void first_(); - /// Advance the position of the iterator by one step. - void step_(); + /// Update the internal data of the iterator. + void update_(); /// \} private: /// The window. const W& win_; + + /// An iterator on the set of adjacent vertices. + typename super_::sites_t::const_reverse_iterator i_; }; @@ -148,42 +141,70 @@ : super_(p_ref), win_(exact(win)) { + // Invalidate i_. + invalidate(); + } + + template <typename P, typename W> + inline + bool + graph_window_fwd_piter<P, W>::is_valid() const + { + return + // The reference point must be valid... + this->p_ref_.is_valid() + // ...and must not have changed since the window has been computed... + && this->p_ref_ == this->saved_p_ref_ + // ...and the iterator i_ must point a valid value. + && i_ != this->sites_.end(); } template <typename P, typename W> inline void - graph_window_fwd_piter<P, W>::start() + graph_window_fwd_piter<P, W>::invalidate() { - this->win_.start(*this); - if (this->is_valid()) - this->update_(); + i_ = this->sites_.end(); } template <typename P, typename W> inline void - graph_window_fwd_piter<P, W>::next_() + graph_window_fwd_piter<P, W>::start() { - this->win_.next_(*this); - if (this->is_valid()) - this->update_(); + mln_precondition(this->p_ref_.is_valid()); + // Update the sites, if needed. + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) + { + this->saved_p_ref_ = this->p_ref_; + win_.compute_sites_(*this); + } + i_ = this->sites_.begin(); + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename W> inline void - graph_window_fwd_piter<P, W>::first_() + graph_window_fwd_piter<P, W>::next_() { - this->id_ = 0; + // Ensure the p_ref_ has not changed. + mln_precondition(this->p_ref_ == this->saved_p_ref_); + ++i_; + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename W> inline void - graph_window_fwd_piter<P, W>::step_() + graph_window_fwd_piter<P, W>::update_() { - ++this->id_; + // Update psite_. + this->psite_ = graph_psite(this->pg(), *i_); } @@ -199,42 +220,70 @@ : super_(p_ref), win_(exact(win)) { + // Invalidate i_. + invalidate(); + } + + template <typename P, typename W> + inline + bool + graph_window_bkd_piter<P, W>::is_valid() const + { + return + // The reference point must be valid... + this->p_ref_.is_valid() + // ...and must not have changed since the window has been computed... + && this->p_ref_ == this->saved_p_ref_ + // ...and the iterator i_ must point a valid value. + && i_ != this->sites_.rend(); } template <typename P, typename W> inline void - graph_window_bkd_piter<P, W>::start() + graph_window_bkd_piter<P, W>::invalidate() { - this->win_.start(*this); - if (this->is_valid()) - this->update_(); + i_ = this->sites_.rend(); } template <typename P, typename W> inline void - graph_window_bkd_piter<P, W>::next_() + graph_window_bkd_piter<P, W>::start() + { + mln_precondition(this->p_ref_.is_valid()); + // Update the sites, if needed. + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) { - this->win_.next_(*this); - if (this->is_valid()) - this->update_(); + this->saved_p_ref_ = this->p_ref_; + win_.compute_sites_(*this); + } + i_ = this->sites_.rbegin(); + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename W> inline void - graph_window_bkd_piter<P, W>::first_() + graph_window_bkd_piter<P, W>::next_() { - this->id_ = this->p_ref_.pg().gr_->nnodes() - 1; + // Ensure the p_ref_ has not changed. + mln_precondition(this->p_ref_ == this->saved_p_ref_); + ++i_; + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename W> inline void - graph_window_bkd_piter<P, W>::step_() + graph_window_bkd_piter<P, W>::update_() { - --this->id_; + // Update psite_. + this->psite_ = graph_psite(this->pg(), *i_); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/graph_neighborhood_piter.hh --- mln/core/graph_neighborhood_piter.hh (revision 1904) +++ mln/core/graph_neighborhood_piter.hh (working copy) @@ -31,17 +31,6 @@ /// \file mln/core/graph_neighborhood_piter.hh /// \brief Definition of a point iterator on a graph neighborhood. -/* FIXME: Factor those classes: - - - mln::graph_window_fwd_piter - - mln::graph_neighborhood_fwd_piter - - mln::line_graph_window_fwd_piter - - mln::line_graph_neighborhood_fwd_piter. - - mln::graph_window_bkd_piter - - mln::graph_neighborhood_bkd_piter - - mln::line_graph_window_bkd_piter - - mln::line_graph_neighborhood_bkd_piter. */ - # include <mln/core/internal/graph_vicinity_piter.hh> /* FIXME: Due to the poor interface of mln::p_graph and @@ -73,23 +62,25 @@ /// 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_(); - /// \} - - /// Internals, used by the neighborhood. - /// \{ - /// Set the iterator to the first site of the graph. - void first_(); - /// Advance the position of the iterator by one step. - void step_(); + /// Update the internal data of the iterator. + void update_(); /// \} private: /// The neighborhood. const N& nbh_; + + /// An iterator on the set of adjacent edges. + typename super_::sites_t::const_iterator i_; }; @@ -115,23 +106,25 @@ /// 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_(); - /// \} - - /// Internals, used by the neighborhood. - /// \{ - /// Set the iterator to the first site of the graph. - void first_(); - /// Advance the position of the iterator by one step. - void step_(); + /// Update the internal data of the iterator. + void update_(); /// \} private: /// The neighborhood. const N& nbh_; + + /// An iterator on the set of adjacent edges. + typename super_::sites_t::const_reverse_iterator i_; }; @@ -150,42 +143,71 @@ : super_(p_ref), nbh_(exact(nbh)) { + // Invalidate i_. + invalidate(); + } + + template <typename P, typename N> + inline + bool + graph_neighborhood_fwd_piter<P, N>::is_valid() const + { + return + // The reference point must be valid... + this->p_ref_.is_valid() + // ...and must not have changed since the neighborhood has been + // computed... + && this->p_ref_ == this->saved_p_ref_ + // ...and the iterator i_ must point a valid value. + && i_ != this->sites_.end(); } template <typename P, typename N> inline void - graph_neighborhood_fwd_piter<P, N>::start() + graph_neighborhood_fwd_piter<P, N>::invalidate() { - this->nbh_.start(*this); - if (this->is_valid()) - this->update_(); + i_ = this->sites_.end(); } template <typename P, typename N> inline void - graph_neighborhood_fwd_piter<P, N>::next_() + graph_neighborhood_fwd_piter<P, N>::start() { - this->nbh_.next_(*this); - if (this->is_valid()) - this->update_(); + mln_precondition(this->p_ref_.is_valid()); + // Update the neighbors, if needed. + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) + { + this->saved_p_ref_ = this->p_ref_; + nbh_.compute_sites_(*this); + } + i_ = this->sites_.begin(); + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename N> inline void - graph_neighborhood_fwd_piter<P, N>::first_() + graph_neighborhood_fwd_piter<P, N>::next_() { - this->id_ = 0; + // Ensure the p_ref_ has not changed. + mln_precondition(this->p_ref_ == this->saved_p_ref_); + ++i_; + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename N> inline void - graph_neighborhood_fwd_piter<P, N>::step_() + graph_neighborhood_fwd_piter<P, N>::update_() { - ++this->id_; + // Update psite_. + this->psite_ = graph_psite(this->pg(), *i_); } @@ -201,42 +223,71 @@ : super_(p_ref), nbh_(exact(nbh)) { + // Invalidate i_. + invalidate(); + } + + template <typename P, typename N> + inline + bool + graph_neighborhood_bkd_piter<P, N>::is_valid() const + { + return + // The reference point must be valid... + this->p_ref_.is_valid() + // ...and must not have changed since the neighborhood has been + // computed... + && this->p_ref_ == this->saved_p_ref_ + // ...and the iterator i_ must point a valid value. + && i_ != this->sites_.rend(); } template <typename P, typename N> inline void - graph_neighborhood_bkd_piter<P, N>::start() + graph_neighborhood_bkd_piter<P, N>::invalidate() { - this->nbh_.start(*this); - if (this->is_valid()) - this->update_(); + i_ = this->sites_.rend(); } template <typename P, typename N> inline void - graph_neighborhood_bkd_piter<P, N>::next_() + graph_neighborhood_bkd_piter<P, N>::start() + { + mln_precondition(this->p_ref_.is_valid()); + // Update the neighbors, if needed. + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) { - this->nbh_.next_(*this); - if (this->is_valid()) - this->update_(); + this->saved_p_ref_ = this->p_ref_; + nbh_.compute_sites_(*this); + } + i_ = this->sites_.rbegin(); + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename N> inline void - graph_neighborhood_bkd_piter<P, N>::first_() + graph_neighborhood_bkd_piter<P, N>::next_() { - this->id_ = this->p_ref_.pg().gr_->nnodes() - 1; + // Ensure the p_ref_ has not changed. + mln_precondition(this->p_ref_ == this->saved_p_ref_); + ++i_; + // FIXME: We might move the is_valid condition within update_. + if (is_valid()) + update_(); } template <typename P, typename N> inline void - graph_neighborhood_bkd_piter<P, N>::step_() + graph_neighborhood_bkd_piter<P, N>::update_() { - --this->id_; + // Update psite_. + this->psite_ = graph_psite(this->pg(), *i_); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/graph_elt_window.hh --- mln/core/graph_elt_window.hh (revision 1904) +++ mln/core/graph_elt_window.hh (working copy) @@ -40,6 +40,10 @@ - mln::line_graph_elt_window - mln::line_graph_elt_neighborhood. */ +/* FIXME: Due to the poor interface of mln::p_line_graph and + mln::util::graph, we show to much implementation details here. + Enrich their interfaces to avoid that. */ + # include <mln/core/concept/window.hh> # include <mln/core/graph_psite.hh> # include <mln/core/graph_window_piter.hh> @@ -65,6 +69,9 @@ typedef P point; /// The type of psite corresponding to the window. typedef graph_psite psite; + // The type of the set of window sites (node ids adjacent to the + // reference psite). + typedef std::set<util::node_id> sites_t; // FIXME: This is a dummy value. typedef void dpoint; @@ -81,17 +88,11 @@ typedef fwd_qiter qiter; /// \} - /// Construct an elementary graph window. - graph_elt_window(); - /// Services for iterators. /// \{ - /// Move \a piter to the beginning of the iteration on this window. + /// Compute the set of sites for this window around \a piter. template <typename Piter> - void start(Point_Iterator<Piter>& piter) const; - /// Move \a piter to the next site on this window. - template <typename Piter> - void next_(Point_Iterator<Piter>& piter) const; + void compute_sites_(Point_Iterator<Piter>& piter) const; /// \} /// Interface of the concept Window. @@ -125,37 +126,32 @@ # ifndef MLN_INCLUDE_ONLY template <typename P> - inline - graph_elt_window::graph_elt_window() - { - } - - template <typename P> template <typename Piter> inline void - graph_elt_window::start(Point_Iterator<Piter>& piter_) const + graph_elt_window::compute_sites_(Point_Iterator<Piter>& piter_) const { Piter& piter = exact(piter_); - piter.first_(); - if (!piter.adjacent_or_equal_to_p_ref_()) - next_(piter); + util::node_id ref_node_id = piter.p_ref().id(); + const util::node& ref_node = piter.pg().gr_->node(ref_node_id); + sites_t& sites = piter.sites(); + sites.clear(); + /* FIXME: Move this computation out of the window. In fact, + this should be a service of the graph, also proposed by the + p_line_graph. */ + // Adjacent vertices. + /* We don't need to explicitely insert the reference piter (node + id) itself into SITES, since it is part of the set of nodes + adjacent to NODE1 and NODE2, and will therefore be + automatically added. */ + for (std::vector<util::edge_id>::const_iterator e = ref_node.edges.begin(); + e != ref_node.edges.end(); ++e) + { + util::node_id n1 = piter.pg().gr_->edges()[*e]->n1(); + sites.insert(n1); + util::node_id n2 = piter.pg().gr_->edges()[*e]->n2(); + sites.insert(n2); } - - template <typename P> - template <typename Piter> - inline - void - graph_elt_window::next_(Point_Iterator<Piter>& piter_) const - { - Piter& piter = exact(piter_); - /* FIXME: This is inefficient. The graph structure should be able - to produce the set of adjacent nodes fast. Boost Graphs - probably provides adequates structures to fetch these - neighbors in constant time. */ - do - piter.step_(); - while (piter.is_valid() && !piter.adjacent_or_equal_to_p_ref_()); } template <typename P> Index: mln/core/graph_elt_neighborhood.hh --- mln/core/graph_elt_neighborhood.hh (revision 1904) +++ mln/core/graph_elt_neighborhood.hh (working copy) @@ -40,6 +40,10 @@ - mln::line_graph_elt_window - mln::line_graph_elt_neighborhood. */ +/* FIXME: Due to the poor interface of mln::p_line_graph and + mln::util::graph, we show to much implementation details here. + Enrich their interfaces to avoid that. */ + # include <mln/core/concept/neighborhood.hh> # include <mln/core/graph_psite.hh> # include <mln/core/graph_neighborhood_piter.hh> @@ -66,6 +70,9 @@ typedef P point; /// The type of psite corresponding to the neighborhood. typedef graph_psite psite; + // The type of the set of neighbors (node ids adjacent to the + // reference psite). + typedef std::set<util::node_id> sites_t; // FIXME: This is a dummy value. typedef void dpoint; @@ -84,12 +91,9 @@ /// Services for iterators. /// \{ - /// Move \a piter to the beginning of the iteration on this neighborhood. - template <typename Piter> - void start(Point_Iterator<Piter>& piter) const; - /// Move \a piter to the next site on this neighborhood. + /// Compute the set of sites for this neighborhood around \a piter. template <typename Piter> - void next_(Point_Iterator<Piter>& piter) const; + void compute_sites_(Point_Iterator<Piter>& piter) const; /// \} }; @@ -100,28 +104,30 @@ template <typename Piter> inline void - graph_elt_neighborhood::start(Point_Iterator<Piter>& piter_) const + graph_elt_neighborhood::compute_sites_(Point_Iterator<Piter>& piter_) const { Piter& piter = exact(piter_); - piter.first_(); - if (!piter.adjacent_to_p_ref_()) - next_(piter); - } - - template <typename P> - template <typename Piter> - inline - void - graph_elt_neighborhood::next_(Point_Iterator<Piter>& piter_) const + util::node_id ref_node_id = piter.p_ref().id(); + const util::node& ref_node = piter.pg().gr_->node(ref_node_id); + sites_t& sites = piter.sites(); + sites.clear(); + /* FIXME: Move this computation out of the neighborhood. In fact, + this should be a service of the graph, also proposed by the + p_line_graph. */ + // Adjacent vertices. + for (std::vector<util::edge_id>::const_iterator e = ref_node.edges.begin(); + e != ref_node.edges.end(); ++e) { - Piter& piter = exact(piter_); - /* FIXME: This is inefficient. The graph structure should be able - to produce the set of adjacent nodes fast. Boost Graphs - probably provides adequates structures to fetch these - neighbors in constant time. */ - do - piter.step_(); - while (piter.is_valid() && !piter.adjacent_to_p_ref_()); + util::node_id n1 = piter.pg().gr_->edges()[*e]->n1(); + // We explicitly enforce that the reference piter node id is + // *not* inserted into SITES. + if (n1 != ref_node_id) + sites.insert(n1); + util::node_id n2 = piter.pg().gr_->edges()[*e]->n2(); + // Likewise. + if (n2 != ref_node_id) + sites.insert(n2); + } } # endif // ! MLN_INCLUDE_ONLY

16 years

1904: Add pset_array class for image encoded by values.

by Nicolas Ballas

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Add pset_array class for image encoded by values. * tests/level/paste.cc: Add tests. * tests/core/image3d.cc, * tests/core/pset_array.cc: New tests. * tests/core/Makefile.am: Add the new tests. * mln/core/pset_array.hh: pset_array class. * mln/core/rle_image.hh, * mln/core/p_runs.hh, * mln/core/runs_psite.hh: Update the license.. * mln/core/pset_array_psite.hh: Psite associated to the pset_arry. * mln/level/memcpy_.hh: Clean up. * sandbox/ballas/doc/image_tours.txt: Update Documentation. mln/core/p_runs.hh | 77 ++++++-- mln/core/pset_array.hh | 353 +++++++++++++++++++++++++++++++++++++ mln/core/pset_array_psite.hh | 152 +++++++++++++++ mln/core/rle_image.hh | 2 mln/core/runs_psite.hh | 2 mln/level/memcpy_.hh | 6 sandbox/ballas/doc/image_tours.txt | 100 ++++++++-- tests/core/Makefile.am | 2 tests/core/image3d.cc | 73 +++++++ tests/core/pset_array.cc | 93 +++++++++ tests/level/paste.cc | 28 ++ 11 files changed, 846 insertions(+), 42 deletions(-) Index: tests/level/paste.cc --- tests/level/paste.cc (revision 1903) +++ tests/level/paste.cc (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -31,8 +31,12 @@ */ #include <mln/core/image2d.hh> +#include <mln/core/image3d.hh> +#include <mln/core/sub_image.hh> + #include <mln/level/fill.hh> #include <mln/level/paste.hh> +#include <mln/level/compare.hh> #include <mln/debug/iota.hh> #include <mln/debug/println.hh> @@ -42,6 +46,8 @@ { using namespace mln; + // tests in two dimension + { box2d b(make::point2d(1,2), make::point2d(2,4)); image2d<int> ima(b, 2); debug::iota(ima); @@ -51,6 +57,26 @@ debug::iota(ima2); level::paste(ima, ima2); // Fast version. + assert(ima == (ima2 | b)); level::impl::generic::paste_(ima, ima2); // Not so fast version... + assert(ima == (ima2 | b)); + } + + // tests in three dimension + { + box3d b(make::point3d(1,2, 1), make::point3d(2,4, 3)); + image3d<int> ima(b, 2); + debug::iota(ima); + + box3d b2(make::point3d(-1,-2, -1), make::point3d(3,6, 3)); + image3d<int> ima2(b2, 2); + debug::iota(ima2); + + level::paste(ima, ima2); // Fast version. + assert(ima == (ima2 | b)); + + level::impl::generic::paste_(ima, ima2); // Not so fast version... + assert(ima == (ima2 | b)); + } } Index: tests/core/image3d.cc --- tests/core/image3d.cc (revision 0) +++ tests/core/image3d.cc (revision 0) @@ -0,0 +1,73 @@ +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// 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/level/image3d.cc + * + * \brief Tests on Image3d pixter + */ + + +#include <mln/core/image3d.hh> +#include <mln/core/image2d.hh> + +#include <mln/debug/iota.hh> + +int main() +{ + using namespace mln; + + + // Working test + { + box3d b(make::point3d(1,2, 1), make::point3d(2,4, 3)); + image3d<int> ima(b, 2); + + mln_pixter_(image3d<int>) p(ima); + for_all(p) + std::cout < ima(b, 0); + + mln_piter_(image3d<int>) pi(ima.domain()); + mln_pixter_(image3d<int>) p(ima); + + debug::iota(ima); + + pi.start(); + p.start(); + while (pi.is_valid()) + { + assert(ima(pi) == p.val()); + pi.next(); + p.next(); + } + } +} Index: tests/core/pset_array.cc --- tests/core/pset_array.cc (revision 0) +++ tests/core/pset_array.cc (revision 0) @@ -0,0 +1,93 @@ +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// 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 mln/core/pset_array.hh + * + * \brief Tests for the pset array. + */ + +#include <mln/core/pset_array.hh> +#include <mln/core/image2d.hh> +#include <mln/core/p_runs.hh> + +#include <iostream> + +int main() +{ + using namespace mln; + + typedef p_runs_<point2d> runs; + + p_runs_<point2d> pruns0; + p_runs_<point2d> pruns1; + p_runs_<point2d> pruns2; + + pruns0.insert(p_run<point2d>(make::point2d(0, 0), 2)); + + pruns2.insert(p_run<point2d>(make::point2d(10,10), 5)); + + pruns1.insert(p_run<point2d>(make::point2d(2, 4), 7)); + pruns1.insert(p_run<point2d>(make::point2d(18, 42), 5)); + pruns1.insert(p_run<point2d>(make::point2d(50, 76), 2)); + pruns1.insert(p_run<point2d>(make::point2d(17,40), 6)); + + + + /// Declare the pset_array + pset_array<runs> array; + + /// Add elements in the array + assert(array.npsets() == 0); + array.insert(pruns0); + assert(array.npsets() == 1); + assert(array.npoints() == 2); + + array.insert(pruns2); + assert(array.npsets() == 2); + assert(array.npoints() == 7); + + array.insert(pruns1); + + /// Psite tests + typedef pset_array<runs>::psite psite; + runs_psite<point2d> run_psite1(pruns0, 1, 0); + runs_psite<point2d> run_psite2(pruns1, 5, 1); + + psite ps(run_psite1, 0); + assert(array.has(ps)); + + psite ps2(run_psite2, 2); + assert(array.has(ps2)); + + // Iterator test: + pset_array<runs>::fwd_piter piter(array); + + for (piter.start(); piter.is_valid(); piter.next()) + { + std::cout << piter << std::endl; + } +} Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 1903) +++ tests/core/Makefile.am (working copy) @@ -8,6 +8,7 @@ exact \ h_vec \ initialize \ + image3d \ graph_elt_neighborhood \ graph_elt_window \ graph_image \ @@ -26,6 +27,7 @@ p_queue_fast \ p_runs \ point_set_compatibility \ + pset_array \ rle_image \ sparse_image \ t_image \ Index: mln/core/pset_array.hh --- mln/core/pset_array.hh (revision 0) +++ mln/core/pset_array.hh (revision 0) @@ -0,0 +1,353 @@ +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// 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_PSET_ARRAY_HH_ +# define MLN_CORE_PSET_ARRAY_HH_ + + +/*! \file mln/core/pset_array.hh + * + * \brief Definition of the pset array class. + */ + +# include <mln/core/internal/point_set_base.hh> +# include <mln/core/internal/point_iterator_base.hh> + +# include <vector> +# include <mln/accu/bbox.hh> +# include <mln/core/pset_array_psite.hh> + + + + +namespace mln +{ + + // Forward declaration + template <typename Pset> struct pset_array_fwd_piter_; + + + /*! \brief Point Set Class based on a collection of Point Set + ** This class is based on a std::vector. + ** This class is parametrized by \p Pset which is the Point Set + ** type of the collection. + ** + ** The iterator type associated to Pset must satisfy some constraints: + ** * Iterator type must have a constructor which takes no argument + ** * Iterator type must have a method + ** void assign(const Pset&) + ** which change the Pset associated to the iterator + ** + ** + ** FIXME: Add a backward iterator. + */ + template <typename Pset> + class pset_array: + public internal::point_set_base_<pset_array_psite<Pset>, pset_array<Pset> > + { + public: + + // Container + typedef std::vector<Pset> container; + + typedef pset_array_fwd_piter_<Pset> fwd_piter; + typedef pset_array_fwd_piter_<Pset> bkd_piter; + + typedef pset_array_psite<typename Pset::psite> psite; + typedef typename Pset::point point; + + /// Constructor without arguments. + pset_array(); + + /// Test is \p p belongs to this point set. + bool has(const psite& ps) const; + + /// Give the exact bounding box. + const box_<point>& bbox() const; + + /// Give the number of points. + typename std::size_t npoints() const; + + /// Give the number of pset + typename std::size_t npsets() const; + + /// Insert a new Point Set in the Point Sets Collections + void insert(const Pset& ps); + + /// Return the i-th pset of the Point Sets Colletion + const Pset& operator[](unsigned i) const; + Pset& operator[](unsigned i); + + protected: + + /// Number of points. + typename std::size_t npoints_; + + /// Points container + container con_; + + /// Exact bounding box. + accu::bbox<point> fb_; + + }; + +# ifndef MLN_INCLUDE_ONLY + + template <typename Pset> + inline + pset_array<Pset>::pset_array() : + npoints_(0) + { + } + + template <typename Pset> + inline + bool + pset_array<Pset>::has(const typename pset_array<Pset>::psite& ps) const + { + mln_precondition(ps.to_index() < con_.size()); + return con_[ps.to_index()].has(ps.to_psite()); + } + + template <typename Pset> + inline + const box_<typename pset_array<Pset>::point>& + pset_array<Pset>::bbox() const + { + return fb_.to_result(); + } + + template <typename Pset> + inline + typename std::size_t + pset_array<Pset>::npoints() const + { + return npoints_; + } + + template <typename Pset> + inline + typename std::size_t + pset_array<Pset>::npsets() const + { + return con_.size(); + } + + template <typename Pset> + inline + void + pset_array<Pset>::insert(const Pset& ps) + { + // update box + fb_.take(ps.bbox().pmin()); + fb_.take(ps.bbox().pmax()); + + // update size + npoints_ += ps.npoints(); + + // update the container + con_.push_back(ps); + } + + template <typename Pset> + inline + const Pset& + pset_array<Pset>::operator[](unsigned i) const + { + return con_[i]; + } + +# endif // ! MLN_INCLUDE_ONLY + + + /*! \brief Forward Iterator on a Pset array. + ** \p Pset is the type of Point Set in the Point Sets collection. + ** + */ + template <typename Pset> + class pset_array_fwd_piter_ : public + internal::point_iterator_base_<pset_array_psite<typename Pset::psite>, + pset_array_fwd_piter_<Pset> > + { + public: + + /// Access types + typedef pset_array_psite<typename Pset::psite> psite; + typedef typename Pset::point point; + + /// Constructor + pset_array_fwd_piter_(const pset_array<Pset>& pset); + + /// Test the iterator validity. + bool is_valid() const; + + /// Invalidate the iterator. + void invalidate(); + + /// Start an iteration. + void start(); + + /// Go to the next point. + void next_(); + + + /// Convertion into a point. + operator point () const; + + /// Reference to the corresponding point. + const point& to_point() const; + + /// Convertion into a point-site. + operator psite () const; + + /// Access to the current point coordinates. + mln_coord(point) operator[](unsigned i) const; + + protected: + + /// Change the Point Set associated with the wrapped piter. + void assign_piter_(); + + private: + + typedef typename Pset::fwd_piter pset_fwd_piter_; + + + const pset_array<Pset>* pset_; + pset_fwd_piter_ piter_; + unsigned pos_; + }; + +# ifndef MLN_INCLUDE_ONLY + + template <typename Pset> + pset_array_fwd_piter_<Pset>::pset_array_fwd_piter_(const pset_array<Pset>& pset) : + pset_(&pset), + piter_(), + pos_(pset_->npsets()) + { + invalidate(); + } + + template <typename Pset> + inline + bool + pset_array_fwd_piter_<Pset>::is_valid() const + { + return pos_ < pset_->npsets(); + } + + template <typename Pset> + inline + void + pset_array_fwd_piter_<Pset>::invalidate() + { + pos_ = pset_->npsets(); + } + + template <typename Pset> + inline + void + pset_array_fwd_piter_<Pset>::assign_piter_() + { + piter_.assign((*pset_)[pos_]); + piter_.start(); + } + + template <typename Pset> + inline + void + pset_array_fwd_piter_<Pset>::start() + { + mln_precondition(pset_->npsets() > 0); + + pos_ = 0; + assign_piter_(); + } + + template <typename Pset> + inline + void + pset_array_fwd_piter_<Pset>::next_() + { + mln_precondition(is_valid()); + + piter_.next(); + if (!piter_.is_valid()) + { + ++pos_; + if (is_valid()) + assign_piter_(); + else + piter_.invalidate(); + } + } + + template <typename Pset> + pset_array_fwd_piter_<Pset>::operator + typename pset_array_fwd_piter_<Pset>::point() const + { + return to_point(); + } + + template <typename Pset> + const typename pset_array_fwd_piter_<Pset>::point& + pset_array_fwd_piter_<Pset>::to_point() const + { + mln_precondition(is_valid()); + mln_precondition(piter_.is_valid()); + + return piter_.to_point(); + } + + template <typename Pset> + pset_array_fwd_piter_<Pset>::operator + typename pset_array_fwd_piter_<Pset>::psite () + const + { + mln_precondition(is_valid()); + + return pset_array_psite<typename Pset::psite>(piter_, pos_); + } + + template <typename Pset> + mln_coord_(typename pset_array_fwd_piter_<Pset>::point) + pset_array_fwd_piter_<Pset>::operator[](unsigned i) const + { + mln_precondition(is_valid()); + + return piter_[i]; + } + + +# endif // ! MLN_INCLUDE_ONLY + + +} // end of namespace mln + + +#endif // ! MLN_CORE_PSET_ARRAY_HH_ Index: mln/core/rle_image.hh --- mln/core/rle_image.hh (revision 1903) +++ mln/core/rle_image.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms Index: mln/core/runs_psite.hh --- mln/core/runs_psite.hh (revision 1903) +++ mln/core/runs_psite.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms Index: mln/core/pset_array_psite.hh --- mln/core/pset_array_psite.hh (revision 0) +++ mln/core/pset_array_psite.hh (revision 0) @@ -0,0 +1,152 @@ +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// 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_PSET_ARRAY_PSITE_HH_ +# define MLN_CORE_PSET_ARRAY_PSITE_HH_ + +/*! \file mln/core/runs_psite.hh + * + * \brief Definition of the psite associated to the pset_array type. + */ + +# include <mln/core/concept/point_site.hh> +# include <mln/util/tracked_ptr.hh> + + +namespace mln +{ + /*! \brief Psite class associated to pset_array. + ** + ** Parameter \c Psite is the type of the underlying psite. + */ + template <typename Psite> + class pset_array_psite : public Point_Site< pset_array_psite<Psite> > + { + public: + + typedef mln_point(Psite) point; + typedef mln_dpoint(Psite) dpoint; + typedef mln_coord(point) coord; + + typedef Psite psite; + + typedef mln_mesh(point) mesh; + enum { dim = point::dim }; + + pset_array_psite(const psite& psite, unsigned index); + + operator point () const; + + /// Reference to the corresponding point. + const point& to_point() const; + + + /// Useful method for the access + unsigned to_index() const; + unsigned& to_index(); + const psite& to_psite() const; + + /// Give the i-th coordinate of the corresponding point. + mln_coord(point) operator[](unsigned i) const; + + protected: + + /// Psite which allows us to access to the images + const psite& psite_; + + /// Position in the pset_array. + unsigned index_; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename Psite> + pset_array_psite<Psite>::pset_array_psite(const psite& psite, + unsigned index) : + psite_(psite), + index_(index) + { + } + + template <typename Psite> + inline + pset_array_psite<Psite>::operator typename pset_array_psite<Psite>::point () + const + { + return to_point(); + } + + template <typename Psite> + inline + const typename pset_array_psite<Psite>::point& + pset_array_psite<Psite>::to_point() const + { + return psite_.to_point(); + } + + template <typename Psite> + inline + unsigned + pset_array_psite<Psite>::to_index() const + { + return index_; + } + + template <typename Psite> + inline + unsigned& + pset_array_psite<Psite>::to_index() + { + return index_; + } + + template <typename Psite> + inline + const Psite& + pset_array_psite<Psite>::to_psite() const + { + return psite_; + } + + template <typename Psite> + inline + mln_coord(pset_array_psite<Psite>::point) + pset_array_psite<Psite>::operator[] (unsigned i) const + { + return psite_[i]; + } + + + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + +# include <mln/core/pset_array.hh> + +#endif // ! MLN_CORE_INTERNAL_PSET_ARRAY_PSITE_HH Index: mln/core/p_runs.hh --- mln/core/p_runs.hh (revision 1903) +++ mln/core/p_runs.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -269,15 +269,19 @@ /// Access to the current point coordinates. mln_coord(P) operator[](unsigned i) const; + /// Assign a new pset to the iterator + void assign(const p_runs_& pset); + protected: /// Current point. P p_; /// Point set container. - const p_runs_& con_; + const p_runs_* con_; p_runs_piter_(const p_runs_& pset); + p_runs_piter_(); }; @@ -286,7 +290,14 @@ template <typename P, typename E> inline p_runs_piter_<P, E>::p_runs_piter_(const p_runs_& pset) : - con_(pset) + con_(&pset) + { + } + + template <typename P, typename E> + inline + p_runs_piter_<P, E>::p_runs_piter_() : + con_(0) { } @@ -315,6 +326,14 @@ return p_[i]; } + template <typename P, typename E> + inline + void + p_runs_piter_<P, E>::assign(const p_runs_& pset) + { + con_ = &pset; + } + # endif // ! MLN_INCLUDE_ONLY @@ -328,6 +347,7 @@ typedef p_runs_piter_<P, p_runs_fwd_piter_ > super; public: + p_runs_fwd_piter_(); p_runs_fwd_piter_(const p_runs_& pset); /// Test the iterator validity. @@ -357,6 +377,12 @@ template <typename P> inline + p_runs_fwd_piter_::p_runs_fwd_piter_() + { + } + + template <typename P> + inline p_runs_fwd_piter_::p_runs_fwd_piter_(const p_runs_& pset) : super(pset) { @@ -368,7 +394,7 @@ bool p_runs_fwd_piter_::is_valid() const { - return i_ < this->con_.nruns(); + return this->con_ != 0 && i_ < this->con_->nruns(); } template <typename P> @@ -376,7 +402,9 @@ void p_runs_fwd_piter_::invalidate() { - i_ = this->con_.nruns(); + mln_precondition(this->con_ != 0); + + i_ = this->con_->nruns(); } template <typename P> @@ -384,8 +412,10 @@ void p_runs_fwd_piter_::start() { + mln_precondition(this->con_ != 0); + i_ = 0; - it_.assign_run(this->con_[i_]); + it_.assign_run((*this->con_)[i_]); it_.start(); this->p_ = it_; } @@ -396,13 +426,15 @@ p_runs_fwd_piter_::next_() { mln_precondition(this->is_valid()); + mln_precondition(this->con_ != 0); + it_.next(); if (!it_.is_valid()) { ++i_; if (is_valid()) { - it_.assign_run(this->con_[i_]); + it_.assign_run( (*this->con_)[i_]); it_.start(); } else @@ -414,7 +446,9 @@ template <typename P> p_runs_fwd_piter_::operator runs_psite () const { - return runs_psite(this->con_, it_.ind(), i_); + mln_precondition(this->con_ != 0); + + return runs_psite(*this->con_, it_.ind(), i_); } # endif // ! MLN_INCLUDE_ONLY @@ -430,6 +464,7 @@ typedef p_runs_piter_<P, p_runs_bkd_piter_ > super; public: + p_runs_bkd_piter_(); p_runs_bkd_piter_(const p_runs_& pset); /// Test the iterator validity. @@ -458,6 +493,13 @@ # ifndef MLN_INCLUDE_ONLY + + template <typename P> + inline + p_runs_bkd_piter_::p_runs_bkd_piter_() + { + } + template <typename P> inline p_runs_bkd_piter_::p_runs_bkd_piter_(const p_runs_& pset) : @@ -471,7 +513,7 @@ bool p_runs_bkd_piter_::is_valid() const { - return i_ < this->con_.nruns(); + return this->con_ != 0 &&i_ < this->con_->nruns(); } template <typename P> @@ -479,7 +521,9 @@ void p_runs_bkd_piter_::invalidate() { - i_ = this->con_.nruns(); + mln_precondition(this->con_ != 0); + + i_ = this->con_->nruns(); } template <typename P> @@ -487,8 +531,10 @@ void p_runs_bkd_piter_::start() { - i_ = this->con_.nruns() - 1; - it_.assign_run(this->con_[i_]); + mln_precondition(this->con_ != 0); + + i_ = this->con_->nruns() - 1; + it_.assign_run((*this->con_)[i_]); it_.start(); this->p_ = it_; } @@ -499,13 +545,15 @@ p_runs_bkd_piter_::next_() { mln_precondition(this->is_valid()); + mln_precondition(this->con_ != 0); + it_.next(); if (!it_.is_valid()) { --i_; if (is_valid()) { - it_.assign_run(this->con_[i_]); + it_.assign_run((*this->con_)[i_]); it_.start(); } else @@ -517,7 +565,8 @@ template <typename P> p_runs_bkd_piter_::operator runs_psite () const { - return runs_psite(this->con_, it_.ind(), i_); + mln_precondition(this->con_ != 0); + return runs_psite((*this->con_), it_.ind(), i_); } # endif // ! MLN_INCLUDE_ONLY Index: mln/level/memcpy_.hh --- mln/level/memcpy_.hh (revision 1903) +++ mln/level/memcpy_.hh (working copy) @@ -78,11 +78,8 @@ typedef mln_image(Pd) Id; typedef mln_image(Ps) Is; - if (n == 0) - { return; // no-op - } if (n == 1) { @@ -111,7 +108,8 @@ template <typename Pd, typename Ps> inline - void memcpy_(Generalized_Pixel<Pd>& dest_, const Generalized_Pixel<Ps>& src_, + void memcpy_(Generalized_Pixel<Pd>& dest_, + const Generalized_Pixel<Ps>& src_, std::size_t n) { trace::entering("level::memcpy_"); Index: sandbox/ballas/doc/image_tours.txt --- sandbox/ballas/doc/image_tours.txt (revision 1903) +++ sandbox/ballas/doc/image_tours.txt (working copy) @@ -42,7 +42,7 @@ ** Semantic -Properties are a way to classify the images depends or their type. +Properties are a way to classify the images depends or their types. *** Static Checking @@ -50,14 +50,66 @@ check that the operator's input types respect the operator requirements. *** Specialization of an Algorithm - (ex: dilatation/erosion). -TODO: detail the example. + +Example: + +Here are the differents method which implement the morphologic erosion +in Milena. + +All these functions implements the erosion in different ways. +Each implemtation of the erosion is dedicated to image + + + +This is the generic implementation of the erosion. +It works with all the image types. +Indeed, this function works with all the image types which have their traits +kind and speed set to the value any. And any is a superclass of all the values +for these traits. So, it works with all the image types. +However, this is not the most efficient implementation of the erosion. + +template <typename I, typename W> +inline +mln_concrete(I) +erosion_iterative_(trait::image::kind::any, + trait::image::speed::any, + const I& input, const W& win); + + + +This version of the erosion is dedicated to image types which have their +traits speed set to fastest. +This implementation is more efficient than the previous one, however +the image must specific caracteristics (like a border...), + +So it only work with image the "fastest" image types. + + +template <typename I, typename W> +mln_concrete(I) +erosion_iterative_(trait::image::kind::any, + trait::image::speed::fastest, + const I& input, const W& win); + + + +This function automatically call the erosion function which is the more +adapted to the erosion. +So the efficient erosion will be automatically called for the fastest image +types. +This function act likes a facade, and hide the implementation details from +an user point of view. + +template <typename I, typename W> +mln_concrete(I) +erosion_iterative_(const I& input, const W& win); + *** Implementation inheritance Milena image types are property driven. It is possible to get a special behavior (not describe in the Image Concept) -depends on the property define in the property associated for the image +depends on the property defined in the property associated to the image type. So, it is possible to recover some piece of interface depending on the image type properties. @@ -163,18 +215,21 @@ Primitive image are images which are not based on another image type. -A primitive image type property can be either declared or automatically get -back with the help of associated types. - +A primitive image type property can be either declared or automatically deduce +from the help of associated types. FIXME: find a good notation... ** Image nD -Image on regular grid where grid nodes are points. -To gain efficiency, Images nD have a virtual borders. +Image based on a regular grid where the grid nodes are points. +To gain efficiency, Images nD have a virtual border. All these image are templated by T, the image value type. +**** Specific interface: + + Image nd is a able to provide index access through its interfaces. + *** Common Associated type//properties between imageND @@ -219,8 +274,6 @@ space = one_d -**** Specific interface: - FIXME.... *** Image2d<T> @@ -248,10 +301,6 @@ space = three_d -**** Specific interface: - FIXME.... - - ** Image based on function @@ -296,12 +345,9 @@ Is there any lvalue for image with computed data? lvalue just for image with stored//read_only data? -**** Specific interface: - FIXME.... - ** Run based Encoded image -All the run based encoded images have their definition domains encoded by runs. +All the run encoded images have their definition domains encoded by runs. These images types are not morpher types since these do not lie on another image type. All the run based encoded images are templated by P, T where P is a site type @@ -311,7 +357,6 @@ type one shot (const)!!! Do we store the the null value in the rle encoding. ( <=> Do we compress all the images values, or only the image objects...) -Is there any restriction on P and T? *** Notation used: (a, b) represents a pair composed by two elements.. @@ -389,7 +434,6 @@ So we must be able to convert a site and i_run index to another site. ex: - (0, 4) + 3 give us the site (0, 7). It has two consequences: @@ -642,6 +686,15 @@ (4, {((3, 3), 3)} ) } +**** Specific Methods: + +With this type of image, we can easily access to all the site corresponding +to a value (method site_from_values(V value) : p_runs?). + +Furthermore, we can easily change the value of all the +site which share the same value in a constant time. +(method: cell(V value) : V&). + *** Image based on Lut @@ -659,6 +712,11 @@ FIXME: How do we deal with the dimensions of the images? +**** Specific Method: + +As value encoded image, here we can easily change the value of all +the site which share the same value (method: cell(V value) : V&). + **** Associated type

16 years

1903: Factor implementation of piters on line graph neighborhoods.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Factor implementation of piters on line graph neighborhoods. * mln/core/line_graph_elt_neighborhood.hh (mln::graph_elt_neighborhood<P, N>::neighbors_t): Rename as... (mln::graph_elt_neighborhood<P, N>::sites_t): ...this. (mln::graph_elt_neighborhood<P, N>::compute_neighbors_): Rename as... (mln::graph_elt_neighborhood<P, N>::compute_sites_): ...this. * mln/core/line_graph_neighborhood_piter.hh: (mln::line_graph_neighborhood_fwd_piter<P, W>) (mln::line_graph_neighborhood_bkd_piter<P, N>): Inherit from mln::internal::line_graph_vicinity_piter_. (mln::line_graph_neighborhood_fwd_piter<P, N>::start) (mln::line_graph_neighborhood_bkd_piter<P, N>::start): Adjust w.r.t. the changes in graph_elt_neighborhood. (mln::line_graph_neighborhood_fwd_piter<P, N>::super_) (mln::line_graph_neighborhood_bkd_piter<P, N>::super_): Adjust typedef. (mln::line_graph_neighborhood_fwd_piter<P, N>::i_) (mln::line_graph_neighborhood_bkd_piter<P, N>::i_): Adjust. (line_graph_neighborhood_fwd_piter<P, W>) (line_graph_neighborhood_bkd_piter<P, N>): Adjust ctors. (mln::line_graph_neighborhood_fwd_piter<P, N>::psite) (mln::line_graph_neighborhood_fwd_piter<P, N>::point) (mln::line_graph_neighborhood_fwd_piter<P, N>::coord) (mln::line_graph_neighborhood_fwd_piter<P, N>::dpoint) (mln::line_graph_neighborhood_fwd_piter<P, N>::mesh) (mln::line_graph_neighborhood_fwd_piter<P, N>::sites_t) (mln::line_graph_neighborhood_bkd_piter<P, N>::psite) (mln::line_graph_neighborhood_bkd_piter<P, N>::point) (mln::line_graph_neighborhood_bkd_piter<P, N>::coord) (mln::line_graph_neighborhood_bkd_piter<P, N>::dpoint) (mln::line_graph_neighborhood_bkd_piter<P, N>::mesh) (mln::line_graph_neighborhood_bkd_piter<P, N>::sites_t): Remove (now useless) typedefs. (mln::line_graph_neighborhood_fwd_piter<P, N>::to_point) (mln::line_graph_neighborhood_fwd_piter<P, N>::to_psite) (mln::line_graph_neighborhood_fwd_piter<P, N>::operator psite) (mln::line_graph_neighborhood_fwd_piter<P, N>::p_ref) (mln::line_graph_neighborhood_fwd_piter<P, N>::plg) (mln::line_graph_neighborhood_fwd_piter<P, N>::sites) (mln::line_graph_neighborhood_fwd_piter<P, N>::operator[]) (mln::line_graph_neighborhood_bkd_piter<P, N>::to_point) (mln::line_graph_neighborhood_bkd_piter<P, N>::to_psite) (mln::line_graph_neighborhood_bkd_piter<P, N>::operator psite) (mln::line_graph_neighborhood_bkd_piter<P, N>::p_ref) (mln::line_graph_neighborhood_bkd_piter<P, N>::plg) (mln::line_graph_neighborhood_bkd_piter<P, N>::sites) (mln::line_graph_neighborhood_bkd_piter<P, N>::operator[]): Remove methods. (mln::line_graph_neighborhood_fwd_piter<P, N>::p_ref_) (mln::line_graph_neighborhood_fwd_piter<P, N>::saved_p_ref_) (mln::line_graph_neighborhood_fwd_piter<P, N>::sites_) (mln::line_graph_neighborhood_fwd_piter<P, N>::psite_) (mln::line_graph_neighborhood_fwd_piter<P, N>::point_) (mln::line_graph_neighborhood_bkd_piter<P, N>::p_ref_) (mln::line_graph_neighborhood_bkd_piter<P, N>::saved_p_ref_) (mln::line_graph_neighborhood_bkd_piter<P, N>::sites_) (mln::line_graph_neighborhood_bkd_piter<P, N>::psite_) (mln::line_graph_neighborhood_bkd_piter<P, N>::point_): Remove attributes. (operator<<(ostream&, const line_graph_neighborhood_fwd_piter<P, N>&)) (operator<<(ostream&, const line_graph_neighborhood_bkd_piter<P, N>&)): Remove. * mln/core/internal/line_graph_vicinity_piter.hh: Add missing inclusion of standard header `set'. internal/line_graph_vicinity_piter.hh | 2 line_graph_elt_neighborhood.hh | 16 - line_graph_neighborhood_piter.hh | 337 +++------------------------------- 3 files changed, 43 insertions(+), 312 deletions(-) Index: mln/core/line_graph_elt_neighborhood.hh --- mln/core/line_graph_elt_neighborhood.hh (revision 1902) +++ mln/core/line_graph_elt_neighborhood.hh (working copy) @@ -74,7 +74,7 @@ typedef line_graph_psite psite; // The type of the set of neighbors (edge ids adjacent to the // reference psite). - typedef std::set<util::edge_id> neighbors_t; + typedef std::set<util::edge_id> sites_t; // FIXME: This is a dummy value. typedef void dpoint; @@ -94,7 +94,7 @@ /// Services for iterators. /// \{ template <typename Piter> - void compute_neighbors_(Point_Iterator<Piter>& piter) const; + void compute_sites_(Point_Iterator<Piter>& piter) const; /// \} }; @@ -106,12 +106,12 @@ template <typename Piter> inline void - line_graph_elt_neighborhood::compute_neighbors_(Point_Iterator<Piter>& piter_) const + line_graph_elt_neighborhood::compute_sites_(Point_Iterator<Piter>& piter_) const { Piter& piter = exact(piter_); util::edge_id ref_edge_id = piter.p_ref().id(); - neighbors_t& neighbors = piter.neighbors(); - neighbors.clear(); + sites_t& sites = piter.sites(); + sites.clear(); /* FIXME: Move this computation out of the window. In fact, this should be a service of the graph, also proposed by the p_line_graph. */ @@ -122,9 +122,9 @@ for (std::vector<util::edge_id>::const_iterator e = node1.edges.begin(); e != node1.edges.end(); ++e) /* We explicitely enforce that the reference piter edge id is - not inserted into NEIGHBORS. */ + not inserted into SITES. */ if (*e != ref_edge_id) - neighbors.insert(*e); + sites.insert(*e); // Ajacent edges connected through node 2. // FIXME: Likewise. util::node_id id2 = piter.p_ref().second_id(); @@ -133,7 +133,7 @@ node2.edges.begin(); e != node2.edges.end(); ++e) // Same remark as above. if (*e != ref_edge_id) - neighbors.insert(*e); + sites.insert(*e); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/line_graph_neighborhood_piter.hh --- mln/core/line_graph_neighborhood_piter.hh (revision 1902) +++ mln/core/line_graph_neighborhood_piter.hh (working copy) @@ -31,22 +31,7 @@ /// \file mln/core/line_graph_neighborhood_piter.hh /// \brief Definition of a point iterator on a line graph neighborhood. -/* FIXME: Factor those classes: - - - mln::graph_window_fwd_piter - - mln::graph_neighborhood_fwd_piter - - mln::line_graph_window_fwd_piter - - mln::line_graph_neighborhood_fwd_piter. - - mln::graph_window_bkd_piter - - mln::graph_neighborhood_bkd_piter - - mln::line_graph_window_bkd_piter - - mln::line_graph_neighborhood_bkd_piter. */ - -# include <set> - -# include <mln/core/concept/point_iterator.hh> -# include <mln/core/p_line_graph.hh> -# include <mln/core/line_graph_psite.hh> +# include <mln/core/internal/line_graph_vicinity_piter.hh> /* FIXME: Due to the poor interface of mln::p_line_graph and mln::util::graph, we show to much implementation details here. @@ -54,10 +39,6 @@ namespace mln { - // Fwd decls. - template <typename P> class p_line_graph; - template <typename P> class line_graph_psite; - /*------------------------------------------. | line_graph_neighborhood_fwd_piter<P, N>. | @@ -66,24 +47,10 @@ /// \brief Forward iterator on line graph neighborhood. template <typename P, typename N> class line_graph_neighborhood_fwd_piter : - public Point_Iterator< line_graph_neighborhood_fwd_piter<P, N> > + public internal::line_graph_vicinity_piter_< P, line_graph_neighborhood_fwd_piter<P, N> > { typedef line_graph_neighborhood_fwd_piter<P, N> self_; - typedef Point_Iterator< self_ > super_; - - public: - 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; - - // The type of the set of neighbors (adjacent edge ids). - typedef std::set<util::edge_id> neighbors_t; + typedef internal::line_graph_vicinity_piter_<P, self_> super_; public: /// Construction. @@ -108,58 +75,14 @@ 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; - - /// Return the reference psite. - const psite& p_ref() const; - /// Return the mln::p_line_graph corresponding to this piter. - const p_line_graph& plg() const; - /// Return the set of neighbors (adjacent edge ids). - neighbors_t& neighbors(); - - /// Read-only access to the \a i-th coordinate. - // FIXME: Dummy. - coord operator[](unsigned i) const; - /// \} - private: /// The neighborhood. const N& nbh_; - /// The ``central'' psite of the neighborhood. - const psite& p_ref_; - /// The last reference psite whose ajacent psites have been computed. - psite saved_p_ref_; - /// The set of edge ids adjacent to the reference psite. - neighbors_t neighbors_; /// An iterator on the set of adjacent edges. - neighbors_t::const_iterator i_; - - /// 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_; + typename super_::sites_t::const_iterator i_; }; - /* 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, typename N> - inline - std::ostream& - operator<<(std::ostream& ostr, - const line_graph_neighborhood_fwd_piter<P, N>& p); - /*------------------------------------------. | line_graph_neighborhood_bkd_piter<P, N>. | @@ -168,24 +91,10 @@ /// \brief Backward iterator on line graph neighborhood. template <typename P, typename N> class line_graph_neighborhood_bkd_piter : - public Point_Iterator< line_graph_neighborhood_bkd_piter<P, N> > + public internal::line_graph_vicinity_piter_< P, line_graph_neighborhood_bkd_piter<P, N> > { typedef line_graph_neighborhood_bkd_piter<P, N> self_; - typedef Point_Iterator< self_ > super_; - - public: - 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; - - // The type of the set of neighbors (adjacent edge ids). - typedef std::set<util::edge_id> neighbors_t; + typedef internal::line_graph_vicinity_piter_<P, self_> super_; public: /// Construction. @@ -210,58 +119,14 @@ 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; - - /// Return the reference psite. - const psite& p_ref() const; - /// Return the mln::p_line_graph corresponding to this piter. - const p_line_graph& plg() const; - /// Return the set of neighbors (adjacent edge ids). - neighbors_t& neighbors(); - - /// Read-only access to the \a i-th coordinate. - // FIXME: Dummy. - coord operator[](unsigned i) const; - /// \} - private: /// The neighborhood. const N& nbh_; - /// The ``central'' psite of the neighborhood. - const psite& p_ref_; - /// The last reference psite whose ajacent psites have been computed. - psite saved_p_ref_; - /// The set of edge ids adjacent to the reference psite. - neighbors_t neighbors_; /// An iterator on the set of adjacent edges. - neighbors_t::const_reverse_iterator i_; - - /// 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_; + typename super_::sites_t::const_reverse_iterator i_; }; - /* 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, typename N> - inline - std::ostream& - operator<<(std::ostream& ostr, - const line_graph_neighborhood_bkd_piter<P, N>& p); - # ifndef MLN_INCLUDE_ONLY @@ -275,10 +140,8 @@ inline line_graph_neighborhood_fwd_piter<P, N>::line_graph_neighborhood_fwd_piter(const Neighborhood<N>& nbh, const Point_Site<Pref>& p_ref) - : nbh_(exact(nbh)), - p_ref_(exact(p_ref).to_psite()), - // Initialize psite_ to a dummy value. - psite_() + : super_(p_ref), + nbh_(exact(nbh)) { // Invalidate i_. invalidate(); @@ -291,12 +154,12 @@ { return // The reference point must be valid... - p_ref_.is_valid() + this->p_ref_.is_valid() // ...and must not have changed since the neighborhood has been // computed... - && p_ref_ == saved_p_ref_ + && this->p_ref_ == this->saved_p_ref_ // ...and the iterator i_ must point a valid value. - && i_ != neighbors_.end(); + && i_ != this->sites_.end(); } template <typename P, typename N> @@ -304,7 +167,7 @@ void line_graph_neighborhood_fwd_piter<P, N>::invalidate() { - i_ = neighbors_.end(); + i_ = this->sites_.end(); } template <typename P, typename N> @@ -312,14 +175,14 @@ void line_graph_neighborhood_fwd_piter<P, N>::start() { - mln_precondition(p_ref_.is_valid()); + mln_precondition(this->p_ref_.is_valid()); // Update the neighbors, if needed. - if (!saved_p_ref_.is_valid() || p_ref_ != saved_p_ref_) + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) { - saved_p_ref_ = p_ref_; - nbh_.compute_neighbors_(*this); + this->saved_p_ref_ = this->p_ref_; + nbh_.compute_sites_(*this); } - i_ = neighbors_.begin(); + i_ = this->sites_.begin(); // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); @@ -331,7 +194,7 @@ line_graph_neighborhood_fwd_piter<P, N>::next_() { // Ensure the p_ref_ has not changed. - mln_precondition(p_ref_ == saved_p_ref_); + mln_precondition(this->p_ref_ == this->saved_p_ref_); ++i_; // FIXME: We might move the is_valid condition within update_. if (is_valid()) @@ -344,73 +207,7 @@ line_graph_neighborhood_fwd_piter<P, N>::update_() { // Update psite_. - psite_ = line_graph_psite(plg(), *i_); - } - - template <typename P, typename N> - inline - const P& - line_graph_neighborhood_fwd_piter<P, N>::to_point() const - { - return p_; - } - - template <typename P, typename N> - inline - const line_graph_psite& - line_graph_neighborhood_fwd_piter<P, N>::to_psite() const - { - return psite_; - } - - template <typename P, typename N> - inline - line_graph_neighborhood_fwd_piter<P, N>::operator line_graph_psite () const - { - mln_precondition(is_valid()); - return psite_; - } - - template <typename P, typename N> - inline - const line_graph_psite& - line_graph_neighborhood_fwd_piter<P, N>::p_ref() const - { - return p_ref_; - } - - template <typename P, typename N> - inline - const p_line_graph& - line_graph_neighborhood_fwd_piter<P, N>::plg() const - { - return p_ref_.plg(); - } - - template <typename P, typename N> - inline - std::set<util::edge_id>& - line_graph_neighborhood_fwd_piter<P, N>::neighbors() - { - return neighbors_; - } - - template <typename P, typename N> - inline - mln_coord(P) - line_graph_neighborhood_fwd_piter<P, N>::operator[](unsigned i) const - { - assert(i < dim); - return p_[i]; - } - - template <typename P, typename N> - inline - std::ostream& - operator<<(std::ostream& ostr, - const line_graph_neighborhood_fwd_piter<P, N>& p) - { - return ostr << p.to_psite(); + this->psite_ = line_graph_psite(this->plg(), *i_); } @@ -423,10 +220,8 @@ inline line_graph_neighborhood_bkd_piter<P, N>::line_graph_neighborhood_bkd_piter(const Neighborhood<N>& nbh, const Point_Site<Pref>& p_ref) - : nbh_(exact(nbh)), - p_ref_(exact(p_ref).to_psite()), - // Initialize psite_ to a dummy value. - psite_() + : super_(p_ref), + nbh_(exact(nbh)) { // Invalidate i_. invalidate(); @@ -439,12 +234,12 @@ { return // The reference point must be valid... - p_ref_.is_valid() + this->p_ref_.is_valid() // ...and must not have changed since the neighborhood has been // computed... - && p_ref_ == saved_p_ref_ + && this->p_ref_ == this->saved_p_ref_ // ...and the iterator i_ must point a valid value. - && i_ != neighbors_.rend(); + && i_ != this->sites_.rend(); } template <typename P, typename N> @@ -452,7 +247,7 @@ void line_graph_neighborhood_bkd_piter<P, N>::invalidate() { - i_ = neighbors_.rend(); + i_ = this->sites_.rend(); } template <typename P, typename N> @@ -460,14 +255,14 @@ void line_graph_neighborhood_bkd_piter<P, N>::start() { - mln_precondition(p_ref_.is_valid()); + mln_precondition(this->p_ref_.is_valid()); // Update the neighbors, if needed. - if (!saved_p_ref_.is_valid() || p_ref_ != saved_p_ref_) + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) { - saved_p_ref_ = p_ref_; - nbh_.compute_neighbors_(*this); + this->saved_p_ref_ = this->p_ref_; + nbh_.compute_sites_(*this); } - i_ = neighbors_.rbegin(); + i_ = this->sites_.rbegin(); // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); @@ -479,7 +274,7 @@ line_graph_neighborhood_bkd_piter<P, N>::next_() { // Ensure the p_ref_ has not changed. - mln_precondition(p_ref_ == saved_p_ref_); + mln_precondition(this->p_ref_ == this->saved_p_ref_); ++i_; // FIXME: We might move the is_valid condition within update_. if (is_valid()) @@ -492,73 +287,7 @@ line_graph_neighborhood_bkd_piter<P, N>::update_() { // Update psite_. - psite_ = line_graph_psite(plg(), *i_); - } - - template <typename P, typename N> - inline - const P& - line_graph_neighborhood_bkd_piter<P, N>::to_point() const - { - return p_; - } - - template <typename P, typename N> - inline - const line_graph_psite& - line_graph_neighborhood_bkd_piter<P, N>::to_psite() const - { - return psite_; - } - - template <typename P, typename N> - inline - line_graph_neighborhood_bkd_piter<P, N>::operator line_graph_psite () const - { - mln_precondition(is_valid()); - return psite_; - } - - template <typename P, typename N> - inline - const line_graph_psite& - line_graph_neighborhood_bkd_piter<P, N>::p_ref() const - { - return p_ref_; - } - - template <typename P, typename N> - inline - const p_line_graph& - line_graph_neighborhood_bkd_piter<P, N>::plg() const - { - return p_ref_.plg(); - } - - template <typename P, typename N> - inline - std::set<util::edge_id>& - line_graph_neighborhood_bkd_piter<P, N>::neighbors() - { - return neighbors_; - } - - template <typename P, typename N> - inline - mln_coord(P) - line_graph_neighborhood_bkd_piter<P, N>::operator[](unsigned i) const - { - assert(i < dim); - return p_[i]; - } - - template <typename P, typename N> - inline - std::ostream& - operator<<(std::ostream& ostr, - const line_graph_neighborhood_bkd_piter<P, N>& p) - { - return ostr << p.to_psite(); + this->psite_ = line_graph_psite(this->plg(), *i_); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/internal/line_graph_vicinity_piter.hh --- mln/core/internal/line_graph_vicinity_piter.hh (revision 1902) +++ mln/core/internal/line_graph_vicinity_piter.hh (working copy) @@ -37,6 +37,8 @@ - mln::internal::graph_vicinity_piter.hh - mln::internal::line_graph_vicinity_piter.hh */ +# include <set> + # include <mln/core/concept/point_iterator.hh> # include <mln/core/p_line_graph.hh> # include <mln/core/line_graph_psite.hh>

16 years

1902: Add beta tikz saving and tests.

by Alexandre Abraham

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Alexandre Abraham <abraham(a)lrde.epita.fr> Add beta tikz saving and tests. * sandbox/abraham/tests: New. * sandbox/abraham/tests/tikz.cc: New Basic test for tikz saving. * sandbox/abraham/tests/Makefile: New. * sandbox/abraham/io: New. * sandbox/abraham/io/tikz: New. * sandbox/abraham/io/tikz/save.hh: New (mln::io::tikz::save) Save an image to tikz. * sandbox/abraham/img: New. * sandbox/abraham/img/test.pgm: New. * sandbox/abraham/img/lena.pgm: New. * sandbox/abraham/img/lena.ppm: New. img/lena.pgm | 5 + img/lena.ppm | 5 + io/tikz/save.hh | 202 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ tests/Makefile | 9 ++ tests/tikz.cc | 37 ++++++++++ 5 files changed, 258 insertions(+) Index: sandbox/abraham/tests/tikz.cc --- sandbox/abraham/tests/tikz.cc (revision 0) +++ sandbox/abraham/tests/tikz.cc (revision 0) @@ -0,0 +1,37 @@ +#include <mln/core/image2d.hh> +#include <mln/value/rgb.hh> +#include <mln/value/int_u.hh> +#include <mln/io/ppm/load.hh> +#include <mln/io/pgm/load.hh> + +#include "io/tikz/save.hh" + +int main () { + using namespace mln; + using value::rgb; + + typedef image2d< rgb<8> > image2drgb; + + image2drgb input; + + io::ppm::load(input, "../img/lena.ppm"); + + io::tikz::save(input, "tex/lena.tex"); + + typedef image2d< value::int_u<4> > image2dint4; + typedef image2d< value::int_u<8> > image2dint8; + + image2dint8 input2; + + io::pgm::load(input2, "../img/test.pgm"); + + image2dint4 input3 (input2.domain(), input2.border()); + image2dint8::fwd_piter p(input2.domain()); + + for_all(p) + input3(p) = input2(p); + + io::tikz::save(input3, "tex/test.tex"); + + return 0; +} // int main () Index: sandbox/abraham/tests/Makefile --- sandbox/abraham/tests/Makefile (revision 0) +++ sandbox/abraham/tests/Makefile (revision 0) @@ -0,0 +1,9 @@ +CXXFLAGS=-Wall -W -I ../../.. -g -I ../ + +tikz: tikz.o + g++ ${CXXFLAGS} tikz.o -o tikz + +all: + +tikz.o : tikz.cc +tikz.cc: ../io/tikz/save.hh \ No newline at end of file Index: sandbox/abraham/io/tikz/save.hh --- sandbox/abraham/io/tikz/save.hh (revision 0) +++ sandbox/abraham/io/tikz/save.hh (revision 0) @@ -0,0 +1,202 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 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_IO_TIKZ_SAVE_HH +# define MLN_IO_TIKZ_SAVE_HH + +/*! + * \file mln/io/tikz/save.hh + * + * \brief Define a function which saves an image of kind TIKZ into + * given path. + * + */ + +# include <iostream> +# include <fstream> + +# include <mln/core/concept/image.hh> +# include <mln/core/point2d.hh> + +# include <mln/value/graylevel.hh> +# include <mln/value/rgb.hh> +# include <mln/value/int_u.hh> + +# include <mln/metal/templated_by.hh> + +# include <mln/io/pnm/save_header.hh> +# include <mln/io/pnm/macros.hh> + +# include <mln/geom/size2d.hh> + +namespace mln +{ + + namespace io + { + + namespace tikz + { + + /*! Save a milena image as a tikz image. + * + * \param[in] ima_ The image to save. + * \param[in,out] filename the destination. + */ + template <typename I> + void save(const Image& ima_, const std::string& filename); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // write a greylevel value into + template <unsigned int n> + inline + void write_value(std::ofstream& file, + const value::int_u<n>& v) + { + int c = v; + file << "black!" << (int(mln::trait::value_< mln::value::int_u<n> >::max()) - c) * 100 / int(mln::trait::value_< mln::value::int_u<n> >::max()); + } + + // write a rgb value into + template <unsigned int n> + inline + void write_value(std::ofstream& file, + const value::rgb<n>& v) + { + mln::value::int_u<n> cvalues[] = {v.red(), v.green(), v.blue()}; + char *cnames[] = {"red", "green", "blue"}; + short colors[] = {0, 1, 2}, tmp; + + // Sort colors increasing + if (cvalues[colors[0]] > cvalues[colors[1]]) + { + tmp = colors[0]; + colors[0] = colors[1]; + colors[1] = tmp; + } + + if (cvalues[colors[1]] > cvalues[colors[2]]) + { + tmp = colors[1]; + colors[1] = colors[2]; + colors[2] = tmp; + } + + if (cvalues[colors[0]] > cvalues[colors[1]]) + { + tmp = colors[0]; + colors[0] = colors[1]; + colors[1] = tmp; + } + + double c1 = cvalues[colors[1]] - cvalues[colors[0]], + c2 = cvalues[colors[2]] - cvalues[colors[0]]; + + double w = 1 - double(cvalues[colors[0]]) / 255.; + + c1 /= w; + c2 /= w; + + double c = 1 - c1 / 255.; + + c2 -= c1; + c2 /= c; + + double p = 1 - c2 / 255.; + + file << "black!" << int(p * 100) << "!" << cnames[colors[2]] << "!" + << int(c * 100) << "!" << "-" << cnames[colors[0]] << "!" + << int(w * 100) << "!white"; + } + + // Save data + template <typename I> + inline + void save_data_(std::ofstream& file, + const I& ima) + { + const int + min_row = geom::min_row(ima), + max_row = geom::max_row(ima), + min_col = geom::min_col(ima), + max_col = geom::max_col(ima); + + point2d p; + for (p.row() = min_row; p.row() <= max_row; ++p.row()) + for (p.col() = min_col; p.col() <= max_col; ++p.col()) + { + file << "\\path (" << p.col() << "," << max_row - p.row() << ") node[fill="; + write_value(file, ima(p)); + file << "] (p_" << p.row() << "_" << p.col() << ") { \\scriptsize \\color{"; + file << "black"; + file << "}" << ima(p) << "};" << std::endl; + } + } + + } // end of namespace mln::io::pnm::impl + + + // Facades. + + template <typename I> + inline + void save(const Image& ima_, const std::string& filename) + { + const I& ima = exact(ima_); + std::ofstream file(filename.c_str()); + // io::tikz::save_header(ima, file); + + file << "\\documentclass[12pt,a4paper]{article}" << std::endl; + file << "\\usepackage{tikz}" << std::endl; + + file << "\\begin{document}" << std::endl; + file << "\\begin{tikzpicture}" << std::endl; + file << "\\tikzstyle{every node}=[draw,shape=rectangle, minimum width=1cm, minimum height=1cm]" << std::endl; + + impl::save_data_(file, + ima); + + file << "\\end{tikzpicture}" << std::endl; + file << "\\end{document}" << std::endl; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::io::tikz + + } // end of namespace mln::io + +} // end of namespace mln + + +#endif // ! MLN_IO_TIKZ_SAVE_HH Index: sandbox/abraham/img/test.pgm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: sandbox/abraham/img/test.pgm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: sandbox/abraham/img/lena.pgm --- sandbox/abraham/img/lena.pgm (revision 0) +++ sandbox/abraham/img/lena.pgm (revision 0) @@ -0,0 +1,5 @@ +P5 +# CREATOR: GIMP PNM Filter Version 1.1 +16 16 +255 +[kyzyzxrrTXitx}px®S*mSeop¯Áwws,FXQfkv´ÅÊ[88^Srjw©²¹´¹Å.t`Rt{~rpªÀ©nEaQajC=±n.q]Tgl;4®D8UWiH<YqWHRC]U9FeqIrÆGTJQg:vPL¶ÐBOMo?2W1UÅÌNHFeD/O uX}r¾W_66QX6bÆy[a7/I<Gn¹¡e£]Qv2>C7_|¥·_jOJ \ No newline at end of file Index: sandbox/abraham/img/lena.ppm --- sandbox/abraham/img/lena.ppm (revision 0) +++ sandbox/abraham/img/lena.ppm (revision 0) @@ -0,0 +1,5 @@ +P6 +# CREATOR: GIMP PNM Filter Version 1.1 +16 16 +255 +ânàkDR¿TVÎb_Ñc`Ïb`Îc`Ìa_Ä\^ÏpjálàrÐrÁ]^@Qäjá}f«@MÀQUÎ\\ÎacËpqÍ~ËhjÇX\ÊbdÞ~nÜxgæ¢@Q`@ÁVUâ}e£<MºMTÈWY¾ZaÇrt×¥Ý»¯¾otÊ`bÈabÝqe½__b@{5RªANà|i¢:LºOVÀTYÄ`eËvwÛ« à¾´ßÅ»Êpn GVÖq%Gn&JÈ~y´FNãj§;JÂ]ZÀRWÇagÔÚÛ¨Ù±©Û«Û±¥à¿²aD±cnÓ}·HPåk¥:JÁ_[ÒmaÉejÅjv©a}¢`wÔÝ¹«Ð¡_k}3SÓÐ}·IQæm£9J¶IQÕ}pµThx0]o+YµØ¨Â¦]kf@ªakÔÏ±FPæp¥=O¿OUµWbo)Vf"Q¸v|ËèÖz2Sn&IË{Ë~Æ}§=Kèq¬?M¨Wgv7gj+YI_Çsv´]nßBY6VAWÎyÈyÉ-Fçq§Gb}Ezh(T}5SUcÙfjåàÀ[f7SbfÈyÎzìÀ1Hèu>\t:o~AjXhw'FØ[_ÞooÛzy<V:RÈ}rÃ}wãîË¥-Hçw;]s>r`r.LlA?LÛgjÏishCBUÉy»|wé¿îÇ=Uäuz7Zp6fXt4YcC9MÔilÙ isFX·mnªbgè·ERRgæsg%Ld&RxBuJnq#D·JSÜjfá}í¾©ko½ysÑ{Íl¢GVTgãpk&M^Jo:ik,S2FÄW[ÞicÞyoæ®ÎU^Út§HP>TjuÜpc!Jj.[m4an%H´GLÙc\ßmfÞsháÜ®¤MX±WW=S8Q \ No newline at end of file

16 years

1901: Fix adjacency test in p_graph.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix adjacency test in p_graph. * mln/core/p_graph.hh (mln::p_graph::adjacent): Don't return true when arguments (rhs and lhs) are equal. p_graph.hh | 3 +++ 1 file changed, 3 insertions(+) Index: mln/core/p_graph.hh --- mln/core/p_graph.hh (revision 1900) +++ mln/core/p_graph.hh (working copy) @@ -255,6 +255,9 @@ mln_assertion(lhs < this->npoints()); mln_assertion(rhs < this->npoints()); + // Ensure LHS and RHS are *not* equal. + if (rhs == lhs) + return false; // Check whether RHS and LHS are adjacent (i.e., whether RHS is // among the neighbors of LHS). typedef std::vector<util::edge_id> edges_t;

16 years

1900: Fix the computation of neighbors in mln::line_graph_elt_neighborhood.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix the computation of neighbors in mln::line_graph_elt_neighborhood. * mln/core/line_graph_elt_neighborhood.hh (compute_neighbors_): Don't add the reference point to the set of neighbors. line_graph_elt_neighborhood.hh | 10 ++++++++++ 1 file changed, 10 insertions(+) Index: mln/core/line_graph_elt_neighborhood.hh --- mln/core/line_graph_elt_neighborhood.hh (revision 1899) +++ mln/core/line_graph_elt_neighborhood.hh (working copy) @@ -40,6 +40,10 @@ - mln::line_graph_elt_window - mln::line_graph_elt_neighborhood. */ +/* FIXME: Due to the poor interface of mln::p_line_graph and + mln::util::graph, we show to much implementation details here. + Enrich their interfaces to avoid that. */ + # include <set> # include <mln/core/concept/neighborhood.hh> @@ -105,6 +109,7 @@ line_graph_elt_neighborhood::compute_neighbors_(Point_Iterator<Piter>& piter_) const { Piter& piter = exact(piter_); + util::edge_id ref_edge_id = piter.p_ref().id(); neighbors_t& neighbors = piter.neighbors(); neighbors.clear(); /* FIXME: Move this computation out of the window. In fact, @@ -116,6 +121,9 @@ const util::node& node1 = piter.plg().gr_->node(id1); for (std::vector<util::edge_id>::const_iterator e = node1.edges.begin(); e != node1.edges.end(); ++e) + /* We explicitely enforce that the reference piter edge id is + not inserted into NEIGHBORS. */ + if (*e != ref_edge_id) neighbors.insert(*e); // Ajacent edges connected through node 2. // FIXME: Likewise. @@ -123,6 +131,8 @@ const util::node& node2 = piter.plg().gr_->node(id2); for (std::vector<util::edge_id>::const_iterator e = node2.edges.begin(); e != node2.edges.end(); ++e) + // Same remark as above. + if (*e != ref_edge_id) neighbors.insert(*e); }

16 years

1899: Factor implementation of piters on line graph windows.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Factor implementation of piters on line graph windows. * mln/core/internal/line_graph_vicinity_piter.hh: New. Factored implementation for piters on line graph windows and neighborhoods. * mln/core/line_graph_window_piter.hh (mln::line_graph_window_fwd_piter<P, W>) (mln::line_graph_window_bkd_piter<P, W>): Inherit from mln::internal::line_graph_vicinity_piter_. (mln::line_graph_window_fwd_piter<P, W>::super_) (mln::line_graph_window_bkd_piter<P, W>::super_): Adjust typedef. (mln::line_graph_window_fwd_piter<P, W>::psite) (mln::line_graph_window_fwd_piter<P, W>::point) (mln::line_graph_window_fwd_piter<P, W>::coord) (mln::line_graph_window_fwd_piter<P, W>::dpoint) (mln::line_graph_window_fwd_piter<P, W>::mesh) (mln::line_graph_window_fwd_piter<P, W>::sites_t) (mln::line_graph_window_bkd_piter<P, W>::psite) (mln::line_graph_window_bkd_piter<P, W>::point) (mln::line_graph_window_bkd_piter<P, W>::coord) (mln::line_graph_window_bkd_piter<P, W>::dpoint) (mln::line_graph_window_bkd_piter<P, W>::mesh) (mln::line_graph_window_bkd_piter<P, W>::sites_t): Remove (now useless) typedefs. (mln::line_graph_window_fwd_piter<P, W>::to_point) (mln::line_graph_window_fwd_piter<P, W>::to_psite) (mln::line_graph_window_fwd_piter<P, W>::operator psite) (mln::line_graph_window_fwd_piter<P, W>::p_ref) (mln::line_graph_window_fwd_piter<P, W>::plg) (mln::line_graph_window_fwd_piter<P, W>::sites) (mln::line_graph_window_fwd_piter<P, W>::operator[]) (mln::line_graph_window_bkd_piter<P, W>::to_point) (mln::line_graph_window_bkd_piter<P, W>::to_psite) (mln::line_graph_window_bkd_piter<P, W>::operator psite) (mln::line_graph_window_bkd_piter<P, W>::p_ref) (mln::line_graph_window_bkd_piter<P, W>::plg) (mln::line_graph_window_bkd_piter<P, W>::sites) (mln::line_graph_window_bkd_piter<P, W>::operator[]): Remove methods. (mln::line_graph_window_fwd_piter<P, W>::p_ref_) (mln::line_graph_window_fwd_piter<P, W>::saved_p_ref_) (mln::line_graph_window_fwd_piter<P, W>::sites_) (mln::line_graph_window_fwd_piter<P, W>::psite_) (mln::line_graph_window_fwd_piter<P, W>::point_) (mln::line_graph_window_bkd_piter<P, W>::p_ref_) (mln::line_graph_window_bkd_piter<P, W>::saved_p_ref_) (mln::line_graph_window_bkd_piter<P, W>::sites_) (mln::line_graph_window_bkd_piter<P, W>::psite_) (mln::line_graph_window_bkd_piter<P, W>::point_): Remove attributes. (operator<<(std::ostream&, const line_graph_window_fwd_piter<P, W>&)) (operator<<(std::ostream&, const line_graph_window_bkd_piter<P, W>&)): Remove. internal/line_graph_vicinity_piter.hh | 218 ++++++++++++++++++++++ line_graph_window_piter.hh | 334 +++------------------------------- 2 files changed, 253 insertions(+), 299 deletions(-) Index: mln/core/internal/line_graph_vicinity_piter.hh --- mln/core/internal/line_graph_vicinity_piter.hh (revision 0) +++ mln/core/internal/line_graph_vicinity_piter.hh (revision 0) @@ -0,0 +1,218 @@ +// Copyright (C) 2007, 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. + +#ifndef MLN_CORE_INTERNAL_LINE_GRAPH_VICINITY_PITER_HH +# define MLN_CORE_INTERNAL_LINE_GRAPH_VICINITY_PITER_HH + +/// \file mln/core/internal/line_graph_vicinity_piter.hh +/// \brief Factored implementation for point iterators on a line graph windows +/// and line graph neighborhoods, called "vicinities". + +/* FIXME: Factor those classes: + + - mln::internal::graph_vicinity_piter.hh + - mln::internal::line_graph_vicinity_piter.hh */ + +# include <mln/core/concept/point_iterator.hh> +# include <mln/core/p_line_graph.hh> +# include <mln/core/line_graph_psite.hh> + +namespace mln +{ + // Fwd decls. + template <typename P> class p_line_graph; + template <typename P> class line_graph_psite; + + + /*---------------------------------------------. + | internal::line_graph_vicinity_piter_<P, E>. | + `---------------------------------------------*/ + + namespace internal + { + + /// \brief Base for iterator on a line graph vicinity. + template <typename P, typename E> + class line_graph_vicinity_piter_ : public Point_Iterator< E > + { + typedef line_graph_vicinity_piter_<P, E> self_; + typedef Point_Iterator< self_ > super_; + + public: + 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; + + // The type of the set of vicinity sites (adjacent edge ids). + typedef std::set<util::edge_id> sites_t; + + public: + /// 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; + + /// Return the reference psite. + const psite& p_ref() const; + /// Return the mln::p_line_graph corresponding to this piter. + const p_line_graph& plg() const; + /// Return the set of sites (adjacent edge ids). + sites_t& sites(); + + /// Read-only access to the \a i-th coordinate. + coord operator[](unsigned i) const; + /// \} + + protected: + /// Construction. + /// \{ + template <typename Pref> + line_graph_vicinity_piter_(const Point_Site<Pref>& p_ref); + /// \} + + protected: + /// The ``central'' psite of the vicinity. + const psite& p_ref_; + + /// The last reference psite whose ajacent psites have been computed. + psite saved_p_ref_; + /// The set of edge ids adjacent to the reference psite. + sites_t sites_; + + /// 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, typename E> + inline + std::ostream& + operator<<(std::ostream& ostr, const line_graph_vicinity_piter_<P, E>& p); + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename P, typename E> + template <typename Pref> + inline + line_graph_vicinity_piter_<P, E>::line_graph_vicinity_piter_(const Point_Site<Pref>& p_ref) + : p_ref_(exact(p_ref).to_psite()), + // Initialize psite_ to a dummy value. + psite_() + { + } + + template <typename P, typename E> + inline + const P& + line_graph_vicinity_piter_<P, E>::to_point() const + { + return p_; + } + + template <typename P, typename E> + inline + const line_graph_psite& + line_graph_vicinity_piter_<P, E>::to_psite() const + { + return psite_; + } + + template <typename P, typename E> + inline + line_graph_vicinity_piter_<P, E>::operator line_graph_psite () const + { + mln_precondition(exact(*this).is_valid()); + return psite_; + } + + template <typename P, typename E> + inline + const line_graph_psite& + line_graph_vicinity_piter_<P, E>::p_ref() const + { + return p_ref_; + } + + template <typename P, typename E> + inline + const p_line_graph& + line_graph_vicinity_piter_<P, E>::plg() const + { + return p_ref_.plg(); + } + + template <typename P, typename E> + inline + std::set<util::edge_id>& + line_graph_vicinity_piter_<P, E>::sites() + { + return sites_; + } + + template <typename P, typename E> + inline + mln_coord(P) + line_graph_vicinity_piter_<P, E>::operator[](unsigned i) const + { + assert(i < dim); + return p_[i]; + } + + template <typename P, typename E> + inline + std::ostream& + operator<<(std::ostream& ostr, const line_graph_vicinity_piter_<P, E>& p) + { + return ostr << p.to_psite(); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::internal + +} // end of namespace mln + +#endif // ! MLN_CORE_INTERNAL_LINE_GRAPH_VICINITY_PITER_HH Index: mln/core/line_graph_window_piter.hh --- mln/core/line_graph_window_piter.hh (revision 1898) +++ mln/core/line_graph_window_piter.hh (working copy) @@ -31,20 +31,7 @@ /// \file mln/core/line_graph_window_piter.hh /// \brief Definition of a point iterator on a line_graph window. -/* FIXME: Factor those classes: - - - mln::graph_window_fwd_piter - - mln::graph_neighborhood_fwd_piter - - mln::line_graph_window_fwd_piter - - mln::line_graph_neighborhood_fwd_piter. - - mln::graph_window_bkd_piter - - mln::graph_neighborhood_bkd_piter - - mln::line_graph_window_bkd_piter - - mln::line_graph_neighborhood_bkd_piter. */ - -# include <mln/core/concept/point_iterator.hh> -# include <mln/core/p_line_graph.hh> -# include <mln/core/line_graph_psite.hh> +# include <mln/core/internal/line_graph_vicinity_piter.hh> /* FIXME: Due to the poor interface of mln::p_line_graph and mln::util::graph, we show to much implementation details here. @@ -52,10 +39,6 @@ namespace mln { - // Fwd decls. - template <typename P> class p_line_graph; - template <typename P> class line_graph_psite; - /*------------------------------------. | line_graph_window_fwd_piter<P, W>. | @@ -63,25 +46,11 @@ /// \brief Forward iterator on line graph window. template <typename P, typename W> - class line_graph_window_fwd_piter : - public Point_Iterator< line_graph_window_fwd_piter<P, W> > + class line_graph_window_fwd_piter + : public internal::line_graph_vicinity_piter_<P, line_graph_window_fwd_piter<P, W> > { typedef line_graph_window_fwd_piter<P, W> self_; - typedef Point_Iterator< self_ > super_; - - public: - 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; - - // The type of the set of window sites (adjacent edge ids). - typedef std::set<util::edge_id> sites_t; + typedef internal::line_graph_vicinity_piter_<P, self_ > super_; public: /// Construction. @@ -106,56 +75,14 @@ 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; - - /// Return the reference psite. - const psite& p_ref() const; - /// Return the mln::p_line_graph corresponding to this piter. - const p_line_graph& plg() const; - /// Return the set of sites (adjacent edge ids). - sites_t& sites(); - - /// Read-only access to the \a i-th coordinate. - coord operator[](unsigned i) const; - /// \} - private: /// The window. const W& win_; - /// The ``central'' psite of the window. - const psite& p_ref_; - /// The last reference psite whose ajacent psites have been computed. - psite saved_p_ref_; - /// The set of edge ids adjacent to the reference psite. - sites_t sites_; /// An iterator on the set of adjacent edges. - sites_t::const_iterator i_; - - /// 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_; + typename super_::sites_t::const_iterator i_; }; - /* 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, typename W> - inline - std::ostream& - operator<<(std::ostream& ostr, const line_graph_window_fwd_piter<P, W>& p); - /*------------------------------------. | line_graph_window_bkd_piter<P, W>. | @@ -163,25 +90,11 @@ /// \brief Backward iterator on line graph window. template <typename P, typename W> - class line_graph_window_bkd_piter : - public Point_Iterator< line_graph_window_bkd_piter<P, W> > + class line_graph_window_bkd_piter + : public internal::line_graph_vicinity_piter_<P, line_graph_window_bkd_piter<P, W> > { typedef line_graph_window_bkd_piter<P, W> self_; - typedef Point_Iterator< self_ > super_; - - public: - 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; - - // The type of the set of window sites (adjacent edge ids). - typedef std::set<util::edge_id> sites_t; + typedef internal::line_graph_vicinity_piter_<P, self_ > super_; public: /// Construction. @@ -206,56 +119,14 @@ 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; - - /// Return the reference psite. - const psite& p_ref() const; - /// Return the mln::p_line_graph corresponding to this piter. - const p_line_graph& plg() const; - /// Return the set of sites (adjacent edge ids). - sites_t& sites(); - - /// Read-only access to the \a i-th coordinate. - coord operator[](unsigned i) const; - /// \} - private: /// The window. const W& win_; - /// The ``central'' psite of the window. - const psite& p_ref_; - /// The last reference psite whose ajacent psites have been computed. - psite saved_p_ref_; - /// The set of edge ids adjacent to the reference psite. - sites_t sites_; /// An iterator on the set of adjacent edges. - sites_t::const_reverse_iterator i_; - - /// 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_; + typename super_::sites_t::const_reverse_iterator i_; }; - /* 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, typename W> - inline - std::ostream& - operator<<(std::ostream& ostr, const line_graph_window_bkd_piter<P, W>& p); - # ifndef MLN_INCLUDE_ONLY @@ -269,12 +140,10 @@ inline line_graph_window_fwd_piter<P, W>::line_graph_window_fwd_piter(const Window<W>& win, const Point_Site<Pref>& p_ref) - : win_(exact(win)), - p_ref_(exact(p_ref).to_psite()), - // Initialize psite_ to a dummy value. - psite_() + : super_(p_ref), + win_(exact(win)) { - // Invalidate id_. + // Invalidate i_. invalidate(); } @@ -285,11 +154,11 @@ { return // The reference point must be valid... - p_ref_.is_valid() + this->p_ref_.is_valid() // ...and must not have changed since the window has been computed... - && p_ref_ == saved_p_ref_ + && this->p_ref_ == this->saved_p_ref_ // ...and the iterator i_ must point a valid value. - && i_ != sites_.end(); + && i_ != this->sites_.end(); } template <typename P, typename W> @@ -297,7 +166,7 @@ void line_graph_window_fwd_piter<P, W>::invalidate() { - i_ = sites_.end(); + i_ = this->sites_.end(); } template <typename P, typename W> @@ -305,14 +174,14 @@ void line_graph_window_fwd_piter<P, W>::start() { - mln_precondition(p_ref_.is_valid()); + mln_precondition(this->p_ref_.is_valid()); // Update the sites, if needed. - if (!saved_p_ref_.is_valid() || p_ref_ != saved_p_ref_) + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) { - saved_p_ref_ = p_ref_; + this->saved_p_ref_ = this->p_ref_; win_.compute_sites_(*this); } - i_ = sites_.begin(); + i_ = this->sites_.begin(); // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); @@ -324,7 +193,7 @@ line_graph_window_fwd_piter<P, W>::next_() { // Ensure the p_ref_ has not changed. - mln_precondition(p_ref_ == saved_p_ref_); + mln_precondition(this->p_ref_ == this->saved_p_ref_); ++i_; // FIXME: We might move the is_valid condition within update_. if (is_valid()) @@ -337,72 +206,7 @@ line_graph_window_fwd_piter<P, W>::update_() { // Update psite_. - psite_ = line_graph_psite(plg(), *i_); - } - - template <typename P, typename W> - inline - const P& - line_graph_window_fwd_piter<P, W>::to_point() const - { - return p_; - } - - template <typename P, typename W> - inline - const line_graph_psite& - line_graph_window_fwd_piter<P, W>::to_psite() const - { - return psite_; - } - - template <typename P, typename W> - inline - line_graph_window_fwd_piter<P, W>::operator line_graph_psite () const - { - mln_precondition(is_valid()); - return psite_; - } - - template <typename P, typename W> - inline - const line_graph_psite& - line_graph_window_fwd_piter<P, W>::p_ref() const - { - return p_ref_; - } - - template <typename P, typename W> - inline - const p_line_graph& - line_graph_window_fwd_piter<P, W>::plg() const - { - return p_ref_.plg(); - } - - template <typename P, typename W> - inline - std::set<util::edge_id>& - line_graph_window_fwd_piter<P, W>::sites() - { - return sites_; - } - - template <typename P, typename W> - inline - mln_coord(P) - line_graph_window_fwd_piter<P, W>::operator[](unsigned i) const - { - assert(i < dim); - return p_[i]; - } - - template <typename P, typename W> - inline - std::ostream& - operator<<(std::ostream& ostr, const line_graph_window_fwd_piter<P, W>& p) - { - return ostr << p.to_psite(); + this->psite_ = line_graph_psite(this->plg(), *i_); } @@ -410,18 +214,15 @@ | line_graph_window_bkd_piter<P, W>. | `------------------------------------*/ - // FIXME: Currently, argument win is ignored. template <typename P, typename W> template <typename Pref> inline line_graph_window_bkd_piter<P, W>::line_graph_window_bkd_piter(const Window<W>& win, const Point_Site<Pref>& p_ref) - : win_(exact(win)), - p_ref_(exact(p_ref).to_psite()), - // Initialize psite_ to a dummy value. - psite_() + : super_(p_ref), + win_(exact(win)) { - // Invalidate id_. + // Invalidate i_. invalidate(); } @@ -432,11 +233,11 @@ { return // The reference point must be valid... - p_ref_.is_valid() + this->p_ref_.is_valid() // ...and must not have changed since the window has been computed... - && p_ref_ == saved_p_ref_ + && this->p_ref_ == this->saved_p_ref_ // ...and the iterator i_ must point a valid value. - && i_ != sites_.rend(); + && i_ != this->sites_.rend(); } template <typename P, typename W> @@ -444,7 +245,7 @@ void line_graph_window_bkd_piter<P, W>::invalidate() { - i_ = sites_.rend(); + i_ = this->sites_.rend(); } template <typename P, typename W> @@ -452,14 +253,14 @@ void line_graph_window_bkd_piter<P, W>::start() { - mln_precondition(p_ref_.is_valid()); + mln_precondition(this->p_ref_.is_valid()); // Update the sites, if needed. - if (!saved_p_ref_.is_valid() || p_ref_ != saved_p_ref_) + if (!this->saved_p_ref_.is_valid() || this->p_ref_ != this->saved_p_ref_) { - saved_p_ref_ = p_ref_; + this->saved_p_ref_ = this->p_ref_; win_.compute_sites_(*this); } - i_ = sites_.rbegin(); + i_ = this->sites_.rbegin(); // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); @@ -471,7 +272,7 @@ line_graph_window_bkd_piter<P, W>::next_() { // Ensure the p_ref_ has not changed. - mln_precondition(p_ref_ == saved_p_ref_); + mln_precondition(this->p_ref_ == this->saved_p_ref_); ++i_; // FIXME: We might move the is_valid condition within update_. if (is_valid()) @@ -484,72 +285,7 @@ line_graph_window_bkd_piter<P, W>::update_() { // Update psite_. - psite_ = line_graph_psite(plg(), *i_); - } - - template <typename P, typename W> - inline - const P& - line_graph_window_bkd_piter<P, W>::to_point() const - { - return p_; - } - - template <typename P, typename W> - inline - const line_graph_psite& - line_graph_window_bkd_piter<P, W>::to_psite() const - { - return psite_; - } - - template <typename P, typename W> - inline - line_graph_window_bkd_piter<P, W>::operator line_graph_psite () const - { - mln_precondition(is_valid()); - return psite_; - } - - template <typename P, typename W> - inline - const line_graph_psite& - line_graph_window_bkd_piter<P, W>::p_ref() const - { - return p_ref_; - } - - template <typename P, typename W> - inline - const p_line_graph& - line_graph_window_bkd_piter<P, W>::plg() const - { - return p_ref_.plg(); - } - - template <typename P, typename W> - inline - std::set<util::edge_id>& - line_graph_window_bkd_piter<P, W>::sites() - { - return sites_; - } - - template <typename P, typename W> - inline - mln_coord(P) - line_graph_window_bkd_piter<P, W>::operator[](unsigned i) const - { - assert(i < dim); - return p_[i]; - } - - template <typename P, typename W> - inline - std::ostream& - operator<<(std::ostream& ostr, const line_graph_window_bkd_piter<P, W>& p) - { - return ostr << p.to_psite(); + this->psite_ = line_graph_psite(this->plg(), *i_); } # endif // ! MLN_INCLUDE_ONLY

16 years

milena r1898: Modifie literals

by Caroline Vigouroux

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2008-04-29 Caroline Vigouroux <vigour_c(a)epita.fr> Modifie literals. * cmy/rgb_to_cmy.hh: . * literal/black.hh, literal/blue.hh literal/cyan.hh, literal/green.hh literal/red.hh, literal/white.hh: modifications. --- cmy/rgb_to_cmy.hh | 2 +- literal/black.hh | 3 ++- literal/blue.hh | 3 ++- literal/cyan.hh | 3 ++- literal/green.hh | 3 ++- literal/red.hh | 3 ++- literal/white.hh | 3 ++- 7 files changed, 13 insertions(+), 7 deletions(-) Index: trunk/milena/sandbox/vigouroux/cmy/rgb_to_cmy.hh =================================================================== --- trunk/milena/sandbox/vigouroux/cmy/rgb_to_cmy.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/cmy/rgb_to_cmy.hh (revision 1898) @@ -65,7 +65,7 @@ } }; - typedef f_cmy_to_rgb_<value::rgb8> f_cmy_to_rgb_3x8_t; + typedef f_cmy_to_rgb_<value::cmy_f> f_cmy_to_rgb_3x8_t; f_cmy_to_rgb_3x8_t f_cmy_to_rgb_3x8; Index: trunk/milena/sandbox/vigouroux/literal/blue.hh =================================================================== --- trunk/milena/sandbox/vigouroux/literal/blue.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/literal/blue.hh (revision 1898) @@ -7,6 +7,7 @@ */ # include <mln/core/concept/literal.hh> +# include <mln/value/rgb8.hh> namespace mln { @@ -17,7 +18,7 @@ /// Type of literal blue. struct blue_t : public Literal<blue_t> { - T_rgb operator()() const + value::rgb8 operator()() const { return value::rgb8(0,0,255); } Index: trunk/milena/sandbox/vigouroux/literal/cyan.hh =================================================================== --- trunk/milena/sandbox/vigouroux/literal/cyan.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/literal/cyan.hh (revision 1898) @@ -23,7 +23,8 @@ value::rgb8 operator()() const { const value::cmy_f cmy(255,0,0); - value::rgb8 rgb = fun::v2v::f_rgb_to_cmy_f(fun::v2v::f_rgb_to_cmy_f(cmy)); + value::rgb8 rgb; + rgb = fun::v2v::f_cmy_to_rgb_3x8_t(cmy); return rgb; } Index: trunk/milena/sandbox/vigouroux/literal/green.hh =================================================================== --- trunk/milena/sandbox/vigouroux/literal/green.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/literal/green.hh (revision 1898) @@ -7,6 +7,7 @@ */ # include <mln/core/concept/literal.hh> +# include <mln/value/rgb8.hh> namespace mln { @@ -17,7 +18,7 @@ /// Type of literal green. struct green_t : public Literal<green_t> { - T_rgb operator()() const + value::rgb8 operator()() const { return value::rgb8(0,255,0); } Index: trunk/milena/sandbox/vigouroux/literal/red.hh =================================================================== --- trunk/milena/sandbox/vigouroux/literal/red.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/literal/red.hh (revision 1898) @@ -7,6 +7,7 @@ */ # include <mln/core/concept/literal.hh> +# include <mln/value/rgb8.hh> namespace mln { @@ -17,7 +18,7 @@ /// Type of literal red. struct red_t : public Literal<red_t> { - T_rgb operator()() const + value::rgb8 operator()() const { return value::rgb8(255,0,0); } Index: trunk/milena/sandbox/vigouroux/literal/black.hh =================================================================== --- trunk/milena/sandbox/vigouroux/literal/black.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/literal/black.hh (revision 1898) @@ -7,6 +7,7 @@ */ # include <mln/core/concept/literal.hh> +# include <mln/value/rgb8.hh> namespace mln { @@ -17,7 +18,7 @@ /// Type of literal black. struct black_t : public Literal<black_t> { - T_rgb operator()() const + value::rgb8 operator()() const { return value::rgb8(0,0,0); } Index: trunk/milena/sandbox/vigouroux/literal/white.hh =================================================================== --- trunk/milena/sandbox/vigouroux/literal/white.hh (revision 1897) +++ trunk/milena/sandbox/vigouroux/literal/white.hh (revision 1898) @@ -7,6 +7,7 @@ */ # include <mln/core/concept/literal.hh> +# include <mln/value/rgb8.hh> namespace mln { @@ -17,7 +18,7 @@ /// Type of literal white. struct white_t : public Literal<white_t> { - T_rgb operator()() const + value::rgb8 operator()() const { return value::rgb8(255,255,255); }

16 years

1897: Simplify the hierarchy of piters on graph windows and neighborhoods.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Cleared almost 80 lines. Yeepee! Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Simplify the hierarchy of piters on graph windows and neighborhoods. * mln/core/graph_window_piter.hh (mln::internal::graph_window_piter_<P, W, E>): Remove class. (mln::graph_window_fwd_piter<P, W>) (mln::graph_window_bkd_piter<P, W>): Inherit from internal::graph_vicinity_piter_ directly. (mln::graph_window_fwd_piter<P, W>::super_) (mln::graph_window_bkd_piter<P, W>::super_): Adjust typedefs. (mln::graph_window_fwd_piter<P, W>::win_) (mln::graph_window_bkd_piter<P, W>::win_): New members. (mln::graph_window_fwd_piter<P, W>::graph_window_fwd_piter) (mln::graph_window_bkd_piter<P, W>::graph_window_bkd_piter): Adjust ctors. * mln/core/graph_neighborhood_piter.hh (mln::internal::graph_neighborhood_piter_<P, N, E>): Remove class. (mln::graph_neighborhood_fwd_piter<P, N>) (mln::graph_neighborhood_bkd_piter<P, N>): Inherit from internal::graph_vicinity_piter_ directly. (mln::graph_neighborhood_fwd_piter<P, N>::super_) (mln::graph_neighborhood_bkd_piter<P, N>::super_): Adjust typedefs. (mln::graph_neighborhood_fwd_piter<P, N>::nbh_) (mln::graph_neighborhood_bkd_piter<P, N>::nbh_): New members. (mln::graph_neighborhood_fwd_piter<P, N>::graph_neighborhood_fwd_piter) (mln::graph_neighborhood_bkd_piter<P, N>::graph_neighborhood_bkd_piter): Adjust ctors. graph_neighborhood_piter.hh | 72 +++++++++----------------------------------- graph_window_piter.hh | 71 +++++++++---------------------------------- 2 files changed, 32 insertions(+), 111 deletions(-) Index: mln/core/graph_neighborhood_piter.hh --- mln/core/graph_neighborhood_piter.hh (revision 1896) +++ mln/core/graph_neighborhood_piter.hh (working copy) @@ -51,47 +51,17 @@ namespace mln { - /*-----------------------------------------------. - | internal::graph_neighborhood_piter_<P, N, E>. | - `-----------------------------------------------*/ - - namespace internal - { - - /// \brief Base for iterator on a graph neighborhood. - template <typename P, typename N, typename E> - class graph_neighborhood_piter_ : public graph_vicinity_piter_<P, E> - { - typedef graph_neighborhood_piter_<P, N, E> self_; - typedef graph_vicinity_piter_<P, E> super_; - - public: - /// Construction. - /// \{ - template <typename Pref> - graph_neighborhood_piter_(const Neighborhood<N>& nbh, - const Point_Site<Pref>& p_ref); - /// \} - - protected: - /// The neighborhood. - const N& nbh_; - }; - - } // end of namespace mln::internal - - /*-------------------------------------. | graph_neighborhood_fwd_piter<P, N>. | `-------------------------------------*/ template <typename P, typename N> class graph_neighborhood_fwd_piter : - public internal::graph_neighborhood_piter_< P, N, + public internal::graph_vicinity_piter_< P, graph_neighborhood_fwd_piter<P, N> > { typedef graph_neighborhood_fwd_piter<P, N> self_; - typedef internal::graph_neighborhood_piter_<P, N, self_> super_; + typedef internal::graph_vicinity_piter_<P, self_> super_; public: /// Construction. @@ -116,6 +86,10 @@ /// Advance the position of the iterator by one step. void step_(); /// \} + + private: + /// The neighborhood. + const N& nbh_; }; @@ -125,11 +99,11 @@ template <typename P, typename N> class graph_neighborhood_bkd_piter : - public internal::graph_neighborhood_piter_< P, N, + public internal::graph_vicinity_piter_< P, graph_neighborhood_bkd_piter<P, N> > { typedef graph_neighborhood_bkd_piter<P, N> self_; - typedef internal::graph_neighborhood_piter_<P, N, self_> super_; + typedef internal::graph_vicinity_piter_<P, self_> super_; public: /// Construction. @@ -154,32 +128,16 @@ /// Advance the position of the iterator by one step. void step_(); /// \} + + private: + /// The neighborhood. + const N& nbh_; }; # ifndef MLN_INCLUDE_ONLY - /*-----------------------------------------------. - | internal::graph_neighborhood_piter_<P, N, E>. | - `-----------------------------------------------*/ - - namespace internal - { - - template <typename P, typename N, typename E> - template <typename Pref> - inline - graph_neighborhood_piter_<P, N, E>::graph_neighborhood_piter_(const Neighborhood<N>& nbh, - const Point_Site<Pref>& p_ref) - : super_(p_ref), - nbh_(exact(nbh)) - { - } - - } // end of namespace mln::internal - - /*-------------------------------------. | graph_neighborhood_fwd_piter<P, N>. | `-------------------------------------*/ @@ -189,7 +147,8 @@ inline graph_neighborhood_fwd_piter<P, N>::graph_neighborhood_fwd_piter(const Neighborhood<N>& nbh, const Point_Site<Pref>& p_ref) - : super_(nbh, p_ref) + : super_(p_ref), + nbh_(exact(nbh)) { } @@ -239,7 +198,8 @@ inline graph_neighborhood_bkd_piter<P, N>::graph_neighborhood_bkd_piter(const Neighborhood<N>& nbh, const Point_Site<Pref>& p_ref) - : super_(nbh, p_ref) + : super_(p_ref), + nbh_(exact(nbh)) { } Index: mln/core/graph_window_piter.hh --- mln/core/graph_window_piter.hh (revision 1896) +++ mln/core/graph_window_piter.hh (working copy) @@ -51,35 +51,6 @@ namespace mln { - /*-----------------------------------------. - | internal::graph_window_piter_<P, W, E>. | - `-----------------------------------------*/ - - namespace internal - { - - /// \brief Base for iterator on a graph window. - template <typename P, typename W, typename E> - class graph_window_piter_ : public graph_vicinity_piter_<P, E> - { - typedef graph_window_piter_<P, W, E> self_; - typedef graph_vicinity_piter_<P, E> super_; - - public: - /// Construction. - /// \{ - template <typename Pref> - graph_window_piter_(const Window<W>& win, const Point_Site<Pref>& p_ref); - /// \} - - protected: - /// The window. - const W& win_; - }; - - } // end of namespace mln::internal - - /*-------------------------------. | graph_window_fwd_piter<P, W>. | `-------------------------------*/ @@ -87,10 +58,10 @@ /// \brief Forward iterator on graph window. template <typename P, typename W> class graph_window_fwd_piter : - public internal::graph_window_piter_< P, W, graph_window_fwd_piter<P, W> > + public internal::graph_vicinity_piter_< P, graph_window_fwd_piter<P, W> > { typedef graph_window_fwd_piter<P, W> self_; - typedef internal::graph_window_piter_<P, W, self_> super_; + typedef internal::graph_vicinity_piter_<P, self_> super_; public: /// Construction. @@ -114,6 +85,10 @@ /// Advance the position of the iterator by one step. void step_(); /// \} + + private: + /// The window. + const W& win_; }; @@ -124,10 +99,10 @@ /// \brief Backward iterator on graph window. template <typename P, typename W> class graph_window_bkd_piter : - public internal::graph_window_piter_< P, W, graph_window_bkd_piter<P, W> > + public internal::graph_vicinity_piter_< P, graph_window_bkd_piter<P, W> > { typedef graph_window_bkd_piter<P, W> self_; - typedef internal::graph_window_piter_<P, W, self_> super_; + typedef internal::graph_vicinity_piter_<P, self_> super_; public: /// Construction. @@ -151,32 +126,16 @@ /// Advance the position of the iterator by one step. void step_(); /// \} + + private: + /// The window. + const W& win_; }; # ifndef MLN_INCLUDE_ONLY - /*-----------------------------------------. - | internal::graph_window_piter_<P, W, E>. | - `-----------------------------------------*/ - - namespace internal - { - - template <typename P, typename W, typename E> - template <typename Pref> - inline - graph_window_piter_<P, W, E>::graph_window_piter_(const Window<W>& win, - const Point_Site<Pref>& p_ref) - : super_(p_ref), - win_(exact(win)) - { - } - - } // end of namespace mln::internal - - /*-------------------------------. | graph_window_fwd_piter<P, W>. | `-------------------------------*/ @@ -186,7 +145,8 @@ inline graph_window_fwd_piter<P, W>::graph_window_fwd_piter(const Window<W>& win, const Point_Site<Pref>& p_ref) - : super_(win, p_ref) + : super_(p_ref), + win_(exact(win)) { } @@ -236,7 +196,8 @@ inline graph_window_bkd_piter<P, W>::graph_window_bkd_piter(const Window<W>& win, const Point_Site<Pref>& p_ref) - : super_(win, p_ref) + : super_(p_ref), + win_(exact(win)) { }

16 years

1896: Speed up iterations on line graph windows.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Speed up iterations on line graph windows. * mln/core/line_graph_window_piter.hh (mln::line_graph_window_fwd_piter::sites_t) (mln::line_graph_window_bkd_piter::sites_t): New typedefs. (mln::line_graph_window_fwd_piter::adjacent_or_equal_to_p_ref_) (mln::line_graph_window_bkd_piter::adjacent_or_equal_to_p_ref_) (mln::line_graph_window_fwd_piter::first_) (mln::line_graph_window_bkd_piter::first_) (mln::line_graph_window_fwd_piter::step_) (mln::line_graph_window_bkd_piter::step_) (mln::line_graph_window_fwd_piter::id_) (mln::line_graph_window_bkd_piter::id_): Remove. (mln::line_graph_window_fwd_piter::p_ref) (mln::line_graph_window_bkd_piter::p_ref) (mln::line_graph_window_fwd_piter::plg) (mln::line_graph_window_bkd_piter::plg) (mln::line_graph_window_fwd_piter::sites) (mln::line_graph_window_bkd_piter::sites): New accessors. (mln::line_graph_window_fwd_piter::saved_p_ref_) (mln::line_graph_window_bkd_piter::saved_p_ref_) (mln::line_graph_window_fwd_piter::sites_) (mln::line_graph_window_bkd_piter::sites_) (mln::line_graph_window_fwd_piter::i_) (mln::line_graph_window_bkd_piter::i_): New attributes. (mln::line_graph_window_fwd_piter<P, W>::is_valid) (mln::line_graph_window_bkd_piter<P, W>::is_valid) (mln::line_graph_window_fwd_piter<P, W>::invalidate) (mln::line_graph_window_bkd_piter<P, W>::invalidate) (mln::line_graph_window_fwd_piter<P, W>::start) (mln::line_graph_window_bkd_piter<P, W>::start) (mln::line_graph_window_fwd_piter<P, W>::next) (mln::line_graph_window_bkd_piter<P, W>::next): Change the algorithms used in these routines, so that they use a list of computed window sites (new member sites_) instead of iterating over the whole set of edges. (mln::line_graph_window_fwd_piter<P, W>::update_) (mln::line_graph_window_bkd_piter<P, W>::update_): Adjust. * mln/core/line_graph_elt_window.hh: Catch up with the new interface of piters on line graph windows. (mln::line_graph_elt_window::sites_t): New typedef. (mln::line_graph_elt_window::line_graph_elt_window): Remove useless ctor. (mln::line_graph_elt_window::start) (mln::line_graph_elt_window::next_): Remove methods. (mln::line_graph_elt_window::compute_sites_): New method. * mln/core/line_graph_neighborhood_piter.hh (line_graph_neighborhood_fwd_piter<P, N>::adjacent_or_equal_to_p_ref_) (line_graph_neighborhood_bkd_piter<P, N>::adjacent_or_equal_to_p_ref_): Remove spurious method declarations. line_graph_elt_window.hh | 60 +++------ line_graph_neighborhood_piter.hh | 4 line_graph_window_piter.hh | 256 ++++++++++++++++++--------------------- 3 files changed, 146 insertions(+), 174 deletions(-) Index: mln/core/line_graph_window_piter.hh --- mln/core/line_graph_window_piter.hh (revision 1895) +++ mln/core/line_graph_window_piter.hh (working copy) @@ -80,6 +80,9 @@ // FIXME: Dummy typedef. typedef void mesh; + // The type of the set of window sites (adjacent edge ids). + typedef std::set<util::edge_id> sites_t; + public: /// Construction. /// \{ @@ -99,8 +102,6 @@ /// 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_(); /// \} @@ -114,27 +115,30 @@ /// Convert the iterator into a line graph psite. operator psite() const; + /// Return the reference psite. + const psite& p_ref() const; + /// Return the mln::p_line_graph corresponding to this piter. + const p_line_graph& plg() const; + /// Return the set of sites (adjacent edge ids). + sites_t& sites(); + /// Read-only access to the \a i-th coordinate. coord operator[](unsigned i) const; /// \} - /// Internals, used by the window. - /// \{ - public: - /// Set the iterator to the first site of the graph. - void first_(); - /// Advance the position of the iterator by one step. - void step_(); - - /// An internal iterator on the set of edges of the underlying graph. - util::edge_id id_; - /// \} - private: /// The window. const W& win_; /// The ``central'' psite of the window. const psite& p_ref_; + + /// The last reference psite whose ajacent psites have been computed. + psite saved_p_ref_; + /// The set of edge ids adjacent to the reference psite. + sites_t sites_; + /// An iterator on the set of adjacent edges. + sites_t::const_iterator i_; + /// The psite corresponding to this iterator. psite psite_; /// The point corresponding to this iterator. @@ -176,6 +180,9 @@ // FIXME: Dummy typedef. typedef void mesh; + // The type of the set of window sites (adjacent edge ids). + typedef std::set<util::edge_id> sites_t; + public: /// Construction. /// \{ @@ -195,8 +202,6 @@ /// 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_(); /// \} @@ -210,27 +215,30 @@ /// Convert the iterator into a line graph psite. operator psite() const; + /// Return the reference psite. + const psite& p_ref() const; + /// Return the mln::p_line_graph corresponding to this piter. + const p_line_graph& plg() const; + /// Return the set of sites (adjacent edge ids). + sites_t& sites(); + /// Read-only access to the \a i-th coordinate. coord operator[](unsigned i) const; /// \} - /// Internals, used by the window. - /// \{ - public: - /// Set the iterator to the first site of the graph. - void first_(); - /// Advance the position of the iterator by one step. - void step_(); - - /// An internal iterator on the set of edges of the underlying graph. - util::edge_id id_; - /// \} - private: /// The window. const W& win_; /// The ``central'' psite of the window. const psite& p_ref_; + + /// The last reference psite whose ajacent psites have been computed. + psite saved_p_ref_; + /// The set of edge ids adjacent to the reference psite. + sites_t sites_; + /// An iterator on the set of adjacent edges. + sites_t::const_reverse_iterator i_; + /// The psite corresponding to this iterator. psite psite_; /// The point corresponding to this iterator. @@ -275,10 +283,13 @@ bool line_graph_window_fwd_piter<P, W>::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 p_ref_.is_valid() && id_ < p_ref_.plg().gr_->nedges(); + return + // The reference point must be valid... + p_ref_.is_valid() + // ...and must not have changed since the window has been computed... + && p_ref_ == saved_p_ref_ + // ...and the iterator i_ must point a valid value. + && i_ != sites_.end(); } template <typename P, typename W> @@ -286,7 +297,7 @@ void line_graph_window_fwd_piter<P, W>::invalidate() { - id_ = -1; + i_ = sites_.end(); } template <typename P, typename W> @@ -294,7 +305,15 @@ void line_graph_window_fwd_piter<P, W>::start() { - win_.start(*this); + mln_precondition(p_ref_.is_valid()); + // Update the sites, if needed. + if (!saved_p_ref_.is_valid() || p_ref_ != saved_p_ref_) + { + saved_p_ref_ = p_ref_; + win_.compute_sites_(*this); + } + i_ = sites_.begin(); + // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); } @@ -304,7 +323,10 @@ void line_graph_window_fwd_piter<P, W>::next_() { - win_.next_(*this); + // Ensure the p_ref_ has not changed. + mln_precondition(p_ref_ == saved_p_ref_); + ++i_; + // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); } @@ -312,84 +334,58 @@ template <typename P, typename W> inline void - line_graph_window_fwd_piter<P, W>::first_() + line_graph_window_fwd_piter<P, W>::update_() { - id_ = 0; + // Update psite_. + psite_ = line_graph_psite(plg(), *i_); } template <typename P, typename W> inline - void - line_graph_window_fwd_piter<P, W>::step_() + const P& + line_graph_window_fwd_piter<P, W>::to_point() const { - ++id_; + return p_; } - template <typename P, typename W> inline - bool - line_graph_window_fwd_piter<P, W>::adjacent_or_equal_to_p_ref_() const + const line_graph_psite& + line_graph_window_fwd_piter<P, W>::to_psite() 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 util::tracked_ptr<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; + return psite_; } template <typename P, typename W> inline - void - line_graph_window_fwd_piter<P, W>::update_() + line_graph_window_fwd_piter<P, W>::operator line_graph_psite () const { - // Update psite_. - psite_ = line_graph_psite(p_ref_.plg(), id_); + mln_precondition(is_valid()); + return psite_; } template <typename P, typename W> inline - const P& - line_graph_window_fwd_piter<P, W>::to_point() const + const line_graph_psite& + line_graph_window_fwd_piter<P, W>::p_ref() const { - return p_; + return p_ref_; } template <typename P, typename W> inline - const line_graph_psite& - line_graph_window_fwd_piter<P, W>::to_psite() const + const p_line_graph& + line_graph_window_fwd_piter<P, W>::plg() const { - return psite_; + return p_ref_.plg(); } template <typename P, typename W> inline - line_graph_window_fwd_piter<P, W>::operator line_graph_psite () const + std::set<util::edge_id>& + line_graph_window_fwd_piter<P, W>::sites() { - mln_precondition(is_valid()); - return psite_; + return sites_; } template <typename P, typename W> @@ -434,10 +430,13 @@ bool line_graph_window_bkd_piter<P, W>::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 p_ref_.is_valid() && id_ < p_ref_.plg().gr_->nedges(); + return + // The reference point must be valid... + p_ref_.is_valid() + // ...and must not have changed since the window has been computed... + && p_ref_ == saved_p_ref_ + // ...and the iterator i_ must point a valid value. + && i_ != sites_.rend(); } template <typename P, typename W> @@ -445,7 +444,7 @@ void line_graph_window_bkd_piter<P, W>::invalidate() { - id_ = -1; + i_ = sites_.rend(); } template <typename P, typename W> @@ -453,7 +452,15 @@ void line_graph_window_bkd_piter<P, W>::start() { - win_.start(*this); + mln_precondition(p_ref_.is_valid()); + // Update the sites, if needed. + if (!saved_p_ref_.is_valid() || p_ref_ != saved_p_ref_) + { + saved_p_ref_ = p_ref_; + win_.compute_sites_(*this); + } + i_ = sites_.rbegin(); + // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); } @@ -463,7 +470,10 @@ void line_graph_window_bkd_piter<P, W>::next_() { - win_.next_(*this); + // Ensure the p_ref_ has not changed. + mln_precondition(p_ref_ == saved_p_ref_); + ++i_; + // FIXME: We might move the is_valid condition within update_. if (is_valid()) update_(); } @@ -471,84 +481,58 @@ template <typename P, typename W> inline void - line_graph_window_bkd_piter<P, W>::first_() + line_graph_window_bkd_piter<P, W>::update_() { - id_ = p_ref_.plg().gr_->nedges() - 1; + // Update psite_. + psite_ = line_graph_psite(plg(), *i_); } template <typename P, typename W> inline - void - line_graph_window_bkd_piter<P, W>::step_() + const P& + line_graph_window_bkd_piter<P, W>::to_point() const { - --id_; + return p_; } - template <typename P, typename W> inline - bool - line_graph_window_bkd_piter<P, W>::adjacent_or_equal_to_p_ref_() const + const line_graph_psite& + line_graph_window_bkd_piter<P, W>::to_psite() 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 util::tracked_ptr<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; + return psite_; } template <typename P, typename W> inline - void - line_graph_window_bkd_piter<P, W>::update_() + line_graph_window_bkd_piter<P, W>::operator line_graph_psite () const { - // Update psite_. - psite_ = line_graph_psite(p_ref_.plg(), id_); + mln_precondition(is_valid()); + return psite_; } template <typename P, typename W> inline - const P& - line_graph_window_bkd_piter<P, W>::to_point() const + const line_graph_psite& + line_graph_window_bkd_piter<P, W>::p_ref() const { - return p_; + return p_ref_; } template <typename P, typename W> inline - const line_graph_psite& - line_graph_window_bkd_piter<P, W>::to_psite() const + const p_line_graph& + line_graph_window_bkd_piter<P, W>::plg() const { - return psite_; + return p_ref_.plg(); } template <typename P, typename W> inline - line_graph_window_bkd_piter<P, W>::operator line_graph_psite () const + std::set<util::edge_id>& + line_graph_window_bkd_piter<P, W>::sites() { - mln_precondition(is_valid()); - return psite_; + return sites_; } template <typename P, typename W> Index: mln/core/line_graph_elt_window.hh --- mln/core/line_graph_elt_window.hh (revision 1895) +++ mln/core/line_graph_elt_window.hh (working copy) @@ -65,6 +65,9 @@ typedef P point; /// The type of psite corresponding to the window. typedef line_graph_psite psite; + // The type of the set of window sites (edge ids adjacent to the + // reference psite). + typedef std::set<util::edge_id> sites_t; // FIXME: This is a dummy value. typedef void dpoint; @@ -81,17 +84,10 @@ typedef fwd_qiter qiter; /// \} - /// Construct an elementary line_graph window. - line_graph_elt_window(); - /// Services for iterators. /// \{ - /// Move \a piter to the beginning of the iteration on this window. - template <typename Piter> - void start(Point_Iterator<Piter>& piter) const; - /// Move \a piter to the next site on this window. template <typename Piter> - void next_(Point_Iterator<Piter>& piter) const; + void compute_sites_(Point_Iterator<Piter>& piter) const; /// \} /// Interface of the concept Window. @@ -125,37 +121,33 @@ # ifndef MLN_INCLUDE_ONLY template <typename P> - inline - line_graph_elt_window::line_graph_elt_window() - { - } - - template <typename P> - template <typename Piter> - inline - void - line_graph_elt_window::start(Point_Iterator<Piter>& piter_) const - { - Piter& piter = exact(piter_); - piter.first_(); - if (!piter.adjacent_or_equal_to_p_ref_()) - next_(piter); - } - - template <typename P> template <typename Piter> inline void - line_graph_elt_window::next_(Point_Iterator<Piter>& piter_) const + line_graph_elt_window::compute_sites_(Point_Iterator<Piter>& piter_) const { Piter& piter = exact(piter_); - /* FIXME: This is inefficient. The graph structure should be able - to produce the set of adjacent nodes fast. Boost Graphs - probably provides adequates structures to fetch these - neighbors in constant time. */ - do - piter.step_(); - while (piter.is_valid() && !piter.adjacent_or_equal_to_p_ref_()); + sites_t& sites = piter.sites(); + sites.clear(); + /* FIXME: Move this computation out of the window. In fact, + this should be a service of the graph, also proposed by the + p_line_graph. */ + // Add the reference piter itself. + sites.insert(piter.p_ref().id()); + // Ajacent edges connected through node 1. + // FIXME: Far too low-level. + util::node_id id1 = piter.p_ref().first_id(); + const util::node& node1 = piter.plg().gr_->node(id1); + for (std::vector<util::edge_id>::const_iterator e = + node1.edges.begin(); e != node1.edges.end(); ++e) + sites.insert(*e); + // Ajacent edges connected through node 2. + // FIXME: Likewise. + util::node_id id2 = piter.p_ref().second_id(); + const util::node& node2 = piter.plg().gr_->node(id2); + for (std::vector<util::edge_id>::const_iterator e = + node2.edges.begin(); e != node2.edges.end(); ++e) + sites.insert(*e); } template <typename P> Index: mln/core/line_graph_neighborhood_piter.hh --- mln/core/line_graph_neighborhood_piter.hh (revision 1895) +++ mln/core/line_graph_neighborhood_piter.hh (working copy) @@ -104,8 +104,6 @@ /// 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_(); /// \} @@ -208,8 +206,6 @@ /// 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_(); /// \}

16 years

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches April 2008