- Olena-patches

1716: Fix documentation.
by Nicolas Ballas 11 Feb '08

11 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Fix documentation. * mln/util/graph.hh, mln/util/internal/graph_base.hh: fix documentation graph_base.hh | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) Index: mln/util/graph.hh Index: mln/util/internal/graph_base.hh --- mln/util/internal/graph_base.hh (revision 1715) +++ mln/util/internal/graph_base.hh (working copy) @@ -50,12 +50,12 @@ Conversion to and from unsigned would still be useful, but it might be safer to turn them into explicit ones. */ - /// \bref The type used to identify nodes. + /// \brief The type used to identify nodes. /// /// Used internally as a key to manipulate nodes. typedef unsigned node_id; - /// \bref The type used to identify edges. + /// \brief The type used to identify edges. /// /// Used internally as a key to manipulate edges. typedef unsigned edge_id; @@ -82,7 +82,7 @@ template<> struct node<void> { - std::list<node_id> edges; + std::list<edge_id> edges; };

2 1

1715: Revamp iterators on windows on graphs.
by Roland Levillain 08 Feb '08

08 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Revamp iterators on windows on graphs. * mln/core/graph_window_piter.hh: Add missing inline `keywords' on methods. (graph_window_fwd_piter::psite_) (graph_window_fwd_piter::p_): New attributes. (graph_window_fwd_piter::graph_window_fwd_piter): Adjust ctor. (graph_window_fwd_piter::update_): New method. Use it... (graph_window_fwd_piter::start) (graph_window_fwd_piter::next_) ...here (graph_window_fwd_piter::to_psite) (graph_window_fwd_piter::operator point): New methods. (graph_window_fwd_piter::to_psite) (graph_window_fwd_piter::operator psite) (graph_window_fwd_piter::operator[]): Adjust. * mln/core/p_graph.hh (p_graph::has): Rewrite this method using a much simpler and faster approach. * mln/core/p_graph_piter.hh (p_graph_piter_::i_): Rename as... (p_graph_piter_::id_): ...this. (p_graph_piter_::p_graph_piter_): Adjust ctor. (p_graph_piter_::is_valid) (p_graph_piter_::invalidate) (p_graph_piter_::start) (p_graph_piter_::next_) (p_graph_piter_::update_): Adjust. * mln/core/graph_psite.hh: More doc. * mln/core/graph_elt_window.hh: Fix header guards. * mln/core/graph_image.hh: Aesthetic changes. * mln/util/internal/graph_base.hh: More FIXME. core/graph_elt_window.hh | 6 +-- core/graph_image.hh | 6 +-- core/graph_psite.hh | 4 +- core/graph_window_piter.hh | 74 ++++++++++++++++++++++++++++++++++++++------ core/p_graph.hh | 13 ++----- core/p_graph_piter.hh | 28 +++++++++------- util/internal/graph_base.hh | 6 +++ 7 files changed, 100 insertions(+), 37 deletions(-) Index: mln/core/graph_elt_window.hh --- mln/core/graph_elt_window.hh (revision 1714) +++ mln/core/graph_elt_window.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_WIN_GRAPH_ELT_WINDOW_HH -# define MLN_WIN_GRAPH_ELT_WINDOW_HH +#ifndef MLN_CORE_GRAPH_ELT_WINDOW_HH +# define MLN_CORE_GRAPH_ELT_WINDOW_HH /*! \file mln/core/graph_elt_window.hh * @@ -168,4 +168,4 @@ } // end of namespace mln -#endif // ! MLN_WIN_GRAPH_ELT_WINDOW_HH +#endif // ! MLN_CORE_GRAPH_ELT_WINDOW_HH Index: mln/core/graph_image.hh --- mln/core/graph_image.hh (revision 1714) +++ mln/core/graph_image.hh (working copy) @@ -28,10 +28,8 @@ #ifndef MLN_CORE_GRAPH_IMAGE_HH # define MLN_CORE_GRAPH_IMAGE_HH -/*! \file mln/core/graph_image.hh - * - * \brief Definition of a graph-based image. - */ +/// \file mln/core/graph_image.hh +/// \brief Definition of a graph-based image. # include <mln/trait/images.hh> Index: mln/core/graph_psite.hh --- mln/core/graph_psite.hh (revision 1714) +++ mln/core/graph_psite.hh (working copy) @@ -68,13 +68,15 @@ coord operator[](unsigned id) const; /// \} - /// Return the mln::p_graph this point site belongs to. + /// Return the p_graph this point site belongs to. const p_graph& pg() const; /// Return the node id of this point site. util::node_id id() const; private: + // The p_graph this point site belongs to. const p_graph& pg_; + // The id of the node this psite is pointing towards. util::node_id id_; }; Index: mln/core/graph_window_piter.hh --- mln/core/graph_window_piter.hh (revision 1714) +++ mln/core/graph_window_piter.hh (working copy) @@ -77,20 +77,29 @@ void next_(); bool adjacent_or_equal_to_p_ref_() const; + /// Update the internal data of the iterator. + void update_(); - // FIXME: In fact, this method should be named `to_psite', since - // it returns a mln::graph_psite object, not a P object. const point& to_point() const; + + const psite& to_psite() const; + + operator point() const; + operator psite () const; + /// Return the \a i th coordinate of the (iterated) point. coord operator[](unsigned i) const; private: - /// The ``central'' point of the window. + /// The ``central'' psite of the window. const psite& p_ref_; - /// An internal iterator on the set of nodes of the underlying graph. util::node_id id_; + // The psite corresponding to this iterator. + psite psite_; + // The point corresponding to this iterator. + point p_; }; // FIXME: Implement graph_window_bkd_piter. @@ -101,15 +110,20 @@ // FIXME: Currently, argument win is ignored. template <typename P> template <typename W, typename Pref> + inline graph_window_fwd_piter::graph_window_fwd_piter(const W& /* win */, const Point_Site<Pref>& p_ref) - : p_ref_(exact(p_ref).to_psite()) + : p_ref_(exact(p_ref).to_psite()), + // Initialize psite_ to a dummy value. + psite_(p_ref_.pg(), p_ref_.pg().npoints()), + p_() { // Invalidate id_. invalidate(); } template <typename P> + inline bool graph_window_fwd_piter::is_valid() const { @@ -120,6 +134,7 @@ } template <typename P> + inline void graph_window_fwd_piter::invalidate() { @@ -127,15 +142,22 @@ } template <typename P> + inline void graph_window_fwd_piter::start() { id_ = 0; if (!adjacent_or_equal_to_p_ref_()) next_(); + /* FIXME: This is redundant with the end of next_(), but we might + change the implementation of start_() when we'll fix it later, + and no longer use next_(). */ + if (is_valid()) + update_(); } template <typename P> + inline void graph_window_fwd_piter::next_() { @@ -144,13 +166,17 @@ probably provides adequates structures to fetch these neighbors in constant time. */ /* FIXME: Moreover, the behavior of next shall depend on the - window, which is not the case now! */ + window, which is not the case now! (Currently, next_() behaves + as win was always an elementary window.) */ do ++id_; while (is_valid() && !adjacent_or_equal_to_p_ref_()); + if (is_valid()) + update_(); } template <typename P> + inline bool graph_window_fwd_piter::adjacent_or_equal_to_p_ref_() const { @@ -180,16 +206,46 @@ } template <typename P> + inline + void + graph_window_fwd_piter::update_() + { + // Update psite_. + psite_ = graph_psite(p_ref_.pg(), id_); + // Update p_. + p_ = p_ref_.pg().gr_.node_data(id_); + } + + template <typename P> + inline const P& graph_window_fwd_piter::to_point() const { - return p_ref_.pg().gr_.node_data(id_); + return p_; + } + + template <typename P> + inline + const graph_psite& + graph_window_fwd_piter::to_psite() const + { + return psite_; } template <typename P> + inline + graph_window_fwd_piter::operator P() const + { + mln_precondition(is_valid()); + return p_; + } + + template <typename P> + inline graph_window_fwd_piter::operator graph_psite () const { - return graph_psite(p_ref_.pg(), id_); + mln_precondition(is_valid()); + return psite_; } template <typename P> @@ -198,7 +254,7 @@ graph_window_fwd_piter::operator[](unsigned i) const { assert(i < dim); - return to_point()[i]; + return p_[i]; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/p_graph.hh --- mln/core/p_graph.hh (revision 1714) +++ mln/core/p_graph.hh (working copy) @@ -127,14 +127,11 @@ bool p_graph::has(const psite& p) const { - // FIXME: util::graph (or util::internal::graph_base) should - // provide the iteration facility (iterators, find, etc.) - const typename graph::nodes_t& nodes = gr_.nodes(); - for (typename graph::nodes_t::const_iterator n = nodes.begin(); - n != nodes.end(); ++n) - if ((*n)->data == p) - return true; - return false; + return + // Check whether P is compatible with this psite set. + (&p.pg() == this) && + // Check that the node id of P belongs to the range of valid node ids. + (p.id() < gr_.nnodes()); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/p_graph_piter.hh --- mln/core/p_graph_piter.hh (revision 1714) +++ mln/core/p_graph_piter.hh (working copy) @@ -93,10 +93,14 @@ operator psite() const; protected: + // The p_graph this point site belongs to. const p_graph& pg_; - unsigned i_; - P p_; + // The id of the node this psite is pointing towards. + unsigned id_; + // The psite corresponding to this iterator. psite psite_; + // The point corresponding to this iterator. + point p_; }; @@ -107,11 +111,11 @@ inline p_graph_piter_::p_graph_piter_(const p_graph& pg) : pg_(pg), - p_(), // Initialize psite_ to a dummy value. - psite_(pg, pg_.npoints()) + psite_(pg, pg_.npoints()), + p_() { - // Invalidate i_. + // Invalidate id_. invalidate(); } @@ -128,7 +132,7 @@ bool p_graph_piter_::is_valid() const { - return i_ < pg_.npoints(); + return id_ < pg_.npoints(); } template<typename P> @@ -136,7 +140,7 @@ void p_graph_piter_::invalidate() { - i_ = pg_.npoints(); + id_ = pg_.npoints(); } template<typename P> @@ -144,7 +148,7 @@ void p_graph_piter_::start() { - i_ = 0; + id_ = 0; if (is_valid()) update_(); } @@ -154,7 +158,7 @@ void p_graph_piter_::next_() { - ++i_; + ++id_; if (is_valid()) update_(); } @@ -164,10 +168,10 @@ void p_graph_piter_::update_() { - // Update p_. - p_ = pg_.gr_.node_data(i_); // Update psite_. - psite_ = graph_psite(pg_, i_); + psite_ = graph_psite(pg_, id_); + // Update p_. + p_ = pg_.gr_.node_data(id_); } template<typename P> Index: mln/util/internal/graph_base.hh --- mln/util/internal/graph_base.hh (revision 1714) +++ mln/util/internal/graph_base.hh (working copy) @@ -44,6 +44,12 @@ namespace util { + /* FIXME: We should create actual types for node_id and edge_id, + (not just typedefs), at least to prevent the user from using a + node_id where an edge_id is expected (and vice versa). + Conversion to and from unsigned would still be useful, but it + might be safer to turn them into explicit ones. */ + /// \bref The type used to identify nodes. /// /// Used internally as a key to manipulate nodes.

1 0

1714: Update to new mln::util::graph and improve graph-based entities.
by Roland Levillain 07 Feb '08

07 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Catch up with the new interface of mln::util::graph and improve graph-based entities. * mln/core/p_graph.hh: Store points associated to nodes in the graph itself, not in an separate array. (p_graph::graph): Set this typedef from `util::graph<void>' to `util::graph'. (p_graph::loc_): Remove. (p_graph::graph): Adjust ctor. (p_graph::npoints, p_graph::nlines, p_graph::has): Use the new interface of mln::util::graph. * mln/core/graph_psite.hh (graph_psite::i_): Rename as (graph_psite::id_): ...this. Make it a private argument. (graph_psite::pg_): Likewise. (graph_psite::id, graph_psite::pg): New accessors. Adjust users. * mln/core/graph_image.hh (graph_image<P, V>::access_location_link_node1) (graph_image<P, V>::access_location_link_node2): Rename as... (graph_image<P, V>::node1) (graph_image<P, V>::node2): ...these. Use the new interface of mln::util::graph. (graph_image<P, V>::operator()) Use the new interface of mln::graph_psite. * mln/core/graph_window_piter.hh (graph_window_fwd_piter::i_): Rename as... (graph_window_fwd_piter::id_): ...this. Set its to type from `unsigned' to `util::node_id'. Adjust users. (graph_window_fwd_piter::is_valid) (graph_window_fwd_piter::invalidate) (graph_window_fwd_piter::adjacent_or_equal_to_p_ref_) (graph_window_fwd_piter::to_point) (graph_window_fwd_piter::operator graph_psite): Use the new interface of mln::util::graph. * mln/core/p_graph_piter.hh (p_graph_piter_::psite_set_): Rename as... (p_graph_piter_::pg_): ...this. Use the new interface of mln::p_graph. (p_graph_piter_::is_valid) (p_graph_piter_::invalidate) (p_graph_piter_::update_): Likewise. * mln/draw/graph.hh (draw::graph): Update to the new interfaces of mln::util::graph and mln::p_graph. * mln/draw/all.hh: Adjust and complete the list of included headers. * tests/core/graph_elt_window.cc, * tests/core/graph_image.cc, * tests/draw/graph.cc: Update tests. mln/core/graph_image.hh | 39 +++++++++++++---------- mln/core/graph_psite.hh | 68 ++++++++++++++++++++++++----------------- mln/core/graph_window_piter.hh | 51 +++++++++++++----------------- mln/core/p_graph.hh | 37 +++++++++++++--------- mln/core/p_graph_piter.hh | 18 +++++----- mln/draw/all.hh | 4 +- mln/draw/graph.hh | 33 ++++++++++--------- tests/core/graph_elt_window.cc | 6 +-- tests/core/graph_image.cc | 6 +-- tests/draw/graph.cc | 8 +--- 10 files changed, 145 insertions(+), 125 deletions(-) Index: mln/core/graph_psite.hh --- mln/core/graph_psite.hh (revision 1713) +++ mln/core/graph_psite.hh (working copy) @@ -28,12 +28,8 @@ #ifndef MLN_CORE_GRAPH_PSITE_HH # define MLN_CORE_GRAPH_PSITE_HH -/*! \file mln/core/graph_psite.hh - * - * \brief Definition of a graph-based point site. - * - * \todo Clean-up! - */ +/// \file mln/core/graph_psite.hh +/// \brief Definition of a graph-based point site. # include <mln/core/p_graph.hh> @@ -45,11 +41,7 @@ template<typename P> class p_graph; - /*! - * \brief Point site associate to graph_image. - * - * \todo Fix access to member. - */ + /// \brief Point site associated to a mln::graph_image. template<typename P> class graph_psite : public Point_Site< graph_psite > { @@ -64,27 +56,37 @@ /// Construction and assignment. /// \{ - graph_psite(const p_graph& pg_, unsigned i); + graph_psite(const p_graph& pg_, unsigned id); graph_psite(const self_& rhs); self_& operator= (const self_& rhs); /// \} + /// Access to point/psite. + /// \{ operator P() const; const point& to_point() const; - coord operator[](unsigned i) const; + coord operator[](unsigned id) const; + /// \} - // FIXME: These shouldn't be public. + /// Return the mln::p_graph this point site belongs to. + const p_graph& pg() const; + /// Return the node id of this point site. + util::node_id id() const; + + private: const p_graph& pg_; - unsigned i_; + util::node_id id_; }; + + # ifndef MLN_INCLUDE_ONLY template<typename P> inline - graph_psite::graph_psite(const p_graph& g, unsigned i) + graph_psite::graph_psite(const p_graph& g, util::node_id id) : pg_(g), - i_(i) + id_(id) { } @@ -92,7 +94,7 @@ inline graph_psite::graph_psite(const graph_psite& rhs) : pg_(rhs.pg_), - i_(rhs.i_) + id_(rhs.id_) { } @@ -105,7 +107,7 @@ return *this; // FIXME: Could we get rid of this cast? const_cast< p_graph& >(pg_) = rhs.pg_; - i_ = rhs.i_; + id_ = rhs.id_; return *this; } @@ -113,9 +115,7 @@ inline graph_psite::operator P() const { - // FIXME: This is quite unsafe: we should check that i_ is a valid - // index before dereferencing loc_ to ensure clear error messages. - return pg_.loc_[i_]; + return pg_.gr_.node_data(id_); } template<typename P> @@ -123,17 +123,31 @@ const P& graph_psite::to_point() const { - // FIXME: This is quite unsafe: we should check that i_ is a valid - // index before dereferencing loc_ to ensure clear error messages. - return pg_.loc_[i_]; + return pg_.gr_.node_data(id_); } template<typename P> inline mln_coord(P) - graph_psite::operator[](unsigned i) const + graph_psite::operator[](util::node_id id) const + { + return to_point()[id]; + } + + template<typename P> + inline + const p_graph& + graph_psite::pg() const + { + return pg_; + } + + template<typename P> + inline + util::node_id + graph_psite::id() const { - return to_point()[i]; + return id_; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/p_graph.hh --- mln/core/p_graph.hh (revision 1713) +++ mln/core/p_graph.hh (working copy) @@ -44,12 +44,13 @@ template<typename P> class p_graph_piter_; template<typename P> - struct p_graph : public internal::point_set_base_< graph_psite, p_graph > + struct p_graph + : public internal::point_set_base_< graph_psite, p_graph > { - typedef util::graph<void> graph; + typedef util::graph graph; - /// Construct a graph psite set from a graph and an array of locations. - p_graph (graph& gr, std::vector& loc); + /// Construct a graph psite set from a graph of points. + p_graph (graph& gr); /// Point_Site associated type. typedef graph_psite psite; @@ -71,8 +72,8 @@ bool has(const psite& p) const; + // FIXME: Should be private. graph gr_; - std::vector loc_; // FIXME: (Roland) Is it really useful/needed? /* 2007-12-19: It seems so, since graph_image must implement a method named bbox(). Now the question is: should each image type have a @@ -84,22 +85,25 @@ template<typename P> inline - p_graph::p_graph (util::graph<void>& gr, std::vector& loc) - : gr_ (gr), - loc_ (loc) + p_graph::p_graph (util::graph& gr) + : gr_ (gr) { + // FIXME: Warning: if the underlying graph is updated later, this + // won't be taken into account by this p_graph! accu::bbox a; - for (unsigned i = 0; i < loc.size(); ++i) - a.take(loc[i]); + for (unsigned i = 0; i < npoints(); ++i) + a.take(gr_.node_data(i)); bb_ = a.to_result(); } + // FIXME: Rename to npsites? In fact, this depends on the + // interface expected from models of Point_Sets. template<typename P> inline std::size_t p_graph::npoints() const { - return this->gr_.nb_node_; + return this->gr_.nnodes(); } template<typename P> @@ -107,7 +111,7 @@ std::size_t p_graph::nlines() const { - return this->gr_.nb_link_; + return this->gr_.nedges(); } template<typename P> @@ -123,13 +127,16 @@ bool p_graph::has(const psite& p) const { - for (unsigned i = 0; i < loc_.size(); ++i) - if (loc_[i] == p) + // FIXME: util::graph (or util::internal::graph_base) should + // provide the iteration facility (iterators, find, etc.) + const typename graph::nodes_t& nodes = gr_.nodes(); + for (typename graph::nodes_t::const_iterator n = nodes.begin(); + n != nodes.end(); ++n) + if ((*n)->data == p) return true; return false; } - # endif // ! MLN_INCLUDE_ONLY } // end of mln Index: mln/core/graph_window_piter.hh --- mln/core/graph_window_piter.hh (revision 1713) +++ mln/core/graph_window_piter.hh (working copy) @@ -82,6 +82,7 @@ // it returns a mln::graph_psite object, not a P object. const point& to_point() const; operator psite () const; + /// Return the \a i th coordinate of the (iterated) point. coord operator[](unsigned i) const; private: @@ -89,7 +90,7 @@ const psite& p_ref_; /// An internal iterator on the set of nodes of the underlying graph. - unsigned i_; + util::node_id id_; }; // FIXME: Implement graph_window_bkd_piter. @@ -104,7 +105,7 @@ const Point_Site<Pref>& p_ref) : p_ref_(exact(p_ref).to_psite()) { - // Invalidate i_. + // Invalidate id_. invalidate(); } @@ -115,21 +116,21 @@ // FIXME: We depend too much on the implementation of util::graph // here. The util::graph should provide the service to abstract // these manipulations. - return i_ >= 0 && i_ < p_ref_.pg_.gr_.nb_node_; + return id_ < p_ref_.pg().gr_.nnodes(); } template <typename P> void graph_window_fwd_piter::invalidate() { - i_ = p_ref_.pg_.gr_.nb_node_; + id_ = p_ref_.pg().gr_.nnodes(); } template <typename P> void graph_window_fwd_piter::start() { - i_ = 0; + id_ = 0; if (!adjacent_or_equal_to_p_ref_()) next_(); } @@ -138,12 +139,14 @@ void graph_window_fwd_piter::next_() { - // 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. + /* 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. */ + /* FIXME: Moreover, the behavior of next shall depend on the + window, which is not the case now! */ do - ++i_; + ++id_; while (is_valid() && !adjacent_or_equal_to_p_ref_()); } @@ -154,34 +157,24 @@ // FIXME: Likewise, this is inefficient. // Check wether the iterator points to P_REF_. - if (i_ == p_ref_.i_) + if (id_ == p_ref_.id()) return true; - typedef std::list<unsigned> adjacency_type; - // Check whether the iterator is among the neighbors of P_REF_. { // Paranoid assertion. - assert (p_ref_.i_ >= 0 && - p_ref_.i_ < p_ref_.pg_.gr_.nodes_.size ()); + assert (p_ref_.id() < p_ref_.pg().gr_.nnodes()); + // FIXME: This is too low-level. Yet another service the graph + // should provide. + typedef std::vector<util::node_id> adjacency_type; const adjacency_type& p_ref_neighbs = - p_ref_.pg_.gr_.nodes_[p_ref_.i_]->links; + p_ref_.pg().gr_.nodes()[p_ref_.id()]->edges; adjacency_type::const_iterator j = - std::find (p_ref_neighbs.begin(), p_ref_neighbs.end(), i_); + std::find (p_ref_neighbs.begin(), p_ref_neighbs.end(), id_); if (j != p_ref_neighbs.end()) return true; } - // Check whether P_REF_ is among the neighbors of the iterator. - { - assert (is_valid ()); - const adjacency_type& i_neighbs = p_ref_.pg_.gr_.nodes_[i_]->links; - adjacency_type::const_iterator k = - std::find (i_neighbs.begin(), i_neighbs.end(), p_ref_.i_); - if (k != i_neighbs.end()) - return true; - } - // Otherwise, the iterator is not adjacent to P_REF_. return false; } @@ -190,13 +183,13 @@ const P& graph_window_fwd_piter::to_point() const { - return p_ref_.pg_.loc_[i_]; + return p_ref_.pg().gr_.node_data(id_); } template <typename P> graph_window_fwd_piter::operator graph_psite () const { - return graph_psite(p_ref_.pg_, i_); + return graph_psite(p_ref_.pg(), id_); } template <typename P> Index: mln/core/graph_image.hh --- mln/core/graph_image.hh (revision 1713) +++ mln/core/graph_image.hh (working copy) @@ -134,11 +134,12 @@ const p_graph& domain() const; - /// Return the first node of the link at i from loc - const P& access_location_link_node1 (const unsigned& i) const; - - /// Return the second node of the link at i from loc - const P& access_location_link_node2 (const unsigned& i) const; + /// Return the point of the first node adjacent to the edge with + /// id \a e. + const P& node1(const util::edge_id& e) const; + /// Return the point of the second node adjacent to the edge with + /// id \a e. + const P& node2(const util::edge_id& e) const; }; // Fwd decl. @@ -225,9 +226,9 @@ const V& graph_image<P, V>::operator()(const graph_psite& p) const { - mln_precondition(&p.pg_ == &this->data_->pg_); - mln_precondition(p.i_ < this->data_->val_.size()); - return this->data_->val_[p.i_]; + mln_precondition(&p.pg() == &this->data_->pg_); + mln_precondition(p.id() < this->data_->val_.size()); + return this->data_->val_[p.id()]; } template <typename P, typename V> @@ -235,9 +236,9 @@ V& graph_image<P, V>::operator()(const graph_psite& p) { - mln_precondition(&p.pg_ == &this->data_->pg_); - mln_precondition(p.i_ < this->data_->val_.size()); - return this->data_->val_[p.i_]; + mln_precondition(&p.pg() == &this->data_->pg_); + mln_precondition(p.id() < this->data_->val_.size()); + return this->data_->val_[p.id()]; } template <typename P, typename V> @@ -268,19 +269,23 @@ template <typename P, typename V> inline const P& - graph_image<P, V>::access_location_link_node1 (const unsigned& i) const + graph_image<P, V>::node1(const util::edge_id& e) const { - // FIXME: This is ugly! Too much implementation details are shown here. - return this->domain().loc_[this->domain().gr_.links_[i]->pair_node_.first]; + // FIXME: Improve the interface of graph to avoid these low-level + // manipulations. + util::node_id n1 = this->domain().gr_.edge(e).n1(); + return this->domain().gr_.node_data(n1); } template <typename P, typename V> inline const P& - graph_image<P, V>::access_location_link_node2 (const unsigned& i) const + graph_image<P, V>::node2(const util::edge_id& e) const { - // FIXME: This is ugly! Too much implementation details are shown here. - return this->domain().loc_[this->domain().gr_.links_[i]->pair_node_.second]; + // FIXME: Improve the interface of graph to avoid these low-level + // manipulations. + util::node_id n2 = this->domain().gr_.edge(e).n2(); + return this->domain().gr_.node_data(n2); } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/p_graph_piter.hh --- mln/core/p_graph_piter.hh (revision 1713) +++ mln/core/p_graph_piter.hh (working copy) @@ -60,7 +60,7 @@ typedef graph_psite psite; typedef P point; - p_graph_piter_(const p_graph& psite_set); + p_graph_piter_(const p_graph& pg); /// Read-only access to the \p i-th coordinate. mln_coord(P) operator[](unsigned i) const; @@ -93,7 +93,7 @@ operator psite() const; protected: - const p_graph& psite_set_; + const p_graph& pg_; unsigned i_; P p_; psite psite_; @@ -105,11 +105,11 @@ template<typename P> inline - p_graph_piter_::p_graph_piter_(const p_graph& psite_set) - : psite_set_(psite_set), + p_graph_piter_::p_graph_piter_(const p_graph& pg) + : pg_(pg), p_(), // Initialize psite_ to a dummy value. - psite_(psite_set, psite_set_.loc_.size()) + psite_(pg, pg_.npoints()) { // Invalidate i_. invalidate(); @@ -128,7 +128,7 @@ bool p_graph_piter_::is_valid() const { - return i_ != psite_set_.loc_.size(); + return i_ < pg_.npoints(); } template<typename P> @@ -136,7 +136,7 @@ void p_graph_piter_::invalidate() { - i_ = psite_set_.loc_.size(); + i_ = pg_.npoints(); } template<typename P> @@ -165,9 +165,9 @@ p_graph_piter_::update_() { // Update p_. - p_ = psite_set_.loc_[i_]; + p_ = pg_.gr_.node_data(i_); // Update psite_. - psite_ = graph_psite(psite_set_, i_); + psite_ = graph_psite(pg_, i_); } template<typename P> Index: mln/draw/graph.hh --- mln/draw/graph.hh (revision 1713) +++ mln/draw/graph.hh (working copy) @@ -92,16 +92,19 @@ graph(Image& ima, const p_graph& pg, mln_value(I) node_v, mln_value(I) link_v) { + // Draw the background. level::fill(ima, 0); - - for (unsigned i = 0; i < pg.nlines(); ++i) + // Draw the lines (edges). + for (size_t l = 0; l < pg.nlines(); ++l) line (exact(ima), - pg.loc_[pg.gr_.links_[i]->pair_node_.first], - pg.loc_[pg.gr_.links_[i]->pair_node_.second], + // FIXME: Too low-level. See similar remarks + // in mln/core/graph_image.hh + pg.gr_.node_data(pg.gr_.edge(l).n1()), + pg.gr_.node_data(pg.gr_.edge(l).n2()), link_v); - - for (unsigned i = 0; i < pg.npoints(); ++i) - exact(ima)(pg.loc_[i]) = node_v; + // Draw the points (nodes). + for (size_t p = 0; p < pg.npoints(); ++p) + exact(ima)(pg.gr_.node_data(p)) = node_v; } template <typename I, typename P, typename V> @@ -110,16 +113,14 @@ graph(Image& ima, const graph_image<P, V>& gi, mln_value(I) link_v) { + // Draw the background. level::fill(ima, 0); - - for (unsigned i = 0; i < gi.domain().nlines(); ++i) - line (exact(ima), - gi.access_location_link_node1 (i), - gi.access_location_link_node2 (i), - link_v); - - for (unsigned i = 0; i < gi.domain().npoints(); ++i) - exact(ima)(gi.domain().loc_[i]) = gi.data_values ()[i]; + // Draw the lines (edges). + for (size_t l = 0; l < gi.domain().nlines(); ++l) + line (exact(ima), gi.node1(l), gi.node2(l), link_v); + // Draw the points (nodes). + for (size_t p = 0; p < gi.domain().npoints(); ++p) + exact(ima)(gi.domain().gr_.node_data(p)) = gi.data_values()[p]; } # endif // ! MLN_INCLUDE_ONLY Index: mln/draw/all.hh --- mln/draw/all.hh (revision 1713) +++ mln/draw/all.hh (working copy) @@ -42,7 +42,9 @@ } +# include <mln/draw/box.hh> +# include <mln/draw/graph.hh> +# include <mln/draw/label.hh> # include <mln/draw/line.hh> -# include <mln/draw/mesh.hh> #endif // ! MLN_DRAW_ALL_HH Index: tests/core/graph_elt_window.cc --- tests/core/graph_elt_window.cc (revision 1713) +++ tests/core/graph_elt_window.cc (working copy) @@ -58,10 +58,10 @@ points.push_back(make::point2d(4,4)); // Point associated to node 4. // Edges. - mln::util::graph<void> g; + mln::util::graph<p_t> g; // Populate the graph with nodes. for (unsigned i = 0; i < points.size(); ++i) - g.add_node (); + g.add_node (points[i]); // Populate the graph with edges. g.add_edge(0, 1); g.add_edge(1, 2); @@ -74,7 +74,7 @@ `------------------*/ // Graph psite set. - p_graph<p_t> pg(g, points); + p_graph<p_t> pg(g); // Graph point site. graph_psite<p_t> psite(pg, 0); // ``Sliding'' window (in fact, neighborhood) of a psite of PG. Index: tests/core/graph_image.cc --- tests/core/graph_image.cc (revision 1713) +++ tests/core/graph_image.cc (working copy) @@ -59,10 +59,10 @@ points.push_back(make::point2d(4,4)); // Point associated to node 4. // Edges. - util::graph<void> g; + util::graph<point2d> g; // Populate the graph with nodes. for (unsigned i = 0; i < points.size(); ++i) - g.add_node (); + g.add_node (points[i]); // Populate the graph with edges. g.add_edge(0, 1); g.add_edge(1, 2); @@ -74,7 +74,7 @@ | Graph. | `-------*/ - p_graph<point2d> pg(g, points); + p_graph<point2d> pg(g); /*-------------. | Graph image. | Index: tests/draw/graph.cc --- tests/draw/graph.cc (revision 1713) +++ tests/draw/graph.cc (working copy) @@ -61,17 +61,15 @@ unsigned nrows, unsigned ncols, const mln::image2d<int>& ref) { // Graph. - util::graph<void> g; + util::graph<mln::point2d> g; // Populate the graph with nodes. for (unsigned i = 0; i < points.size(); ++i) - g.add_node (); + g.add_node (points[i]); // Populate the graph with edges. for (edges_type::const_iterator i = edges.begin(); i != edges.end(); ++i) g.add_edge (i->first, i->second); - // Check its consistency. - g.consistency (); - mln::p_graph<point2d> pg(g, points); + mln::p_graph<point2d> pg(g); image2d<int> ima(nrows, ncols); draw::graph (ima, pg, 2, 1);

1 0

1713: Ovherhaul undirected graphs.
by Roland Levillain 07 Feb '08

07 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Ovherhaul undirected graphs. * mln/util/graph.hh (util::node, util::edge, util::graph): Move... * mln/util/internal/graph_base.hh: ...here (new file). (node_id, edge_id): New. (util::graph): Rename as... (util::internal::graph_base): ...this. Factor the common implementations of undirected graphs. (util::internal::consistency): Remove. (util::internal::nb_node_, util::internal::nb_link_): Remove. * mln/util/graph.hh: Include mln/util/internal/graph_base.hh. (util::graph<N, E>): New class, inheriting from util::internal::graph_base. (util::graph<N, void>, util::graph<void, void>): New specializations. * tests/util/graph.cc: Adjust. mln/util/graph.hh | 412 ++++++++++++++++++++-------------------- mln/util/internal/graph_base.hh | 399 ++++++++++++++++++++++++++++++++++++++ tests/util/graph.cc | 11 - 3 files changed, 610 insertions(+), 212 deletions(-) Index: mln/util/internal/graph_base.hh --- mln/util/internal/graph_base.hh (revision 0) +++ mln/util/internal/graph_base.hh (revision 0) @@ -0,0 +1,399 @@ +// 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. +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_UTIL_INTERNAL_GRAPH_BASE_HH +# define MLN_UTIL_INTERNAL_GRAPH_BASE_HH + +/// \file mln/util/internal/graph.hh +/// \brief Factored implementation of undirected graphs. + +# include <mln/core/concept/object.hh> +# include <cstddef> +# include <ostream> +# include <vector> +# include <list> +# include <algorithm> +# include <mln/util/ordpair.hh> + +namespace mln +{ + + namespace util + { + /// \bref The type used to identify nodes. + /// + /// Used internally as a key to manipulate nodes. + typedef unsigned node_id; + + /// \bref The type used to identify edges. + /// + /// Used internally as a key to manipulate edges. + typedef unsigned edge_id; + + + /*-------. + | Node. | + `-------*/ + + /// \brief Node of a graph, holding a value of type \p T. + template<typename T> + struct node + { + node(T data) + : data(data) + {} + + T data; + std::vector<edge_id> edges; + }; + + /// \brief Specialization of mln::util::node for nodes with no + /// associated value. + template<> + struct node<void> + { + std::list<node_id> edges; + }; + + + /*-------. + | Edge. | + `-------*/ + + /// \brief Edge of a graph, holding a value of type \p T. + template<typename T> + struct edge + { + edge(node_id n1, node_id n2) + : pair_node_ (n1, n2) + {} + + /// Return the lowest node id adjacent to this edge. + node_id n1 () const { return pair_node_.first; } + /// Return the highest node id adjacent to this edge. + node_id n2 () const { return pair_node_.second; } + + T data; + ordpair_<node_id> pair_node_; + }; + + /// \brief Specialization of mln::util::node for edges with no + /// associated value. + template<> + struct edge <void> + { + edge(node_id n1, node_id n2) + : pair_node_ (n1, n2) + {} + + /// Return the lowest node id adjacent to this edge. + node_id n1 () const { return pair_node_.first; } + /// Return the highest node id adjacent to this edge. + node_id n2 () const { return pair_node_.second; } + + ordpair_<node_id> pair_node_; + }; + + // FIXME: Document this. In particular, we should state that edges are + // only compared w.r.t. their adjacent nodes, not the data they + // possibly hold! + template <typename E> + bool + operator==(const edge<E>& lhs, const edge<E>& rhs); + + template <typename E> + bool + operator< (const edge<E>& lhs, const edge<E>& rhs); + + + /*--------. + | Graph. | + `--------*/ + + namespace internal + { + /// \brief Base class for undirected graphs. + template<typename N, typename E> + class graph_base + { + public: + /* FIXME: Do we really want handle nodes and edges through + pointers? In my (Roland) opinion, this is just a drawback, + here. */ + /// The type of the set of nodes. + typedef std::vector< node<N>* > nodes_t; + /// The type of the set of edges. + typedef std::vector< edge<E>* > edges_t; + + /// Constructor. + graph_base(); + /// Destructor. + ~graph_base(); + + /// Return the node whose id is \a n. + /// \{ + util::node<N>& node(node_id n); + const util::node<N>& node(edge_id n) const; + /// \} + + /// Return the edge whose id is \a e. + /// \{ + util::edge<E>& edge(edge_id e); + const util::edge<E>& edge(edge_id e) const; + /// \} + + /// Return the whole nodes of the graph. + /// \{ + nodes_t& nodes (); + const nodes_t& nodes () const; + /// \} + + /// Return the whole edges of the graph. + /// \{ + edges_t& edges (); + const edges_t& edges () const; + /// \} + + /// \brief Return the number of nodes in the graph. + size_t nnodes() const; + /// \brief Return the number of edges in the graph. + size_t nedges() const; + + // FIXME: We might want to externalize this in routine of + // namespace mln::debug. + /** \brief Print on \p ostr the graph. + + \param[in] ostr The output stream. */ + void print_debug (std::ostream& ostr) const; + + protected: + /// Shortcuts factoring the insertion of nodes and edges. + /// \{ + void add_node_ (util::node<N>* node); + void add_edge_ (util::edge<E>* edge); + /// \} + + protected: + /// The nodes. + nodes_t nodes_; + /// The edges. + edges_t edges_; + }; + + } // end of namespace mln::util::internal + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename E> + bool + operator==(const edge<E>& lhs, const edge<E>& rhs) + { + return lhs.pair_node_ == rhs.pair_node_; + } + + template <typename E> + bool + operator< (const edge<E>& lhs, const edge<E>& rhs) + { + return lhs.pair_node_ < rhs.pair_node_; + } + + namespace internal + { + + /*----------------. + | Ctor and dtor. | + `----------------*/ + + template<typename N, typename E> + inline + graph_base<N, E>::graph_base() + : nodes_(), edges_() + { + } + + template<typename N, typename E> + inline + graph_base<N, E>::~graph_base() + { + // FIXME: Delete data dynamically allocated in nodes_ and + // edges_. + } + + /*------------. + | Accessors. | + `------------*/ + + template<typename N, typename E> + inline + util::node<N>& + graph_base<N, E>::node(node_id n) + { + mln_assertion(n < this->nnodes()); + return *nodes_[n]; + } + + template<typename N, typename E> + inline + const util::node<N>& + graph_base<N, E>::node(node_id n) const + { + mln_assertion(n < this->nnodes()); + return *nodes_[n]; + } + + template<typename N, typename E> + inline + util::edge<E>& + graph_base<N, E>::edge(edge_id e) + { + mln_assertion(e < this->nedges()); + return *edges_[e]; + } + + template<typename N, typename E> + inline + const util::edge<E>& + graph_base<N, E>::edge(edge_id e) const + { + mln_assertion(e < this->nedges()); + return *edges_[e]; + } + + template<typename N, typename E> + inline + typename graph_base<N, E>::nodes_t& + graph_base<N, E>::nodes() + { + return nodes_; + } + + template<typename N, typename E> + inline + const typename graph_base<N, E>::nodes_t& + graph_base<N, E>::nodes() const + { + return nodes_; + } + + template<typename N, typename E> + inline + typename graph_base<N, E>::edges_t& + graph_base<N, E>::edges() + { + return edges_; + } + + template<typename N, typename E> + inline + const typename graph_base<N, E>::edges_t& + graph_base<N, E>::edges() const + { + return edges_; + } + + template<typename N, typename E> + inline + size_t + graph_base<N, E>::nnodes() const + { + return nodes_.size(); + } + + template<typename N, typename E> + inline + size_t + graph_base<N, E>::nedges() const + { + return edges_.size(); + } + + /*---------------. + | Manipulators. | + `---------------*/ + + template<typename N, typename E> + inline + void + graph_base<N, E>::add_node_(util::node<N>* node) + { + nodes_.push_back (node); + } + + template<typename N, typename E> + inline + void + graph_base<N, E>::add_edge_(util::edge<E>* edge) + { + // Does this edge already exist in the graph? + if (std::find(edges_.begin(), edges_.end(), edge) != edges_.end ()) + { + delete edge; + edge = 0; + } + else + { + edges_.push_back (edge); + nodes_[edge->n1()]->edges.push_back(edge->n2()); + nodes_[edge->n2()]->edges.push_back(edge->n1()); + } + } + + /*--------. + | Debug. | + `--------*/ + + template<typename N, typename E> + inline + void + graph_base<N, E>::print_debug (std::ostream& ostr) const + { + ostr << "graph: " << std::endl; + int i = 0; + for (typename nodes_t::const_iterator n = nodes_.begin (); + n != nodes_.end (); ++n, ++i) + { + ostr << "node: " <edges.begin(); + e != (*n)->edges.end(); ++e) + ostr << *e << " "; + ostr << std::endl; + } + ostr << std::endl; + } + + } // end of namespace mln::util::internal + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::util + +} // end of namespace mln + +#endif // ! MLN_UTIL_INTERNAL_GRAPH_BASE_HH Index: mln/util/graph.hh --- mln/util/graph.hh (revision 1712) +++ mln/util/graph.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// 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 @@ -28,274 +28,278 @@ #ifndef MLN_UTIL_GRAPH_HH # define MLN_UTIL_GRAPH_HH -# include <mln/core/concept/object.hh> -# include <cstddef> -# include <ostream> -# include <vector> -# include <list> -# include <algorithm> -# include <mln/util/ordpair.hh> - -/*! \file mln/util/graph.hh - * - * \brief Definition of a graph. - */ - -// FIXME: Rename `s_node' to `node'. -// FIXME: Rename `s_edge' to `edge'. -// FIXME: Rename `links' to `edges'. +/// \file mln/util/graph.hh +/// \brief Definitions of undirected graphs. + +# include <mln/util/internal/graph_base.hh> + + +// FIXME: More doc! + namespace mln { + namespace util { + /*-----------. + | Fwd decl. | + `-----------*/ + + /// \brief Undirected graph. + template<typename N = void, typename E = void> + class graph; + + /*--------------------. + | graph<void, void>. | + `--------------------*/ - /*! \brief Structure of generic node. - * - */ - template<typename T> - struct s_node - { - T data; - // FIXME: Rename to `out_edges'. - std::vector<unsigned> links; - }; - - - /*! \brief Structure of node with void parameter. - * - */ + /// Specialization for undirected graphs with no data on nodes nor + /// on edges. template<> - struct s_node<void> + class graph<void, void> : public internal::graph_base<void, void> { - // FIXME: Rename to `out_edges'. - std::list<unsigned> links; - }; + public: + /// The super class. + typedef internal::graph_base<void, void> super; - - /*! \brief Structure of generic edge. - * - */ - template<typename T> - struct s_edge - { - s_edge() - : pair_node_ (0, 0) - {} - - T data; - ordpair_<unsigned> pair_node_; + // FIXME: We should return the id of the newly created node. + /// \brief Add a node. + void add_node(); + // FIXME: We should return the id of the newly created edge. + /// \brief Add an edge between nodes with ids \p n1 and \p n2. + void add_edge(node_id n1, node_id n2); }; - /*! \brief Structure of edge with void parameter. - * - */ - template<> - struct s_edge <void> - { - s_edge() : pair_node_ (0, 0) {} - ordpair_<unsigned> pair_node_; + /*-----------------. + | graph<N, void>. | + `-----------------*/ + + /// Specialization for undirected graphs with data on nodes. + template <typename N> + class graph<N, void> : public internal::graph_base<N, void> + { + public: + /// The super class. + typedef internal::graph_base<N, void> super; + + // FIXME: We should return the id of the newly created node. + /// \brief Add a node. + void add_node(const N& data); + // FIXME: We should return the id of the newly created edge. + /// \brief Add an edge between nodes with ids \p n1 and \p n2. + void add_edge(node_id n1, node_id n2); + + /// Return the data associated to node with id \a n. + /// \{ + N& node_data(node_id n); + const N& node_data(node_id n) const; + /// \} }; - bool operator==(const struct s_edge <void>& lhs, - const struct s_edge <void>& rhs); - - bool operator< (const struct s_edge <void>& lhs, - const struct s_edge <void>& rhs); + /*--------------. + | graph<N, E>. | + `--------------*/ - /// \brief Generic graph structure using s_node and s_edge. - /* FIXME: We don't mention anywhere whether this graph structure - handles directed or undirected graphs! */ - template<typename N, typename E = void> - struct graph - { - /* FIXME: Do we really want handle edges and nodes through - pointers? In my (Roland) opinion, this is just a drawback, - here. */ - - /// The type of the set of nodes. - typedef std::vector< s_node<N>* > nodes; - /// The type of the set of edges. - typedef std::vector< s_edge<E>* > edges; + /// Specialization for undirected graphs with data on nodes and + /// edges. + template <typename N, typename E> + class graph : public internal::graph_base<N, E> + { + public: + /// The super class. + typedef internal::graph_base<N, E> super; + + // FIXME: We should return the id of the newly created node. + /// \brief Add a node. + void add_node(const N& data); + /// \brief Add an edge between nodes with ids \p n1 and \p n2. + // FIXME: We should return the id of the newly created edge. + void add_edge(node_id n1, node_id n2, const E& data); + + /// Return the data associated to node with id \a n. + /// \{ + N& node_data(node_id n); + const N& node_data(node_id n) const; + /// \} + + /// Return the data associated to the edge with id \a e. + /// \{ + E& edge_data(edge_id e); + const E& edge_data(edge_id e) const; + /// \} + + /// Return the data associated to the edge between nodes with + /// ids \a n1 and \a n2. + /// \{ + E& edge_data(node_id n1, node_id n2); + const E& edge_data(node_id n1, node_id n2) const; + /// \} + }; - /// Constructor. - graph (); - /// Destructor. - ~graph(); - /*! \brief Add a void node. */ - void add_node (); +# ifndef MLN_INCLUDE_ONLY + /*--------------------. + | graph<void, void>. | + `--------------------*/ - /*! \brief Add a void edge between \p n1 and \p n2. - * - * \param[in] n1 The first node to link. - * \param[in] n2 The second node to link. - * - * \pre n1 < nb_node_. - * \pre n2 < nb_node_. - */ - void add_edge (unsigned n1, unsigned n2); - - - /*! \brief Check the consistency of the graph. - * - * Check if all edge have their node in the graph. - * - * \pre nodes_.size () == nb_node_. - * \pre links_.size () == nb_link_. - */ - void consistency () const; - - - /*! \brief Print on \p ostr the graph. - * - * \param[in] ostr The output stream. - */ - void print_debug (std::ostream& ostr) const; + /* Note that ddefinition of members from fully specialized + template classes are not preceded by `template<>'. */ + inline + void + graph<void, void>::add_node() + { + super::add_node_(new util::node<void>); + } + /* Note that ddefinition of members from fully specialized + template classes are not preceded by `template<>'. */ + inline + void + graph<void, void>::add_edge(node_id n1, node_id n2) + { + super::add_edge_(new util::edge<void>(n1, n2)); + } + /*-----------------. + | graph<N, void>. | + `-----------------*/ - /// The nuber of nodes. - unsigned nb_node_; + template<typename N> + inline + void + graph<N, void>::add_node(const N& data) + { + super::add_node_(new util::node<N>(data)); + } - /// The nuber of links. - unsigned nb_link_; + template<typename N> + inline + void + graph<N, void>::add_edge(node_id n1, node_id n2) + { + mln_assertion(n1 < this->nnodes()); + mln_assertion(n2 < this->nnodes()); + super::add_edge_(new util::edge<void>(n1, n2)); + } - /// The vector where is stocked the pointers of nodes. - nodes nodes_; + template <class N> + inline + N& + graph<N, void>::node_data(node_id n) + { + mln_assertion(n < this->nnodes()); + return this->nodes_[n]->data; + } - /// The vector where is stocked the pointers of links. - edges links_; - }; + template<typename N> + inline + const N& + graph<N, void>::node_data(node_id n) const + { + mln_assertion(n < this->nnodes()); + return this->nodes_[n]->data; + } -# ifndef MLN_INCLUDE_ONLY + /*--------------. + | graph<N, E>. | + `--------------*/ - bool - operator==(const struct s_edge <void>& lhs, const struct s_edge <void>& rhs) + template<typename N, typename E> + inline + void + graph<N, E>::add_node(const N& data) { - return lhs.pair_node_ == rhs.pair_node_; + super::add_node_(new util::node<N>(data)); } - bool - operator< (const struct s_edge <void>& lhs, const struct s_edge <void>& rhs) + template<typename N, typename E> + inline + void + graph<N, E>::add_edge(node_id n1, node_id n2, const E& data) { - return lhs.pair_node_ < rhs.pair_node_; + mln_assertion(n1 < this->nnodes()); + mln_assertion(n2 < this->nnodes()); + super::add_edge_(new util::edge<E>(n1, n2, data)); } template<typename N, typename E> inline - graph<N, E>::graph () - : nb_node_ (0), - nb_link_ (0), - nodes_ (0), - links_ (0) + N& + graph<N, E>::node_data(node_id n) { + mln_assertion(n < this->nnodes()); + return this->nodes_[n]->data; } template<typename N, typename E> inline - graph<N, E>::~graph () + const N& + graph<N, E>::node_data(node_id n) const { + mln_assertion(n < this->nnodes()); + return this->nodes_[n]->data; } template<typename N, typename E> inline - void - graph<N, E>::add_node () + E& + graph<N, E>::edge_data(edge_id e) { - struct s_node<N>* n = new struct s_node<N>; - - nodes_.push_back (n); - ++nb_node_; + mln_assertion(e < this->nedges()); + return this->edges_[e]->data; } template<typename N, typename E> inline - void - graph<N, E>::add_edge (unsigned n1, unsigned n2) + const E& + graph<N, E>::edge_data(edge_id e) const { - mln_precondition(n1 < this->nb_node_); - mln_precondition(n2 < this->nb_node_); - - struct s_edge<E>* edge; - - edge = new s_edge<E>; - edge->pair_node_.first = n1; - edge->pair_node_.second = n2; - // Does this edge already exist in the graph? - if (std::find(links_.begin(), links_.end(), edge) != links_.end ()) - { - delete edge; - edge = 0; - } - else - { - links_.push_back (edge); - ++nb_link_; - /* FIXME: In fact, we should store adjaceny information in - *both* nodes. Change this globally later, and mention - that the graph is undirected in the documentation. And - don't forget to update clients! */ - nodes_[n1]->links.push_back (n2); - } + mln_assertion(e < this->nedges()); + return this->edges_[e]->data; } template<typename N, typename E> inline - void - graph<N, E>::consistency () const + E& + graph<N, E>::edge_data(node_id n1, node_id n2) { - mln_precondition(nodes_.size () == this->nb_node_); - mln_precondition(links_.size () == this->nb_link_); - typename std::vector<struct s_node <N>*>::const_iterator it = - nodes_.begin (); - for (; it != nodes_.end (); ++it) - { - typename std::list<unsigned>::const_iterator it2 = - (*it)->links.begin (); - for (; it2 != (*it)->links.end (); ++it2) - mln_precondition((*it2) < nb_node_); - } - - typename std::vector<struct s_edge<E>*>::const_iterator it3 = - links_.begin (); - for (; it3 != links_.end (); ++it3) - { - mln_precondition((*it3)->pair_node_.first < nb_node_); - mln_precondition((*it3)->pair_node_.second < nb_node_); - } + mln_assertion(n1 < this->nnodes()); + mln_assertion(n2 < this->nnodes()); + ordpair_<node_id> node_pair (n1, n2); + std::vector<edge_id>& edges_ids = this->nodes_[n1]->edges; + for (std::vector<edge_id>::iterator e = edges_ids.begin(); + e != edges_ids.end(); ++e) + if (this->edges_[*e] == node_pair) + return this->edges_[*e]->data; + // If no edge between N1 and N2 was found, abort. + abort(); } template<typename N, typename E> inline - void - graph<N, E>::print_debug (std::ostream& ostr) const - { - ostr << "nodes :" << std::endl; - - typename std::vector<struct s_node<N>*>::const_iterator it = - nodes_.begin (); - int i = 0; - for (; it != nodes_.end (); ++it, ++i) - { - ostr << "node number = " <::const_iterator it2 = (*it)->links.begin (); - for (; it2 != (*it)->links.end (); ++it2) + const E& + graph<N, E>::edge_data(node_id n1, node_id n2) const { - ostr << (*it2) << " "; - } - ostr << std::endl; - } - ostr << std::endl; + mln_assertion(n1 < this->nnodes()); + mln_assertion(n2 < this->nnodes()); + ordpair_<node_id> node_pair (n1, n2); + const std::vector<edge_id>& edges_ids = this->nodes_[n1]->edges; + for (std::vector<edge_id>::const_iterator e = edges_ids.begin(); + e != edges_ids.end(); ++e) + if (this->edges_[*e] == node_pair) + return this->edges_[*e]->data; + // If no edge between N1 and N2 was found, abort. + abort(); } # endif // ! MLN_INCLUDE_ONLY - } // end of util + } // end of namespace mln::util -} // end of mln +} // end of namespace mln -#endif // MLN_GRAPH_HH +#endif // ! MLN_UTIL_GRAPH_HH Index: tests/util/graph.cc --- tests/util/graph.cc (revision 1712) +++ tests/util/graph.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 @@ -25,12 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! - * \file tests/util/graph.cc - * - * \brief test of mln::util::graph - * - */ +/// \file tests/util/graph.cc +/// \brief test of mln::util::graph #include <mln/util/graph.hh> #include <iostream> @@ -55,5 +51,4 @@ g.add_edge (1, 0); g.add_edge (5, 3); g.add_edge (2, 1); - g.consistency (); }

1 1

1712: Have priority queues of points catch up with the interface of Point_Set.
by Roland Levillain 07 Feb '08

07 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Have priority queues of points catch up with the interface of Point_Set. * mln/core/p_priority_queue.hh (p_priority_queue::npoints) * mln/core/p_priority_queue_fast.hh (p_priority_queue_fast::npoints): Set the return type from `unsigned' to `size_t'. p_priority_queue.hh | 4 ++-- p_priority_queue_fast.hh | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) Index: mln/core/p_priority_queue.hh --- mln/core/p_priority_queue.hh (revision 1711) +++ mln/core/p_priority_queue.hh (working copy) @@ -83,7 +83,7 @@ bool is_empty() const; /// Give the number of points. - unsigned npoints() const; + size_t npoints() const; /// Give the exact bounding box. const box_& bbox() const; @@ -202,7 +202,7 @@ template <typename P, typename T> inline - unsigned + size_t p_priority_queue<P, T>::npoints() const { unsigned res = 0; Index: mln/core/p_priority_queue_fast.hh --- mln/core/p_priority_queue_fast.hh (revision 1711) +++ mln/core/p_priority_queue_fast.hh (working copy) @@ -83,7 +83,7 @@ bool is_empty() const; /// Give the number of points. - unsigned npoints() const; + size_t npoints() const; /// Give the exact bounding box. const box_& bbox() const; @@ -202,7 +202,7 @@ template <typename P, typename T> inline - unsigned + size_t p_priority_queue_fast<P, T>::npoints() const { unsigned res = 0;

1 0

1711: Fix ChangeLogs
by Roland Levillain 07 Feb '08

07 Feb '08

Remember: changes altering only milena/ should be put into milena/Changelog. Index: milena/ChangeLog =================================================================== --- milena/ChangeLog (révision 1710) +++ milena/ChangeLog (révision 1711) @@ -12,6 +12,11 @@ (pw_image_SOURCES, pw_value_SOURCES): Remove. * mln/pw/all.hh: Update. +2008-02-07 Maxime van Noppen <yabo(a)lrde.epita.fr> + + Fix typo. + * mln/core/internal/force_exact.hh: Here. + 2008-02-05 Roland Levillain <roland(a)lrde.epita.fr> Add functors max and min. Index: ChangeLog =================================================================== --- ChangeLog (révision 1710) +++ ChangeLog (révision 1711) @@ -1,8 +1,3 @@ -2008-02-07 Maxime van Noppen <yabo(a)lrde.epita.fr> - - Fix typo. - * milena/mln/core/internal/force_exact.hh: Here. - 2008-01-25 Roland Levillain <roland(a)lrde.epita.fr> * configure.ac: Configure milena/tests/neighb/Makefile.

1 0

1710: Update tests on pw material.
by Thierry Geraud 07 Feb '08

07 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Update tests on pw material. * tests/pw_image.cc: Rename as... * tests/pw/image.cc: ...this. * tests/pw_value.cc: Rename as... * tests/pw/value.cc: ...this. * tests/pw/Makefile.am (check_PROGRAMS): Update. (image_SOURCES, value_SOURCES): New. * tests/Makefile.am (SUBDIRS): Add pw. (pw_image_SOURCES, pw_value_SOURCES): Remove. * mln/pw/all.hh: Update. mln/pw/all.hh | 6 ++++-- tests/Makefile.am | 5 +---- tests/pw/Makefile.am | 9 +++++++++ tests/pw/image.cc | 2 +- tests/pw/value.cc | 22 ++++++++++++---------- 5 files changed, 27 insertions(+), 17 deletions(-) Index: tests/pw/value.cc --- tests/pw/value.cc (revision 1608) +++ tests/pw/value.cc (working copy) @@ -25,15 +25,14 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/pw_value.cc +/*! \file tests/pw/value.cc * * \brief Test on mln::pw::value_. */ #include <mln/core/image2d.hh> -#include <mln/fun/ops.hh> -#include <mln/pw/value.hh> -#include <mln/pw/cst.hh> +#include <mln/level/fill.hh> +#include <mln/pw/all.hh> int main() @@ -41,13 +40,16 @@ using namespace mln; image2d<int> ima(3, 3); - point2d p = make::point2d(1, 1); + level::fill(ima, 0); + + point2d p(1, 1); ima(p) = 51; mln_assertion( (pw::value(ima) = pw::cst(51))(p) = true ); - { - image2d<float> imaf(3,3); - imaf(p) = 51; - mln_assertion(((pw::value(ima) + pw::value(imaf))(p) / 20) - 5.1 < 0.00001); - } +// { +// image2d<float> imaf(3,3); +// imaf(p) = 51; +// mln_assertion(((pw::value(ima) + pw::value(imaf))(p) / 20) - 5.1 < 0.00001); +// } + } Index: tests/pw/image.cc --- tests/pw/image.cc (revision 1608) +++ tests/pw/image.cc (working copy) @@ -25,7 +25,7 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/pw_image.cc +/*! \file tests/pw/image.cc * * \brief Tests on mln::pw::image. */ Index: tests/pw/Makefile.am --- tests/pw/Makefile.am (revision 1709) +++ tests/pw/Makefile.am (working copy) @@ -1,3 +1,12 @@ ## Process this file through Automake to create Makefile.in -*- Makefile -*- include $(top_srcdir)/milena/tests/tests.mk + +check_PROGRAMS = \ + image \ + value + +image_SOURCES = image.cc +value_SOURCES = value.cc + +TESTS = $(check_PROGRAMS) Index: tests/Makefile.am --- tests/Makefile.am (revision 1709) +++ tests/Makefile.am (working copy) @@ -20,6 +20,7 @@ morpho \ neighb \ norm \ + pw \ set \ util \ value \ @@ -92,8 +93,6 @@ point1d \ point2d \ point3d \ - pw_image \ - pw_value \ \ safe_image \ seed2tiling \ @@ -184,8 +183,6 @@ point1d_SOURCES = point1d.cc point2d_SOURCES = point2d.cc point3d_SOURCES = point3d.cc -pw_image_SOURCES = pw_image.cc -pw_value_SOURCES = pw_value.cc safe_image_SOURCES = safe_image.cc seed2tiling_SOURCES = seed2tiling.cc Index: mln/pw/all.hh --- mln/pw/all.hh (revision 1709) +++ mln/pw/all.hh (working copy) @@ -43,11 +43,13 @@ } // end of namespace mln -# include <mln/pw/value.hh> # include <mln/pw/cst.hh> -# include <mln/pw/var.hh> # include <mln/pw/image.hh> +# include <mln/pw/value.hh> +# include <mln/pw/var.hh> + +// Extra include so that we can use operators in point-wise expressions. # include <mln/fun/ops.hh>

1 0

milena r1709: Fix typo.
by Maxime van Noppen 07 Feb '08

07 Feb '08

URL: https://svn.lrde.epita.fr/svn/oln/trunk ChangeLog: 2008-02-07 Maxime van Noppen <yabo(a)lrde.epita.fr> Fix typo. * milena/mln/core/internal/force_exact.hh: Here. force_exact.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) Index: trunk/milena/mln/core/internal/force_exact.hh =================================================================== --- trunk/milena/mln/core/internal/force_exact.hh (revision 1708) +++ trunk/milena/mln/core/internal/force_exact.hh (revision 1709) @@ -44,7 +44,7 @@ /*! \internal Violent cast. * This cast is an alternative to the mln::exact cast. - * It is used for objects than do not derive from + * It is used for objects that do not derive from * mln::Object. * Warning Do not to use this cast! * see mln::exact -- \__/ \__/ (00) Maxime `yabo` van Noppen (00) ___) \ Epita 2009 / (___ (_____/ Président de Prologin \_____)

1 0

Re: [Olena-patches] [Olena] #7: Miscellaneous tasks related to the Olena 1.0ß release process
by Olena 07 Feb '08

07 Feb '08

#7: Miscellaneous tasks related to the Olena 1.0ß release process -----------------------+---------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: new Priority: trivial | Milestone: Olena 1.0ß Component: other | Version: 1.0 Resolution: | Keywords: release NEWS dates copyright headers -----------------------+---------------------------------------------------- Old description: > To do before the release > * update `NEWS` (see the similar task for Olena 0.10a/0.11: #8); > * update `AUTHORS`; > * ensure all copyright headers are sound (using Benoît Sigoure's > `gplize.sh` script, or a variant of it). > > Split this ticket in several parts if the tasks are either too big or too > numerous. New description: To do before the release * update `NEWS` (see the similar task for Olena 0.10a/0.11: #8); * update `AUTHORS`; * ensure all copyright headers are sound (using Benoît Sigoure's `gplize.sh` script, or a variant of it); * use Vaucanson' `reheader` script to fix broken headers. Split this ticket in several parts if the tasks are either too big or too numerous. Comment (by levill_r): The use of `reheader` was suggested by Akim. -- Ticket URL: <https://trac.lrde.org/olena/ticket/7#comment:6> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

1 0

1708: Add functors max and min.
by Roland Levillain 05 Feb '08

05 Feb '08

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add functors max and min. * mln/core/concept/function.hh (mln::Function_vv2v): New. * mln/fun/vv2v/max.hh, mln/fun/vv2v/min.hh: New. * tests/fun/vv2v/max.cc, tests/fun/vv2v/min.cc: New tests. * tests/fun/vv2v/Makefile.am: New. * tests/fun/Makefile.am (SUBDIRS): Add i2v, p2b, p2v and vv2v. * tests/norm/common.hh: Adjust coding style. mln/core/concept/function.hh | 77 +++++++++++++++++++++++++++++++++++-------- mln/fun/vv2v/max.hh | 77 +++++++++++++++++++++++++++++++++++++++++++ mln/fun/vv2v/min.hh | 77 +++++++++++++++++++++++++++++++++++++++++++ tests/fun/Makefile.am | 2 - tests/fun/vv2v/Makefile.am | 12 ++++++ tests/fun/vv2v/max.cc | 53 +++++++++++++++++++++++++++++ tests/fun/vv2v/min.cc | 53 +++++++++++++++++++++++++++++ tests/norm/common.hh | 0 8 files changed, 336 insertions(+), 15 deletions(-) Index: mln/core/concept/function.hh --- mln/core/concept/function.hh (revision 1707) +++ mln/core/concept/function.hh (working copy) @@ -39,9 +39,7 @@ namespace mln { - /// \{ - /// Fwd decls. - + // Fwd decls. template <typename E> struct Function; template <typename E> struct Function_v2v; template <typename E> struct Function_i2v; @@ -50,11 +48,11 @@ template <typename E> struct Function_p2b; template <typename E> struct Function_p2p; template <typename E> struct Function_x2x; - /// \} + template <typename E> struct Function_vv2v; - // Function category flag type. + /// Function category flag type. template <> struct Function<void> { @@ -81,7 +79,9 @@ }; - // Value -> Value. + /*-----------------. + | Value -> Value. | + `-----------------*/ template <> struct Function_v2v<void> { typedef Function<void> super; }; @@ -102,12 +102,13 @@ }; - // Index -> Value. + /*-----------------. + | Index -> Value. | + `-----------------*/ template <> struct Function_i2v<void> { typedef Function_v2v<void> super; }; - /*! * \brief Base class for implementation of function-objects from * index to value. @@ -124,7 +125,9 @@ }; - // Point -> Value. + /*-----------------. + | Point -> Value. | + `-----------------*/ template <> struct Function_p2v<void> { typedef Function_v2v<void> super; }; @@ -145,7 +148,9 @@ }; - // Value -> bool. + /*----------------. + | Value -> bool. | + `----------------*/ template <> struct Function_v2b<void> { typedef Function_v2v<void> super; }; @@ -167,7 +172,9 @@ }; - // Point -> bool. + /*----------------. + | Point -> bool. | + `----------------*/ template <> struct Function_p2b<void> { typedef Function_p2v<void> super; }; // FIXME @@ -190,7 +197,9 @@ }; - // Point -> Point. + /*-----------------. + | Point -> Point. | + `-----------------*/ template <> struct Function_p2p<void> { typedef Function_p2v<void> super; }; // FIXME @@ -211,7 +220,9 @@ }; - // Vector -> Vector. + /*-------------------. + | Vector -> Vector. | + `-------------------*/ template <> struct Function_x2x<void> { typedef Function_v2v<void> super; }; // FIXME @@ -231,7 +242,10 @@ Function_x2x(const Function_x2x&); }; - // Vector <-> Vector. + + /*--------------------. + | Vector <-> Vector. | + `--------------------*/ /*! * \brief Base class for implementation of bijective function-objects from @@ -251,6 +265,28 @@ }; + /*------------------------. + | Value, Value -> Value. | + `------------------------*/ + + template <> + struct Function_vv2v<void> { typedef Function<void> super; }; + + /*! + * \brief Base class for implementation of function-objects from + * a couple of values to a value. + * + * The parameter \a E is the exact type. + */ + template <typename E> + struct Function_vv2v : public Function<E> + { + typedef Function_vv2v<void> category; + protected: + Function_vv2v(); + Function_vv2v(const Function_vv2v&); + }; + # ifndef MLN_INCLUDE_ONLY @@ -370,6 +406,19 @@ m = 0; } + template <typename E> + inline + Function_vv2v<E>::Function_vv2v() + { + } + + template <typename E> + inline + Function_vv2v<E>::Function_vv2v(const Function_vv2v<E>& rhs) + : Function<E>(rhs) + { + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/fun/vv2v/min.hh --- mln/fun/vv2v/min.hh (revision 0) +++ mln/fun/vv2v/min.hh (revision 0) @@ -0,0 +1,77 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2V_MIN_HH +# define MLN_FUN_VV2V_MIN_HH + +/// \file mln/fun/vv2v/min.hh +/// \brief computing the minimum of two values using a functor. + +# include <mln/core/concept/function.hh> +# include <mln/math/min.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2v + { + + // FIXME: Doc. + + /// \brief A functor computing the minimum of two values. + template <typename V> + struct min : public Function_vv2v< min<V> > + { + typedef V result; + V operator()(const V& v1, const V& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V> + inline + V + min<V>::operator()(const V& v1, const V& v2) const + { + return mln::math::min(v1, v2); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2v + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2V_MIN_HH Index: mln/fun/vv2v/max.hh --- mln/fun/vv2v/max.hh (revision 0) +++ mln/fun/vv2v/max.hh (revision 0) @@ -0,0 +1,77 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2V_MAX_HH +# define MLN_FUN_VV2V_MAX_HH + +/// \file mln/fun/vv2v/max.hh +/// \brief Computing the maximum of two values using a functor. + +# include <mln/core/concept/function.hh> +# include <mln/math/max.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2v + { + + // FIXME: Doc. + + /// \brief A functor computing the maximum of two values. + template <typename V> + struct max : public Function_vv2v< max<V> > + { + typedef V result; + V operator()(const V& v1, const V& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V> + inline + V + max<V>::operator()(const V& v1, const V& v2) const + { + return mln::math::max(v1, v2); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2v + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2V_MAX_HH Index: tests/fun/vv2v/min.cc --- tests/fun/vv2v/min.cc (revision 0) +++ tests/fun/vv2v/min.cc (revision 0) @@ -0,0 +1,53 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/// \file tests/fun/vv2v/min.cc +/// \brief Test the min functor. + +#include <cassert> + +#include <mln/metal/vec.hh> +#include <mln/fun/vv2v/min.hh> + +int main() +{ + // Scalars. + mln::fun::vv2v::min<int> min_int; + assert (min_int(42, 51) == 42); + + // FIXME: We don't have vectors-with-an-order (yet), so this won't + // work. +#if 0 + // Vectors. + typedef mln::metal::vec<3, int> vec_t; + mln::fun::vv2v::min<vec_t> min_vec_t; + vec_t t, u; + t.set (1, -2, 3); + u.set (5, 1, 0); + assert (min_vec_t(t, u) == t); +#endif +} Index: tests/fun/vv2v/max.cc --- tests/fun/vv2v/max.cc (revision 0) +++ tests/fun/vv2v/max.cc (revision 0) @@ -0,0 +1,53 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/// \file tests/fun/vv2v/max.cc +/// \brief Test the max functor. + +#include <cassert> + +#include <mln/metal/vec.hh> +#include <mln/fun/vv2v/max.hh> + +int main() +{ + // Scalars. + mln::fun::vv2v::max<int> max_int; + assert (max_int(42, 51) == 51); + + // FIXME: We don't have vectors-with-an-order (yet), so this won't + // work. +#if 0 + // Vectors. + typedef mln::metal::vec<3, int> vec_t; + mln::fun::vv2v::max<vec_t> max_vec_t; + vec_t t, u; + t.set (1, -2, 3); + u.set (5, 1, 0); + assert (max_vec_t(t, u) == u); +#endif +} Index: tests/fun/vv2v/Makefile.am --- tests/fun/vv2v/Makefile.am (revision 0) +++ tests/fun/vv2v/Makefile.am (revision 0) @@ -0,0 +1,12 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include $(top_srcdir)/milena/tests/tests.mk + +check_PROGRAMS = \ + max \ + min + +max_SOURCES = max.cc +min_SOURCES = min.cc + +TESTS = $(check_PROGRAMS) Index: tests/fun/Makefile.am --- tests/fun/Makefile.am (revision 1707) +++ tests/fun/Makefile.am (working copy) @@ -2,4 +2,4 @@ include $(top_srcdir)/milena/tests/tests.mk -SUBDIRS = v2v x2x +SUBDIRS = i2v p2b p2v v2v vv2v x2x Index: tests/norm/common.hh

1 0