https://svn.lrde.epita.fr/svn/oln/trunk/milena
Index: ChangeLog
from Roland Levillain <roland(a)lrde.epita.fr>
Add complex-based psite and pset.
* mln/core/complex_psite.hh, mln/core/p_complex.hh: New.
* mln/core/face.hh: s/mln_assertion/mln_precondition/.
(mln::face_handle<N, D>::face_handle): Statically ensure N is
compatible with D in ctors.
* tests/core/p_complex.cc: New test.
* tests/core/Makefile.am (check_PROGRAMS): Add p_complex.
(p_complex_SOURCES): New.
mln/core/complex_psite.hh | 249 ++++++++++++++++++++++++++++++++++++++++++++++
mln/core/face.hh | 17 ++-
mln/core/p_complex.hh | 199 ++++++++++++++++++++++++++++++++++++
tests/core/Makefile.am | 2
tests/core/p_complex.cc | 95 +++++++++++++++++
5 files changed, 556 insertions(+), 6 deletions(-)
Index: mln/core/face.hh
--- mln/core/face.hh (revision 2121)
+++ mln/core/face.hh (working copy)
@@ -150,7 +150,6 @@
/// Accessors.
/// \{
/// Return the complex the face belongs to.
- // FIXME: Rename to complex()?
complex<D>& cplx() const;
/// Return the id of the face.
unsigned face_id() const;
@@ -269,18 +268,24 @@
face_handle<N, D>::face_handle()
: cplx_(0), face_id_(UINT_MAX)
{
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
}
template <unsigned N, unsigned D>
face_handle<N, D>::face_handle(complex<D>& c, unsigned face_id)
: cplx_(&c), face_id_(face_id)
{
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
}
template <unsigned N, unsigned D>
face_handle<N, D>::face_handle(const face_handle<N, D>& rhs)
: cplx_(rhs.cplx_), face_id_(rhs.face_id_)
{
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
}
template <unsigned N, unsigned D>
@@ -306,7 +311,7 @@
complex<D>&
face_handle<N, D>::cplx() const
{
- mln_assertion(cplx_);
+ mln_precondition(cplx_);
return *cplx_;
}
@@ -321,7 +326,7 @@
face<N, D>&
face_handle<N, D>::to_face() const
{
- mln_assertion(is_valid());
+ mln_precondition(is_valid());
return cplx_->template face_<N>(face_id_);
}
@@ -337,7 +342,7 @@
bool
operator==(const face_handle<N, D>& lhs, const face_handle<N, D>&
rhs)
{
- mln_assertion(&lhs.face.cplx() == &rhs.face.cplx());
+ mln_precondition(&lhs.face.cplx() == &rhs.face.cplx());
return lhs.face().id() == rhs.face().id();
}
@@ -345,7 +350,7 @@
bool
operator< (const face_handle<N, D>& lhs, const face_handle<N,
D>& rhs)
{
- mln_assertion(&lhs.face.cplx() == &rhs.face.cplx());
+ mln_precondition(&lhs.face.cplx() == &rhs.face.cplx());
return lhs.face().id() < rhs.face().id();
}
@@ -360,7 +365,7 @@
{
// Check consistency.
if (!faces_.empty())
- mln_assertion(&faces_.front().cplx() == &f.cplx());
+ mln_precondition(&faces_.front().cplx() == &f.cplx());
faces_.push_back(f);
}
Index: mln/core/complex_psite.hh
--- mln/core/complex_psite.hh (revision 0)
+++ mln/core/complex_psite.hh (revision 0)
@@ -0,0 +1,249 @@
+// 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.
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef MLN_CORE_COMPLEX_PSITE_HH
+# define MLN_CORE_COMPLEX_PSITE_HH
+
+/// \file mln/core/complex_psite.hh
+/// \brief Definition of a complex-based point site.
+
+# include <mln/core/concept/point_site.hh>
+
+# include <mln/core/complex.hh>
+
+
+namespace mln
+{
+ /* FIXME: Write also a complex_psite where N is dynamic, and can be
+ changed? */
+
+ /* FIXME: Currently, P and N are free variables; we might want to
+ relate them, e.g., have P::dim == N. Or even get rid of P. */
+
+ /// \brief Point site associated to a mln::complex_image.
+ ///
+ /// \arg \p P The type of point associated to this psite.
+ /// \arg \p N The dimension of the face associated to this psite.
+ /// \arg \p D The dimention of the complex this psite belongs to.
+ template <typename P, unsigned N, unsigned D>
+ class complex_psite : public Point_Site< complex_psite<P, N, D> >
+ {
+ typedef complex_psite<P, N, D> self_;
+ typedef Point_Site<self_> super_;
+
+ public:
+ typedef mln_mesh(P) mesh;
+ enum { dim = P::dim };
+ typedef P point;
+ typedef mln_dpoint(P) dpoint;
+ typedef mln_coord(P) coord;
+
+ /// Construction and assignment.
+ /// \{
+ complex_psite();
+ complex_psite(const face_handle<N, D>& face);
+ complex_psite(const self_& rhs);
+ self_& operator= (const self_& rhs);
+ /// \}
+
+ /// Access to psite.
+ const self_& to_psite() const;
+
+ /* FIXME: Should be removed as soon as ``point sets'' become
+ ``site sets''. */
+ /// Access to point.
+ /// \{
+ const point& to_point() const;
+ coord operator[](unsigned face) const;
+ /// \}
+
+ /// Return the face handle of this point site.
+ face_handle<N, D> face() const;
+ /// Return the complex on which this site is built.
+ const complex<D>& cplx() const;
+
+ /// Is this psite valid?
+ bool is_valid() const;
+
+ private:
+ /// The handle of the face this psite is pointing towards.
+ face_handle<N, D> face_;
+ // FIXME: Actually, this is a dummy value!
+ point p_;
+ };
+
+
+ /// Comparison of two instances of mln::complex_psite.
+ /// \{
+ /* FIXME: Shouldn't those comparisons be part of a much general
+ mechanism? */
+
+ /// \brief Is \a lhs equal to \a rhs?
+ ///
+ /// \pre Arguments \a lhs and \a rhs must belong to the same
+ /// mln::complex.
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator==(const complex_psite<P, N, D>& lhs,
+ const complex_psite<P, N, D>& rhs);
+
+ /// \brief Is \a lhs ``less'' than \a rhs?
+ ///
+ /// This comparison is required by algorithms sorting psites.
+ ///
+ /// \pre Arguments \a lhs and \a rhs must belong to the same
+ /// mln::complex.
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator< (const complex_psite<P, N, D>& lhs,
+ const complex_psite<P, N, D>& rhs);
+ /// \}
+
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ complex_psite<P, N, D>::complex_psite()
+ : super_(),
+ // Dummy initializations.
+ face_(), p_()
+ {
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ complex_psite<P, N, D>::complex_psite(const face_handle<N, D>& face)
+ : super_(),
+ face_(face), p_()
+ {
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ complex_psite<P, N, D>::complex_psite(const complex_psite<P, N, D>&
rhs)
+ : super_(rhs),
+ face_(rhs.face_), p_()
+ {
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ complex_psite<P, N, D>&
+ complex_psite<P, N, D>::operator= (const complex_psite<P, N, D>& rhs)
+ {
+ if (&rhs == this)
+ return *this;
+ face_ = rhs.face_;
+ return *this;
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ bool
+ complex_psite<P, N, D>::is_valid() const
+ {
+ return face.is_valid();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ const complex_psite<P, N, D>&
+ complex_psite<P, N, D>::to_psite() const
+ {
+ return *this;
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ const P&
+ complex_psite<P, N, D>::to_point() const
+ {
+ // FIXME: Dummy value.
+ return p_;
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ mln_coord(P)
+ complex_psite<P, N, D>::operator[](unsigned i) const
+ {
+ mln_precondition(is_valid());
+ return to_point()[i];
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ face_handle<N, D>
+ complex_psite<P, N, D>::face() const
+ {
+ return face_;
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ const complex<D>&
+ complex_psite<P, N, D>::cplx() const
+ {
+ return face_.cplx();
+ }
+
+ /*--------------.
+ | Comparisons. |
+ `--------------*/
+
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator==(const complex_psite<P, N, D>& lhs,
+ const complex_psite<P, N, D>& rhs)
+ {
+ mln_precondition(&lhs.cplx() == &rhs.cplx());
+ return lhs.face() == rhs.face();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator< (const complex_psite<P, N, D>& lhs,
+ const complex_psite<P, N, D>& rhs)
+ {
+ mln_precondition(&lhs.cplx() == &rhs.cplx());
+ return lhs.face() < rhs.face();
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+
+} // end of mln
+
+#endif // MLN_CORE_COMPLEX_PSITE_HH
Index: mln/core/p_complex.hh
--- mln/core/p_complex.hh (revision 0)
+++ mln/core/p_complex.hh (revision 0)
@@ -0,0 +1,199 @@
+// 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.
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef MLN_CORE_P_COMPLEX_HH
+# define MLN_CORE_P_COMPLEX_HH
+
+/// \file mln/core/p_complex.hh
+/// \brief Definition of a point set based on a complex.
+
+# include <mln/core/internal/point_set_base.hh>
+
+# include <mln/accu/bbox.hh>
+# include <mln/util/tracked_ptr.hh>
+# include <mln/core/complex.hh>
+
+# include <mln/core/complex_psite.hh>
+
+
+namespace mln
+{
+
+ /// A complex psite set based on a complex of dimension \p D (a \p
+ /// D-complex).
+ template<typename P, unsigned N, unsigned D>
+ struct p_complex
+ : public internal::point_set_base_< complex_psite<P, N, D>,
+ p_complex<P, N, D> >
+ {
+ /// \brief Construct a complex psite set from a complex.
+ ///
+ /// \param gr The complex upon which the complex psite set is built.
+ ///
+ /// \a gr is \em copied internally, so that the complex psite set is
+ /// still valid after the initial complex has been removed.
+ p_complex (const complex<D>& cplx);
+
+ /// Point_Site associated type.
+ typedef complex_psite<P, N, D> psite;
+
+ // FIXME: Fake.
+ typedef void fwd_piter;
+ typedef void bkd_piter;
+
+ /// \brief Return The number of points (sites) of the set, i.e., the
+ /// number of \em faces.
+ ///
+ /// Required by the mln::Point_Set concept.
+ std::size_t npoints() const;
+
+ /// Return The number of faces in the complex.
+ std::size_t nfaces() const;
+
+ /// Give the exact bounding box.
+ const box_<P>& bbox() const;
+
+ bool has(const psite& p) const;
+
+ /// Return the complex associated to the p_complex domain.
+ const complex<D>& cplx() const;
+
+ private:
+ /// The complex on which this pset is built.
+ util::tracked_ptr< complex<D> > cplx_;
+ // FIXME: Remove as soon as bbox become optional.
+ box_<P> bb_;
+ };
+
+
+ /// \brief Comparison between two mln::p_complex's.
+ ///
+ /// Two mln::p_complex's are considered equal if they share the
+ /// same complex.
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator==(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>&
rhs);
+
+ /// \brief Inclusion of a mln::p_complex in another one.
+ ///
+ /// This inclusion relation is very strict for the moment, since our
+ /// infrastrure for complexs is simple: a mln::p_complex is included
+ /// in another one if their are equal.
+ ///
+ /// \todo Refine this later, when we are able to express subcomplex
+ /// relations.
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator<=(const p_complex<P, N, D>& lhs, const p_complex<P, N,
D>& rhs);
+
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ p_complex<P, N, D>::p_complex(const complex<D>& cplx)
+ // Create a deep, managed copy of CPLX.
+ : cplx_(new complex<D>(cplx))
+ {
+ // Ensure N is compatible with D.
+ metal::bool_< N <= D >::check();
+
+ // FIXME: Dummy initialization.
+ accu::bbox<P> a;
+ for (unsigned i = 0; i < npoints(); ++i)
+ a.take(P());
+ bb_ = a.to_result();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ std::size_t
+ p_complex<P, N, D>::npoints() const
+ {
+ return nfaces();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ std::size_t
+ p_complex<P, N, D>::nfaces() const
+ {
+ return this->cplx_->template nfaces<N>();
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ const box_<P>&
+ p_complex<P, N, D>::bbox() const
+ {
+ // FIXME: Dummy value.
+ return bb_;
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ inline
+ bool
+ p_complex<P, N, D>::has(const psite& p) const
+ {
+ return
+ // Check whether P's complex is compatible with this pset's complex.
+ &p.cplx() == &cplx() &&
+ // Check whether the complex has the face associated to P.
+ p.face().is_valid();
+ }
+
+
+ template <typename P, unsigned N, unsigned D>
+ const complex<D>&
+ p_complex<P, N, D>::cplx() const
+ {
+ mln_precondition(cplx_);
+ return *cplx_.ptr_;
+ }
+
+
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator==(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>&
rhs)
+ {
+ return lhs.cplx_.ptr_ == rhs.cplx_.ptr_;
+ }
+
+ template <typename P, unsigned N, unsigned D>
+ bool
+ operator<=(const p_complex<P, N, D>& lhs, const p_complex<P, N,
D>& rhs)
+ {
+ return lhs == rhs;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+} // end of mln
+
+
+#endif // MLN_CORE_P_COMPLEX_HH
Index: tests/core/p_complex.cc
--- tests/core/p_complex.cc (revision 0)
+++ tests/core/p_complex.cc (revision 0)
@@ -0,0 +1,95 @@
+// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE)
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+/// \file tests/core/p_complex.cc
+/// \brief Test of mln::p_complex.
+
+#include <iostream>
+
+#include <mln/core/p_complex.hh>
+#include <mln/core/point2d.hh>
+
+
+// FIXME: Extend this test and rename it as complex_image.cc.
+
+int main()
+{
+ using namespace mln;
+
+ /*----------.
+ | Complex. |
+ `----------*/
+
+ /* A 2-d (simplicial) complex and its adjacency graph.
+
+ v0 e3 v3
+ o-----------o v0----e3----v3
+ / \ ,-----. / / \ | /
+ / . \ \ t2/ / / \ t2 /
+ e0 / / \ e1\ / / e4 e0. ,e1� `e4
+ / /t1 \ \ ' / / t1 \ /
+ / `-----' \ / / | \ /
+ o-----------o v1----e2----v2
+ v1 e2 v2
+
+ v = vertex
+ e = edge
+ t = triangle
+ */
+
+
+ complex<2> c;
+
+ // 0-faces (points).
+ face_handle<0, 2> v0 = c.add_face();
+ face_handle<0, 2> v1 = c.add_face();
+ face_handle<0, 2> v2 = c.add_face();
+ face_handle<0, 2> v3 = c.add_face();
+
+ // 1-faces (segments).
+ face_handle<1, 2> e0 = c.add_face(v0 + v1);
+ face_handle<1, 2> e1 = c.add_face(v0 + v2);
+ face_handle<1, 2> e2 = c.add_face(v1 + v2);
+ face_handle<1, 2> e3 = c.add_face(v0 + v3);
+ face_handle<1, 2> e4 = c.add_face(v2 + v3);
+
+ // 2-faces (triangles).
+ face_handle<2, 2> t0 = c.add_face(e0 + e1 + e2);
+ face_handle<2, 2> t1 = c.add_face(e1 + e3 + e4);
+
+
+ /*----------------------.
+ | Complex-based psets. |
+ `----------------------*/
+
+ // Pset of 0-faces.
+ p_complex<point2d, 0, 2> pc0(c);
+ // Pset of 1-faces.
+ p_complex<point2d, 1, 2> pc1(c);
+ // Pset of 2-faces.
+ p_complex<point2d, 2, 2> pc2(c);
+}
Index: tests/core/Makefile.am
--- tests/core/Makefile.am (revision 2121)
+++ tests/core/Makefile.am (working copy)
@@ -51,6 +51,7 @@
\
obased_rle_image \
\
+ p_complex \
p_priority_queue \
p_priority_queue_fast \
p_priority_queue_fast_with_array \
@@ -138,6 +139,7 @@
obased_rle_image_SOURCES = obased_rle_image.cc
+p_complex_SOURCES = p_complex.cc
p_priority_queue_SOURCES = p_priority_queue.cc
p_priority_queue_fast_SOURCES = p_priority_queue_fast.cc
p_priority_queue_fast_with_array_SOURCES = p_priority_queue_fast.cc