Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

Re: [Olena-patches] [Olena] #112: Add full test for mln::draw

by Olena

#112: Add full test for mln::draw ----------------------+----------------------------------------------------- Reporter: duhamel | Owner: Olena Team Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Resolution: | Keywords: ----------------------+----------------------------------------------------- Changes (by levill_r): * owner: duhamel => Olena Team -- Ticket URL: <https://trac.lrde.org/olena/ticket/112#comment:1> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 5 months

Re: [Olena-patches] [Olena] #111: Add full test for mln::display

by Olena

#111: Add full test for mln::display ----------------------+----------------------------------------------------- Reporter: duhamel | Owner: Olena Team Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Resolution: | Keywords: ----------------------+----------------------------------------------------- Changes (by levill_r): * owner: duhamel => Olena Team -- Ticket URL: <https://trac.lrde.org/olena/ticket/111#comment:2> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 5 months

Re: [Olena-patches] [Olena] #120: Handle check_full.

by Olena

#120: Handle check_full. ------------------------+--------------------------------------------------- Reporter: garrigues | Owner: levill_r Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Resolution: | Keywords: ------------------------+--------------------------------------------------- Changes (by levill_r): * owner: levil_r => levill_r Comment: Reassign to `levill_r` (with two 'l'!). -- Ticket URL: <https://trac.lrde.org/olena/ticket/120#comment:1> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 5 months

2128: Add actual complex-based psite and pset.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add actual complex-based psite and pset and give new names to faces-related entities. * mln/core/complex_psite.hh: Rename as... * mln/core/faces_psite.hh: ...this. (mln::complex_psite<P, N, D>): Turn into... (mln::faces_psite<N, D, P>): ...this. * mln/core/p_complex.hh: Rename as... * mln/core/p_faces.hh: ...this. (mln::p_complex<P, N, D>): Turn into... (mln::p_faces<N, D, P>): ...this. * mln/core/complex_psite.hh, mln/core/p_complex.hh: New. * tests/core/complex.cc: Exercise the variants of mln::complex<D>::nfaces(). * tests/core/p_complex.cc: Rename as... * tests/core/complex_image.cc: ...this. Exercise mln::p_complex, mln::complex_psite, and mln::faces_psite. * tests/core/Makefile.am (check_PROGRAMS): s/p_complex/complex_image/. (p_complex_SOURCES): Likewise. Rename as... (complex_image_SOURCES): ...this. mln/core/complex_psite.hh | 101 +++++++++++++++++++----------------------- mln/core/faces_psite.hh | 104 +++++++++++++++++++++----------------------- mln/core/p_complex.hh | 68 ++++++++++++++++------------ mln/core/p_faces.hh | 90 +++++++++++++++++++++----------------- tests/core/Makefile.am | 4 - tests/core/complex.cc | 13 +++++ tests/core/complex_image.cc | 83 +++++++++++++++++++++++++---------- 7 files changed, 260 insertions(+), 203 deletions(-) Index: tests/core/complex.cc --- tests/core/complex.cc (revision 2127) +++ tests/core/complex.cc (working copy) @@ -75,4 +75,17 @@ face_handle<2, 2> t1 = c.add_face(e1 + e3 + e4); std::cout << c << std::endl; + + std::cout << "``Static'' manipulators." << std::endl; + std::cout << " number of 0-faces: " << c.nfaces<0>() << std::endl; + std::cout << " number of 1-faces: " << c.nfaces<1>() << std::endl; + std::cout << " number of 2-faces: " << c.nfaces<2>() << std::endl; + std::cout << " total number of faces: " << c.nfaces() << std::endl; + + std::cout << std::endl; + + std::cout << "``Dynamic'' manipulators." << std::endl; + std::cout << " number of 0-faces: " << c.nfaces(0) << std::endl; + std::cout << " number of 1-faces: " << c.nfaces(1) << std::endl; + std::cout << " number of 2-faces: " << c.nfaces(2) << std::endl; } Index: tests/core/complex_image.cc --- tests/core/complex_image.cc (revision 2123) +++ tests/core/complex_image.cc (working copy) @@ -25,16 +25,18 @@ // 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. +/// \file tests/core/complex_image.cc +/// \brief Test of mln::complex_image. #include <iostream> -#include <mln/core/p_complex.hh> #include <mln/core/point2d.hh> +// #include <mln/core/complex_image.hh> +#include <mln/core/p_faces.hh> +#include <mln/core/p_complex.hh> + -// FIXME: Extend this test and rename it as complex_image.cc. int main() { @@ -62,34 +64,71 @@ */ - complex<2> c; + const unsigned D = 2; + + complex<D> 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(); + face_handle<0, D> v0 = c.add_face(); + face_handle<0, D> v1 = c.add_face(); + face_handle<0, D> v2 = c.add_face(); + face_handle<0, D> 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); + face_handle<1, D> e0 = c.add_face(v0 + v1); + face_handle<1, D> e1 = c.add_face(v0 + v2); + face_handle<1, D> e2 = c.add_face(v1 + v2); + face_handle<1, D> e3 = c.add_face(v0 + v3); + face_handle<1, D> 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); + face_handle<2, D> t0 = c.add_face(e0 + e1 + e2); + face_handle<2, D> t1 = c.add_face(e1 + e3 + e4); - /*----------------------. - | Complex-based psets. | - `----------------------*/ + /*---------------------. + | Complex-based pset. | + `---------------------*/ + + // A pset. + p_complex<D, point2d> pc0(c); + // An any-face handle (on E0) + any_face_handle<D> af(c, 1, 0); + // An associated psite. + complex_psite<D, point2d> cs(af); + + + /*--------------------. + | Faces-based psets. | + `--------------------*/ // Pset of 0-faces. - p_complex<point2d, 0, 2> pc0(c); + p_faces<0, D, point2d> pf0(c); // Pset of 1-faces. - p_complex<point2d, 1, 2> pc1(c); + p_faces<1, D, point2d> pf1(c); // Pset of 2-faces. - p_complex<point2d, 2, 2> pc2(c); + p_faces<2, D, point2d> pf2(c); + + // Some psites on faces. + faces_psite<0, D, point2d> fs0(v0); + faces_psite<1, D, point2d> fs1(e0); + faces_psite<2, D, point2d> fs2(t0); + + + // FIXME: Enable when complex_image is available. +#if 0 + /*----------------------. + | Complex-based image. | + `----------------------*/ + + // An image type built on a 2-complex with mln::int_u8 values on + // each face. + typedef ima_t complex_image< p_complex<D, point2d>, int_u8>; + + // FIXME: Create and init IMA. + // ... + ima_t ima(pc2); + + mln_piter_(ima_t) p(ima.domain()); +#endif } Property changes on: tests/core/complex_image.cc ___________________________________________________________________ Added: svn:mergeinfo Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 2127) +++ tests/core/Makefile.am (working copy) @@ -13,6 +13,7 @@ clock_test \ clone \ complex \ + complex_image \ \ decorated_image \ dpoint1d \ @@ -51,7 +52,6 @@ \ obased_rle_image \ \ - p_complex \ p_priority_queue \ p_priority_queue_fast \ p_priority_queue_fast_with_array \ @@ -101,6 +101,7 @@ clock_test_SOURCES = clock_test.cc clone_SOURCES = clone.cc complex_SOURCES = complex.cc +complex_image_SOURCES = complex_image.cc decorated_image_SOURCES = decorated_image.cc dpoint1d_SOURCES = dpoint1d.cc @@ -139,7 +140,6 @@ 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 Index: mln/core/complex_psite.hh --- mln/core/complex_psite.hh (revision 2127) +++ mln/core/complex_psite.hh (working copy) @@ -38,21 +38,16 @@ namespace mln { - /* FIXME: Write also a complex_psite where N is dynamic, and can be - changed? */ + /* FIXME: Get rid of P? */ - /* 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. + /// \brief Point site associated to a mln::p_complex. /// + /// \arg \p D The dimension of the complex this psite belongs to. /// \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> > + template <unsigned D, typename P> + class complex_psite : public Point_Site< complex_psite<D, P> > { - typedef complex_psite<P, N, D> self_; + typedef complex_psite<D, P> self_; typedef Point_Site<self_> super_; public: @@ -65,7 +60,7 @@ /// Construction and assignment. /// \{ complex_psite(); - complex_psite(const face_handle<N, D>& face); + complex_psite(const any_face_handle<D>& face); complex_psite(const self_& rhs); self_& operator= (const self_& rhs); /// \} @@ -82,7 +77,7 @@ /// \} /// Return the face handle of this point site. - face_handle<N, D> face() const; + any_face_handle<D> face() const; /// Return the complex on which this site is built. const complex<D>& cplx() const; @@ -91,7 +86,7 @@ private: /// The handle of the face this psite is pointing towards. - face_handle<N, D> face_; + any_face_handle<D> face_; // FIXME: Actually, this is a dummy value! point p_; }; @@ -106,10 +101,10 @@ /// /// \pre Arguments \a lhs and \a rhs must belong to the same /// mln::complex. - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator==(const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs); + operator==(const complex_psite<D, P>& lhs, + const complex_psite<D, P>& rhs); /// \brief Is \a lhs ``less'' than \a rhs? /// @@ -117,51 +112,45 @@ /// /// \pre Arguments \a lhs and \a rhs must belong to the same /// mln::complex. - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator< (const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs); + operator< (const complex_psite<D, P>& lhs, + const complex_psite<D, P>& rhs); /// \} # ifndef MLN_INCLUDE_ONLY - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline - complex_psite<P, N, D>::complex_psite() + complex_psite<D, P>::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> + template <unsigned D, typename P> inline - complex_psite<P, N, D>::complex_psite(const face_handle<N, D>& face) + complex_psite<D, P>::complex_psite(const any_face_handle<D>& face) : super_(), face_(face), p_() { - // Ensure N is compatible with D. - metal::bool_< N <= D >::check(); } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline - complex_psite<P, N, D>::complex_psite(const complex_psite<P, N, D>& rhs) + complex_psite<D, P>::complex_psite(const complex_psite<D, P>& 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> + template <unsigned D, typename P> inline - complex_psite<P, N, D>& - complex_psite<P, N, D>::operator= (const complex_psite<P, N, D>& rhs) + complex_psite<D, P>& + complex_psite<D, P>::operator= (const complex_psite<D, P>& rhs) { if (&rhs == this) return *this; @@ -169,52 +158,52 @@ return *this; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline bool - complex_psite<P, N, D>::is_valid() const + complex_psite<D, P>::is_valid() const { - return face.is_valid(); + return face_.is_valid(); } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline - const complex_psite<P, N, D>& - complex_psite<P, N, D>::to_psite() const + const complex_psite<D, P>& + complex_psite<D, P>::to_psite() const { return *this; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline const P& - complex_psite<P, N, D>::to_point() const + complex_psite<D, P>::to_point() const { // FIXME: Dummy value. return p_; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline mln_coord(P) - complex_psite<P, N, D>::operator[](unsigned i) const + complex_psite<D, P>::operator[](unsigned i) const { mln_precondition(is_valid()); return to_point()[i]; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline - face_handle<N, D> - complex_psite<P, N, D>::face() const + any_face_handle<D> + complex_psite<D, P>::face() const { return face_; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline const complex<D>& - complex_psite<P, N, D>::cplx() const + complex_psite<D, P>::cplx() const { return face_.cplx(); } @@ -223,19 +212,19 @@ | Comparisons. | `--------------*/ - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator==(const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs) + operator==(const complex_psite<D, P>& lhs, + const complex_psite<D, P>& rhs) { mln_precondition(&lhs.cplx() == &rhs.cplx()); return lhs.face() == rhs.face(); } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator< (const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs) + operator< (const complex_psite<D, P>& lhs, + const complex_psite<D, P>& rhs) { mln_precondition(&lhs.cplx() == &rhs.cplx()); return lhs.face() < rhs.face(); Index: mln/core/faces_psite.hh --- mln/core/faces_psite.hh (revision 2123) +++ mln/core/faces_psite.hh (working copy) @@ -25,11 +25,12 @@ // 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 +#ifndef MLN_CORE_FACES_PSITE_HH +# define MLN_CORE_FACES_PSITE_HH -/// \file mln/core/complex_psite.hh -/// \brief Definition of a complex-based point site. +/// \file mln/core/faces_psite.hh +/// \brief Definition of a point site based on the n-faces of a +/// complex. # include <mln/core/concept/point_site.hh> @@ -38,21 +39,18 @@ 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. + /// \brief Point site associated to a mln::p_faces. /// - /// \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> > + /// \arg \p D The dimension of the complex this psite belongs to. + /// \arg \p P The type of point associated to this psite. + template <unsigned N, unsigned D, typename P> + class faces_psite : public Point_Site< faces_psite<N, D, P> > { - typedef complex_psite<P, N, D> self_; + typedef faces_psite<N, D, P> self_; typedef Point_Site<self_> super_; public: @@ -64,9 +62,9 @@ /// Construction and assignment. /// \{ - complex_psite(); - complex_psite(const face_handle<N, D>& face); - complex_psite(const self_& rhs); + faces_psite(); + faces_psite(const face_handle<N, D>& face); + faces_psite(const self_& rhs); self_& operator= (const self_& rhs); /// \} @@ -97,7 +95,7 @@ }; - /// Comparison of two instances of mln::complex_psite. + /// Comparison of two instances of mln::faces_psite. /// \{ /* FIXME: Shouldn't those comparisons be part of a much general mechanism? */ @@ -106,10 +104,10 @@ /// /// \pre Arguments \a lhs and \a rhs must belong to the same /// mln::complex. - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator==(const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs); + operator==(const faces_psite<N, D, P>& lhs, + const faces_psite<N, D, P>& rhs); /// \brief Is \a lhs ``less'' than \a rhs? /// @@ -117,19 +115,19 @@ /// /// \pre Arguments \a lhs and \a rhs must belong to the same /// mln::complex. - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator< (const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs); + operator< (const faces_psite<N, D, P>& lhs, + const faces_psite<N, D, P>& rhs); /// \} # ifndef MLN_INCLUDE_ONLY - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline - complex_psite<P, N, D>::complex_psite() + faces_psite<N, D, P>::faces_psite() : super_(), // Dummy initializations. face_(), p_() @@ -138,9 +136,9 @@ metal::bool_< N <= D >::check(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline - complex_psite<P, N, D>::complex_psite(const face_handle<N, D>& face) + faces_psite<N, D, P>::faces_psite(const face_handle<N, D>& face) : super_(), face_(face), p_() { @@ -148,9 +146,9 @@ metal::bool_< N <= D >::check(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline - complex_psite<P, N, D>::complex_psite(const complex_psite<P, N, D>& rhs) + faces_psite<N, D, P>::faces_psite(const faces_psite<N, D, P>& rhs) : super_(rhs), face_(rhs.face_), p_() { @@ -158,10 +156,10 @@ metal::bool_< N <= D >::check(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline - complex_psite<P, N, D>& - complex_psite<P, N, D>::operator= (const complex_psite<P, N, D>& rhs) + faces_psite<N, D, P>& + faces_psite<N, D, P>::operator= (const faces_psite<N, D, P>& rhs) { if (&rhs == this) return *this; @@ -169,52 +167,52 @@ return *this; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline bool - complex_psite<P, N, D>::is_valid() const + faces_psite<N, D, P>::is_valid() const { - return face.is_valid(); + return face_.is_valid(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline - const complex_psite<P, N, D>& - complex_psite<P, N, D>::to_psite() const + const faces_psite<N, D, P>& + faces_psite<N, D, P>::to_psite() const { return *this; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline const P& - complex_psite<P, N, D>::to_point() const + faces_psite<N, D, P>::to_point() const { // FIXME: Dummy value. return p_; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline mln_coord(P) - complex_psite<P, N, D>::operator[](unsigned i) const + faces_psite<N, D, P>::operator[](unsigned i) const { mln_precondition(is_valid()); return to_point()[i]; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline face_handle<N, D> - complex_psite<P, N, D>::face() const + faces_psite<N, D, P>::face() const { return face_; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline const complex<D>& - complex_psite<P, N, D>::cplx() const + faces_psite<N, D, P>::cplx() const { return face_.cplx(); } @@ -223,19 +221,19 @@ | Comparisons. | `--------------*/ - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator==(const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs) + operator==(const faces_psite<N, D, P>& lhs, + const faces_psite<N, D, P>& rhs) { mln_precondition(&lhs.cplx() == &rhs.cplx()); return lhs.face() == rhs.face(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator< (const complex_psite<P, N, D>& lhs, - const complex_psite<P, N, D>& rhs) + operator< (const faces_psite<N, D, P>& lhs, + const faces_psite<N, D, P>& rhs) { mln_precondition(&lhs.cplx() == &rhs.cplx()); return lhs.face() < rhs.face(); @@ -246,4 +244,4 @@ } // end of mln -#endif // MLN_CORE_COMPLEX_PSITE_HH +#endif // MLN_CORE_FACES_PSITE_HH Property changes on: mln/core/faces_psite.hh ___________________________________________________________________ Added: svn:mergeinfo Index: mln/core/p_complex.hh --- mln/core/p_complex.hh (revision 2127) +++ mln/core/p_complex.hh (working copy) @@ -43,12 +43,23 @@ 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> + // FIXME: Rename as p_faces. + + /* FIXME: For compatibility reasons with mln::Point_Set, a point + type \P is attached to this complex-based pset (but it is not + used actually). We should either: + + - use it, and make it mandatory (good solution for the moment); + - use it, and make it optional (better solution, but implies + changes in mln::Point_Set; + - remove it (easy and bad solution). */ + + /// A complex psite set based on a the \N-faces of a complex of + /// dimension \p D (a \p D-complex). + template <unsigned D, typename P> struct p_complex - : public internal::point_set_base_< complex_psite<P, N, D>, - p_complex<P, N, D> > + : public internal::point_set_base_< complex_psite<D, P>, + p_complex<D, P> > { /// \brief Construct a complex psite set from a complex. /// @@ -59,7 +70,7 @@ p_complex (const complex<D>& cplx); /// Point_Site associated type. - typedef complex_psite<P, N, D> psite; + typedef complex_psite<D, P> psite; // FIXME: Fake. typedef void fwd_piter; @@ -94,9 +105,9 @@ /// /// Two mln::p_complex's are considered equal if they share the /// same complex. - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator==(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs); + operator==(const p_complex<D, P>& lhs, const p_complex<D, P>& rhs); /// \brief Inclusion of a mln::p_complex in another one. /// @@ -106,23 +117,20 @@ /// /// \todo Refine this later, when we are able to express subcomplex /// relations. - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator<=(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs); + operator<=(const p_complex<D, P>& lhs, const p_complex<D, P>& rhs); # ifndef MLN_INCLUDE_ONLY - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline - p_complex<P, N, D>::p_complex(const complex<D>& cplx) + p_complex<D, P>::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 a; for (unsigned i = 0; i < npoints(); ++i) @@ -130,35 +138,35 @@ bb_ = a.to_result(); } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline std::size_t - p_complex<P, N, D>::npoints() const + p_complex<D, P>::npoints() const { return nfaces(); } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline std::size_t - p_complex<P, N, D>::nfaces() const + p_complex<D, P>::nfaces() const { - return this->cplx_->template nfaces<N>(); + return cplx_->nfaces(); } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline const box_& - p_complex<P, N, D>::bbox() const + p_complex<D, P>::bbox() const { // FIXME: Dummy value. return bb_; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> inline bool - p_complex<P, N, D>::has(const psite& p) const + p_complex<D, P>::has(const psite& p) const { return // Check whether P's complex is compatible with this pset's complex. @@ -168,25 +176,25 @@ } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> const complex<D>& - p_complex<P, N, D>::cplx() const + p_complex<D, P>::cplx() const { mln_precondition(cplx_); return *cplx_.ptr_; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator==(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs) + operator==(const p_complex<D, P>& lhs, const p_complex<D, P>& rhs) { return lhs.cplx_.ptr_ == rhs.cplx_.ptr_; } - template <typename P, unsigned N, unsigned D> + template <unsigned D, typename P> bool - operator<=(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs) + operator<=(const p_complex<D, P>& lhs, const p_complex<D, P>& rhs) { return lhs == rhs; } Index: mln/core/p_faces.hh --- mln/core/p_faces.hh (revision 2123) +++ mln/core/p_faces.hh (working copy) @@ -25,11 +25,12 @@ // 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 +#ifndef MLN_CORE_P_FACES_HH +# define MLN_CORE_P_FACES_HH -/// \file mln/core/p_complex.hh -/// \brief Definition of a point set based on a complex. +/// \file mln/core/p_faces.hh +/// \brief Definition of a point set based on the set of n-faces of a +/// complex. # include <mln/core/internal/point_set_base.hh> @@ -37,18 +38,27 @@ # include <mln/util/tracked_ptr.hh> # include <mln/core/complex.hh> -# include <mln/core/complex_psite.hh> +# include <mln/core/faces_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> > + /* FIXME: For compatibility reasons with mln::Point_Set, a point + type \P is attached to this complex-based pset (but it is not + used actually). We should either: + + - use it, and make it mandatory (good solution for the moment); + - use it, and make it optional (better solution, but implies + changes in mln::Point_Set; + - remove it (easy and bad solution). */ + + /// A complex psite set based on a the \N-faces of a complex of + /// dimension \p D (a \p D-complex). + template <unsigned N, unsigned D, typename P> + struct p_faces + : public internal::point_set_base_< faces_psite<N, D, P>, + p_faces<N, D, P> > { /// \brief Construct a complex psite set from a complex. /// @@ -56,10 +66,10 @@ /// /// \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); + p_faces (const complex<D>& cplx); /// Point_Site associated type. - typedef complex_psite<P, N, D> psite; + typedef faces_psite<N, D, P> psite; // FIXME: Fake. typedef void fwd_piter; @@ -79,7 +89,7 @@ bool has(const psite& p) const; - /// Return the complex associated to the p_complex domain. + /// Return the complex associated to the p_faces domain. const complex<D>& cplx() const; private: @@ -90,33 +100,33 @@ }; - /// \brief Comparison between two mln::p_complex's. + /// \brief Comparison between two mln::p_faces's. /// - /// Two mln::p_complex's are considered equal if they share the + /// Two mln::p_faces's are considered equal if they share the /// same complex. - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator==(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs); + operator==(const p_faces<N, D, P>& lhs, const p_faces<N, D, P>& rhs); - /// \brief Inclusion of a mln::p_complex in another one. + /// \brief Inclusion of a mln::p_faces 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 + /// infrastrure for complexs is simple: a mln::p_faces 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> + template <unsigned N, unsigned D, typename P> bool - operator<=(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs); + operator<=(const p_faces<N, D, P>& lhs, const p_faces<N, D, P>& rhs); # ifndef MLN_INCLUDE_ONLY - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline - p_complex<P, N, D>::p_complex(const complex<D>& cplx) + p_faces<N, D, P>::p_faces(const complex<D>& cplx) // Create a deep, managed copy of CPLX. : cplx_(new complex<D>(cplx)) { @@ -130,35 +140,35 @@ bb_ = a.to_result(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline std::size_t - p_complex<P, N, D>::npoints() const + p_faces<N, D, P>::npoints() const { return nfaces(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline std::size_t - p_complex<P, N, D>::nfaces() const + p_faces<N, D, P>::nfaces() const { - return this->cplx_->template nfaces<N>(); + return cplx_->template nfaces<N>(); } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline const box_& - p_complex<P, N, D>::bbox() const + p_faces<N, D, P>::bbox() const { // FIXME: Dummy value. return bb_; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> inline bool - p_complex<P, N, D>::has(const psite& p) const + p_faces<N, D, P>::has(const psite& p) const { return // Check whether P's complex is compatible with this pset's complex. @@ -168,25 +178,25 @@ } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> const complex<D>& - p_complex<P, N, D>::cplx() const + p_faces<N, D, P>::cplx() const { mln_precondition(cplx_); return *cplx_.ptr_; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator==(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs) + operator==(const p_faces<N, D, P>& lhs, const p_faces<N, D, P>& rhs) { return lhs.cplx_.ptr_ == rhs.cplx_.ptr_; } - template <typename P, unsigned N, unsigned D> + template <unsigned N, unsigned D, typename P> bool - operator<=(const p_complex<P, N, D>& lhs, const p_complex<P, N, D>& rhs) + operator<=(const p_faces<N, D, P>& lhs, const p_faces<N, D, P>& rhs) { return lhs == rhs; } @@ -196,4 +206,4 @@ } // end of mln -#endif // MLN_CORE_P_COMPLEX_HH +#endif // MLN_CORE_P_FACES_HH

16 years, 5 months

2126: Add a dimension-agnostic face handle.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add a dimension-agnostic face handle. * mln/core/face.hh (mln::any_face_handle<D>): New class. (operator==(const any_face_handle<D>&, const any_face_handle<D>&)) (operator< (const any_face_handle<D>&, const any_face_handle<D>&)): New. (mln::face_handle<N, D>::face_handle): Use std::numeric_limits instead of UINT_MAX. face.hh | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 190 insertions(+), 4 deletions(-) Index: mln/core/face.hh --- mln/core/face.hh (revision 2126) +++ mln/core/face.hh (working copy) @@ -31,12 +31,24 @@ /// \file mln/core/face.hh /// \brief Face of a complex. -#include <climits> +#include <limits> #include <vector> #include <mln/core/contract.hh> +/* FIXME: Suggestions: + + - rename `face' as `face_data', and move it into complex.hh or its + own file; + - rename `face_handle' as `face', and move it to its own file; + - rename `any_face_handle' as `any_face', and move it to its own file. + + Anyway, whatever the decision, splitting `face', `face_handle' and + `any_face_handle' seems to be sound. + + (And what about `faces_set'? Should we move it to its own file as + well?) */ namespace mln { @@ -58,8 +70,6 @@ } - // FIXME: Rename `face' as `face_data' and `face_handle' as face. - /*-------. | Face. | `-------*/ @@ -234,6 +244,78 @@ /// \} + /*----------------------. + | ``Any-face'' handle. | + `----------------------*/ + + // Face handle in a complex, where the dimension is dynamic. + template <unsigned D> + struct any_face_handle + { + /// Build a non-initialized face handle. + any_face_handle(); + /// Build a face handle from \a complex and \a face_id. + any_face_handle(complex<D>& complex, unsigned n, unsigned face_id); + + /// Copy and assignment. + /// \{ + any_face_handle(const any_face_handle<D>& rhs); + any_face_handle<D>& operator=(const any_face_handle<D>& rhs); + /// \} + + /// Is this handle valid? + bool is_valid() const; + + /// Accessors. + /// \{ + /// Return the complex the face belongs to. + complex<D>& cplx() const; + /// Return the dimension of the face. + unsigned n() const; + /// Return the id of the face. + unsigned face_id() const; + + // FIXME: Implement. +// /// Return the mln::face pointed by this handle. +// template <unsigned N> +// face<N, D>& to_face() const; + /// \} + + private: + /// \brief The complex the face belongs to. + /// + /// A const any_face_handle can be used to modify a complex. + mutable complex<D>* cplx_; + /// The dimension of the face. + unsigned n_; + /// \brief The id of the face. + unsigned face_id_; + }; + + + /// Comparison of two instances of mln::any_face_handle. + /// \{ + /// \brief Is \a lhs equal to \a rhs? + /// + /// \pre Arguments \a lhs and \a rhs must belong to the same + /// mln::complex. + template <unsigned D> + bool + operator==(const any_face_handle<D>& lhs, const any_face_handle<D>& rhs); + + /// \brief Is \a lhs ``less'' than \a rhs? + /// + /// This comparison is required by algorithms sorting face handles. + /// + /// \pre Arguments \a lhs and \a rhs must belong to the same + /// mln::complex. + /// \pre Arguments \a lhs and \a rhs must have the same dimension. + template <unsigned D> + bool + operator< (const any_face_handle<D>& lhs, const any_face_handle<D>& rhs); + /// \} + + # ifndef MLN_INCLUDE_ONLY @@ -266,7 +348,7 @@ template <unsigned N, unsigned D> face_handle<N, D>::face_handle() - : cplx_(0), face_id_(UINT_MAX) + : cplx_(0), face_id_(std::numeric_limits<unsigned>::max()) { // Ensure N is compatible with D. metal::bool_< N <= D >::check(); @@ -342,6 +424,7 @@ bool operator==(const face_handle<N, D>& lhs, const face_handle<N, D>& rhs) { + // Ensure LHS and RHS belong to the same complex. mln_precondition(&lhs.face.cplx() == &rhs.face.cplx()); return lhs.face().id() == rhs.face().id(); } @@ -350,6 +433,7 @@ bool operator< (const face_handle<N, D>& lhs, const face_handle<N, D>& rhs) { + // Ensure LHS and RHS belong to the same complex. mln_precondition(&lhs.face.cplx() == &rhs.face.cplx()); return lhs.face().id() < rhs.face().id(); } @@ -396,6 +480,108 @@ return fs2; } + + /*----------------------. + | ``Any-face'' handle. | + `----------------------*/ + + template <unsigned D> + any_face_handle<D>::any_face_handle() + : cplx_(0), + n_(std::numeric_limits<unsigned>::max()), + face_id_(std::numeric_limits<unsigned>::max()) + { + } + + template <unsigned D> + any_face_handle<D>::any_face_handle(complex<D>& c, unsigned n, + unsigned face_id) + : cplx_(&c), n_(n), face_id_(face_id) + { + // Ensure N is compatible with D. + } + + template <unsigned D> + any_face_handle<D>::any_face_handle(const any_face_handle<D>& rhs) + : cplx_(rhs.cplx_), face_id_(rhs.face_id_) + { + } + + template <unsigned D> + any_face_handle<D>& + any_face_handle<D>::operator=(const any_face_handle<D>& rhs) + { + if (&rhs != this) + { + cplx_ = rhs.cplx_; + n_ = rhs.n_; + face_id_ = rhs.face_id_; + } + return *this; + } + + template <unsigned D> + bool + any_face_handle<D>::is_valid() const + { + return cplx_ != 0 && face_id_ < cplx_->nfaces(n_); + } + + template <unsigned D> + complex<D>& + any_face_handle<D>::cplx() const + { + mln_precondition(cplx_); + return *cplx_; + } + + template <unsigned D> + unsigned + any_face_handle<D>::n() const + { + return n_; + } + + template <unsigned D> + unsigned + any_face_handle<D>::face_id() const + { + return face_id_; + } + +// template <unsigned D> +// template <unsigned n> +// face<N, D>& +// any_face_handle<D>::to_face() const +// { +// // FIXME: Adjust. +// // mln_precondition(is_valid()); +// // return cplx_->template face_<N>(face_id_); +// } + + + template <unsigned D> + bool + operator==(const any_face_handle<D>& lhs, const any_face_handle<D>& rhs) + { + // Ensure LHS and RHS belong to the same complex. + mln_precondition(&lhs.face.cplx() == &rhs.face.cplx()); + return + lhs.face().n() == rhs.face().n() && + lhs.face().id() == rhs.face().id(); + } + + template <unsigned D> + bool + operator< (const any_face_handle<D>& lhs, const any_face_handle<D>& rhs) + { + // Ensure LHS and RHS belong to the same complex. + mln_precondition(&lhs.face.cplx() == &rhs.face.cplx()); + // Ensure LHS and RHS have the same dimension. + mln_precondition(lhs.face().n() == rhs.face().n()); + return lhs.face().id() < rhs.face().id(); + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln

16 years, 5 months

2125: Add more services to complexes.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add more services to complexes. * mln/core/complex.hh (mln::complex<D>::nfaces()) (mln::complex<D>::nfaces(unsigned)): New methods. (mln::complex<D>::fold_left_) (mln::complex<D>::apply_if_dim_matches_) (mln::internal::faces_set_mixin<N, D>::fold_left_): (mln::internal::faces_set_mixin<N, D>::apply_if_dim_matches_): New methods. (mln::internal::add_size) (mln::internal::get_size): New meta-functors. complex.hh | 323 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 316 insertions(+), 7 deletions(-) Index: mln/core/complex.hh --- mln/core/complex.hh (revision 2125) +++ mln/core/complex.hh (working copy) @@ -38,6 +38,7 @@ # include <cstddef> +# include <limits> # include <iosfwd> # include <mln/metal/bool.hh> @@ -67,7 +68,6 @@ public: /// Complex construction. /// \{ - /// \brief Add a 0-face to the complex. face_handle<0u, D> add_face(); @@ -79,9 +79,31 @@ face_handle<N + 1, D> add_face(const faces_set<N, D>& adjacent_faces); /// \} + /// \brief Static manipulators. + /// + /// These methods use statically-known input. + /// \{ + /// \brief Return the total number of faces, whatever their + /// dimension. + std::size_t nfaces() const; + /// \brief Return the number of \p N-faces. template <unsigned N> std::size_t nfaces() const; + /// \} + + /// \brief Dynamic manipulators. + /// + /// These methods use input know as run time. + /// \{ + /// \brief Return the number of \a n-faces. + /// + /// Warning, this function has a complexity linear in term of N, + /// since each faces_set is checked (the present implementation + /// does not provide a direct access to faces_set through a + /// dynamic value of the dimension). + std::size_t nfaces(unsigned n) const; + /// \} /// Pretty-printing. /// \{ @@ -104,6 +126,32 @@ const face<N, D>& face_(unsigned face_id) const; /// \} + /// Functional meta-manipulators. + /// \{ + /* FIXME: Use something more constraining than the STL's + UnaryFunction/BinaryFunction. Use Function or Function_v2v? + Or a new subclass of Function? */ + + /* FIXME: Replace F and ACCU by a Milena accumulator? */ + + /** \brief Apply a kind of static fold left operator to the + implicit list of faces_set using a functor \a f and a value \a + accu. + + Argument \a is called an "accumulator", but with a slightly + different meaning than mln:accu members. + + We might want to use TypeLists or something similar, is they + provide an explicit static fold left operator. */ + template <typename BinaryFunction, typename T> + T fold_left_(const BinaryFunction& f, const T& accu) const; + + /// \brief Apply a functor \a f to this list of \a n-faces. + template <typename UnaryFunction> + typename UnaryFunction::result_type + apply_if_dim_matches_(unsigned n, const UnaryFunction& f) const; + /// \} + /// \brief connect two faces. /// /// \param f1 A face of dimension \p N @@ -146,8 +194,8 @@ /// Faces of highest dimension (\p D). template <unsigned D> - struct faces_set_mixin<D, D> : faces_set_mixin<D - 1, D>, - lower_dim_faces_set_mixin<D, D> + struct faces_set_mixin<D, D> : public faces_set_mixin<D - 1, D>, + public lower_dim_faces_set_mixin<D, D> { std::vector< face<D, D> > faces_; @@ -157,13 +205,26 @@ void print(std::ostream& ostr) const; void print_rec_asc(std::ostream& ostr) const; /// \} + + /// Functional meta-manipulators. + /// \{ + /// \brief Fold left. + /// \see mln::complex<D>::fold_left_. + template <typename BinaryFunction, typename T> + T fold_left_(const BinaryFunction& f, const T& accu) const; + /// \brief Apply a functor \a f to the list of faces if \a n == \p D. + /// \see mln::complex<D>::apply_if_dim_matches_. + template <typename UnaryFunction> + typename UnaryFunction::result_type + apply_if_dim_matches_(unsigned n, const UnaryFunction& f) const; + /// \} }; /// Faces of intermediate dimension (greater than 0, lower than \p D). template <unsigned N, unsigned D> - struct faces_set_mixin : faces_set_mixin<N - 1, D>, - lower_dim_faces_set_mixin<N, D>, - higher_dim_faces_set_mixin<N, D> + struct faces_set_mixin : public faces_set_mixin<N - 1, D>, + public lower_dim_faces_set_mixin<N, D>, + public higher_dim_faces_set_mixin<N, D> { std::vector< face<N, D> > faces_; @@ -175,11 +236,24 @@ /// (in ascending dimension). void print_rec_asc(std::ostream& ostr) const; /// \} + + /// Functional meta-manipulators. + /// \{ + /// \brief Fold left. + /// \see mln::complex<D>::fold_left_. + template <typename BinaryFunction, typename T> + T fold_left_(const BinaryFunction& f, const T& accu) const; + /// \brief Apply a functor \a f to the list of faces if \a n == \p N. + /// \see mln::complex<D>::apply_if_dim_matches_. + template <typename UnaryFunction> + typename UnaryFunction::result_type + apply_if_dim_matches_(unsigned n, const UnaryFunction& f) const; + /// \} }; /// Faces of lowest dimension (0). template <unsigned D> - struct faces_set_mixin<0u, D> : higher_dim_faces_set_mixin<0u, D> + struct faces_set_mixin<0u, D> : public higher_dim_faces_set_mixin<0u, D> { std::vector< face<0u, D> > faces_; @@ -189,6 +263,19 @@ void print(std::ostream& ostr) const; void print_rec_asc(std::ostream& ostr) const; /// \} + + /// Functional meta-manipulators. + /// \{ + /// \brief Fold left. + /// \see mln::complex<D>::fold_left_. + template <typename BinaryFunction, typename T> + T fold_left_(const BinaryFunction& f, const T& accu) const; + /// \brief Apply a functor \a f to the list of faces if \a n == 0. + /// \see mln::complex<D>::apply_if_dim_matches_. + template <typename UnaryFunction> + typename UnaryFunction::result_type + apply_if_dim_matches_(unsigned n, const UnaryFunction& f) const; + /// \} }; /// Faces of a 0-complex. @@ -203,6 +290,19 @@ void print(std::ostream& ostr) const; void print_rec_asc(std::ostream& ostr) const; /// \} + + /// Functional meta-manipulators. + /// \{ + /// \brief Fold left. + /// \see mln::complex<D>::fold_left_. + template <typename BinaryFunction, typename T> + T fold_left_(const BinaryFunction& f, const T& accu) const; + /// \brief Apply a functor \a f to the list of faces if \a n == 0. + /// \see mln::complex<D>::apply_if_dim_matches_. + template <typename UnaryFunction> + typename UnaryFunction::result_type + apply_if_dim_matches_(unsigned n, const UnaryFunction& f) const; + /// \} }; /// \} @@ -233,6 +333,10 @@ # ifndef MLN_INCLUDE_ONLY + /*-----------------------. + | Complex construction. | + `-----------------------*/ + template <unsigned D> face_handle<0u, D> complex<D>::add_face() @@ -278,6 +382,64 @@ return fh; } + + /*-------. + | Misc. | + `-------*/ + + namespace internal + { + + /// A binary meta-functor defined by: + /// + /// \code + /// add_size : x, c -> x + c.size() + /// \endcode + /// + /// \see mln::complex<D>::nfaces (static version). + /// \see mln::complex<D>::fold_left_. + struct add_size + { + template <typename T, typename Container> + T operator()(const T& x, const Container& c) const + { + return x + c.size(); + } + }; + + /// An unary meta-functor defined by: + /// + /// \code + /// add_size : c -> c.size() + /// \endcode + /// + /// \see mln::complex<D>::nfaces (dynamic version). + /// \see mln::complex<D>::apply_if_dim_matches_. + struct get_size + { + typedef std::size_t result_type; + + template <typename Container> + typename Container::size_type operator()(const Container& c) const + { + return c.size(); + } + }; + + } // end of namespace mln::internal + + + /*----------------------. + | Static manipulators. | + `----------------------*/ + + template <unsigned D> + std::size_t + complex<D>::nfaces() const + { + return fold_left_(internal::add_size(), 0); + } + template <unsigned D> template <unsigned N> std::size_t @@ -286,6 +448,25 @@ return internal::faces_set_mixin<N, D>::faces_.size(); } + + /*-----------------------. + | Dynamic manipulators. | + `-----------------------*/ + + template <unsigned D> + std::size_t + complex<D>::nfaces(unsigned n) const + { + // Ensure N is compatible with D. + mln_precondition(n <= D); + return apply_if_dim_matches_(n, internal::get_size()); + } + + + /*-------------------. + | Internal methods. | + `-------------------*/ + template <unsigned D> template <unsigned N> face<N, D>& @@ -462,6 +643,134 @@ } // end of namespace mln::internal + + /*-------------------------------. + | Functional meta-manipulators. | + `-------------------------------*/ + + /* ------------------------------- */ + /* ``Static Fold Left'' Operator. */ + /* ------------------------------- */ + + template <unsigned D> + template <typename BinaryFunction, typename T> + T + complex<D>::fold_left_(const BinaryFunction& f, const T& accu) const + { + return internal::faces_set_mixin<D, D>::fold_left_(f, accu); + } + + namespace internal + { + + // FIXME: Try to factor. + + template <unsigned D> + template <typename BinaryFunction, typename T> + T + faces_set_mixin<D, D>::fold_left_(const BinaryFunction& f, + const T& accu) const + { + return faces_set_mixin<D - 1, D>::fold_left_(f, f(accu, faces_)); + } + + template <unsigned N, unsigned D> + template <typename BinaryFunction, typename T> + T + faces_set_mixin<N, D>::fold_left_(const BinaryFunction& f, + const T& accu) const + { + return faces_set_mixin<N - 1, D>::fold_left_(f, f(accu, faces_)); + } + + template <unsigned D> + template <typename BinaryFunction, typename T> + T + faces_set_mixin<0u, D>::fold_left_(const BinaryFunction& f, + const T& accu) const + { + return f(accu, faces_); + } + + template <typename BinaryFunction, typename T> + T + faces_set_mixin<0u, 0u>::fold_left_(const BinaryFunction& f, + const T& accu) const + { + return f(accu, faces_); + } + + } // end of namespace mln::internal + + + /* ------------------------------------------------ */ + /* ``Static Apply-If-Dimension-Matches'' Operator. */ + /* ------------------------------------------------ */ + + template <unsigned D> + template <typename UnaryFunction> + typename UnaryFunction::result_type + complex<D>::apply_if_dim_matches_(unsigned n, const UnaryFunction& f) const + { + // Ensure N is compatible with D. + mln_precondition(n <= D); + return internal::faces_set_mixin<D, D>::apply_if_dim_matches_(n, f); + } + + namespace internal + { + + // FIXME: Try to factor. + + template <unsigned D> + template <typename UnaryFunction> + typename UnaryFunction::result_type + faces_set_mixin<D, D>::apply_if_dim_matches_(unsigned n, + const UnaryFunction& f) const + { + // Ensure N and D are compatible. + mln_precondition(n <= D); + return n == D ? + f(faces_) : + faces_set_mixin<D - 1, D>::apply_if_dim_matches_(n, f); + } + + template <unsigned N, unsigned D> + template <typename UnaryFunction> + typename UnaryFunction::result_type + faces_set_mixin<N, D>::apply_if_dim_matches_(unsigned n, + const UnaryFunction& f) const + { + // Ensure N and D are compatible. + mln_precondition(n <= D); + return n == N ? + f(faces_) : + faces_set_mixin<N - 1, D>::apply_if_dim_matches_(n, f); + } + + template <unsigned D> + template <typename UnaryFunction> + typename UnaryFunction::result_type + faces_set_mixin<0u, D>::apply_if_dim_matches_(unsigned n, + const UnaryFunction& f) const + { + // If we reached this method, then N should be 0. + mln_precondition(n == 0); + return f(faces_); + } + + template <typename UnaryFunction> + typename UnaryFunction::result_type + faces_set_mixin<0u, 0u>::apply_if_dim_matches_(unsigned n, + const UnaryFunction& f) const + { + // If we reached this method, then N should be 0. + mln_precondition(n == 0); + return f(faces_); + } + + } // end of namespace mln::internal + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln

16 years, 5 months

2124: Follow g++ 4.3 advice w.r.t. ignored type qualifiers on return types.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Follow g++ 4.3 advice w.r.t. ignored type qualifiers on function return types. * mln/util/tracked_ptr.hh (mln::util::tracked_ptr<T>::operator->() const) (mln::util::tracked_ptr<T>::operator->()): Remove useless `const' qualifier on return type. * mln/value/builtin/floatings.hh (mln::trait::value_<float>::min) (mln::trait::value_<float>::max) (mln::trait::value_<float>::epsilon) (mln::trait::value_<double>::min) (mln::trait::value_<double>::max) (mln::trait::value_<double>::epsilon): Likewise. util/tracked_ptr.hh | 8 ++++---- value/builtin/floatings.hh | 12 ++++++------ 2 files changed, 10 insertions(+), 10 deletions(-) Index: mln/util/tracked_ptr.hh --- mln/util/tracked_ptr.hh (revision 2124) +++ mln/util/tracked_ptr.hh (working copy) @@ -67,13 +67,13 @@ ** ** \invariant Pointer proxy exists. */ - const T*const operator->() const; + const T* operator->() const; /*! \brief Mimics the behavior of op-> for a pointer in the mutable case. ** ** \invariant Pointer proxy exists. */ - T*const operator->(); + T* operator->(); /// Ctor. tracked_ptr(); @@ -127,7 +127,7 @@ ** \invariant Pointer proxy exists. */ inline - const T*const tracked_ptr<T>::operator->() const + const T* tracked_ptr<T>::operator->() const { mln_invariant(run_()); mln_precondition(ptr_ != 0); @@ -140,7 +140,7 @@ ** \invariant Pointer proxy exists. */ inline - T*const tracked_ptr<T>::operator->() + T* tracked_ptr<T>::operator->() { mln_invariant(run_()); mln_precondition(ptr_ != 0); Index: mln/value/builtin/floatings.hh --- mln/value/builtin/floatings.hh (revision 2124) +++ mln/value/builtin/floatings.hh (working copy) @@ -74,17 +74,17 @@ typedef value::kind::data kind; typedef value::quant::high quant; - static const float min() + static float min() { static const float min_ = std::numeric_limits<float>::min(); return min_; } - static const float max() + static float max() { static const float max_ = std::numeric_limits<float>::max(); return max_; } - static const float epsilon() + static float epsilon() { static const float epsilon_ = std::numeric_limits<float>::epsilon(); return epsilon_; @@ -105,17 +105,17 @@ typedef value::kind::data kind; typedef value::quant::high quant; - static const double min() + static double min() { static const double min_ = std::numeric_limits<double>::min(); return min_; } - static const double max() + static double max() { static const double max_ = std::numeric_limits<double>::max(); return max_; } - static const double epsilon() + static double epsilon() { static const double epsilon_ = std::numeric_limits<double>::epsilon(); return epsilon_;

16 years, 5 months

Re: [Olena-patches] [Olena] #3: Migrate Olena 0.11 (and previous revisions) from PRCS to Subversion

by Olena

#3: Migrate Olena 0.11 (and previous revisions) from PRCS to Subversion --------------------------+------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: enhancement | Status: assigned Priority: blocker | Milestone: Olena 0.11.1 Component: other | Version: 0.11 Resolution: | Keywords: prcs subversion svn --------------------------+------------------------------------------------- Old description: > '''No further development should be done on the 0.11 branch until this > task is either fixed or removed.''' > > This task is an open discussion. I haven't much tried to convert the > PRCS Olena repository to a Subversion one, and I think '''is''' really > feasible, though not trivial. If you're interested in this migration, > please ask me (Roland) first before making actual changes to the PRCS or > the SVN repository. New description: '''No further development should be done on the 0.11 branch until this task is either fixed or removed.''' This task is an open discussion. I haven't much tried to convert the PRCS Olena repository to a Subversion one, and I think it '''is''' really feasible, though not trivial. If you're interested in this migration, please ask me (Roland) first before making actual changes to the PRCS or the SVN repository. Comment (by levill_r): Missing word in description. -- Ticket URL: <https://trac.lrde.org/olena/ticket/3#comment:5> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 5 months

2124: Fix duplicate entry in ChangeLog

by Roland Levillain

Ach! URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog =================================================================== --- ChangeLog (revision 2123) +++ ChangeLog (revision 2124) @@ -10,14 +10,6 @@ 2008-08-06 Roland Levillain <roland(a)lrde.epita.fr> - * mln/core/graph_psite.hh, mln/core/line_graph_psite.hh, - * mln/core/p_graph_piter.hh, mln/core/p_line_graph_piter.hh: - Fix spacing in template definitions. - * mln/core/p_graph.hh, mln/core/p_line_graph.hh: Likewise. - Fix documentation. - -2008-08-06 Roland Levillain <roland(a)lrde.epita.fr> - Add complex-based psite and pset. * mln/core/complex_psite.hh, mln/core/p_complex.hh: New.

16 years, 5 months

2123: Misc. fixes in graph and line graph entities.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Misc. fixes in graph and line graph entities. * mln/core/graph_psite.hh, mln/core/line_graph_psite.hh, * mln/core/p_graph_piter.hh, mln/core/p_line_graph_piter.hh: Fix spacing in template definitions. * mln/core/p_graph.hh, mln/core/p_line_graph.hh: Likewise. Fix documentation. graph_psite.hh | 5 ++++- p_graph.hh | 22 ++++++++++++++-------- p_line_graph.hh | 10 ++++++---- 3 files changed, 24 insertions(+), 13 deletions(-) Index: mln/core/line_graph_psite.hh Index: mln/core/p_graph_piter.hh Index: mln/core/p_line_graph.hh --- mln/core/p_line_graph.hh (revision 2122) +++ mln/core/p_line_graph.hh (working copy) @@ -74,12 +74,14 @@ /// Backward Point_Iterator associated type. typedef p_line_graph_bkd_piter_ bkd_piter; - /// Return The number of points (sites) of the set, i.e., the - /// number of \em edges, since this is a point set based on a line - /// graph. + /// \brief Return The number of points (sites) of the set, i.e., + /// the number of \em edges, since this is a point set based on a + /// line graph. + /// + /// Required by the mln::Point_Set concept. std::size_t npoints() const; - /// Return The number of vertices (vertices) in the graph. + /// Return The number of vertices in the graph. std::size_t nvertices() const; /// Return The number of edges in the graph. std::size_t nedges() const; Index: mln/core/p_line_graph_piter.hh Index: mln/core/graph_psite.hh --- mln/core/graph_psite.hh (revision 2122) +++ mln/core/graph_psite.hh (working copy) @@ -31,13 +31,15 @@ /// \file mln/core/graph_psite.hh /// \brief Definition of a graph-based point site. +# include <mln/core/concept/point_site.hh> + # include <mln/core/p_graph.hh> namespace mln { - // Fwd decl. + // Forward declaration. template<typename P> class p_graph; @@ -113,6 +115,7 @@ /// \} + # ifndef MLN_INCLUDE_ONLY template<typename P> Index: mln/core/p_graph.hh --- mln/core/p_graph.hh (revision 2122) +++ mln/core/p_graph.hh (working copy) @@ -28,16 +28,18 @@ #ifndef MLN_CORE_P_GRAPH_HH # define MLN_CORE_P_GRAPH_HH -# include <mln/core/concept/point_site.hh> +/// \file mln/core/p_graph.hh +/// \brief Definition of a point set based on graph. + # include <mln/core/internal/point_set_base.hh> + # include <mln/accu/bbox.hh> # include <mln/util/tracked_ptr.hh> # include <mln/util/graph.hh> + # include <mln/core/graph_psite.hh> # include <mln/core/p_graph_piter.hh> -/// \file mln/core/p_graph.hh -/// \brief Definition of a point set based on graph. namespace mln { @@ -68,11 +70,13 @@ /// Backward Point_Iterator associated type. typedef p_graph_bkd_piter_ bkd_piter; - /// Return The number of points (sites) of the set, i.e., the - /// number of \em vertices. + /// \brief Return The number of points (sites) of the set, i.e., + /// the number of \em vertices. + /// + /// Required by the mln::Point_Set concept. std::size_t npoints() const; - /// Return The number of vertices (vertices) in the graph. + /// Return The number of vertices in the graph. std::size_t nvertices() const; /// Return The number of edges in the graph. std::size_t nedges() const; @@ -110,7 +114,8 @@ const util::vertex_id& rhs) const; /// \} - /// Return the graph associated to the p_graph domain: + /// Return the graph associated to the p_graph domain. + // FIXME: Rename as something else (graph() ?). const graph& to_graph() const; graph& to_graph(); @@ -138,7 +143,7 @@ /// \brief Inclusion of a mln::p_graph in another one. /// /// This inclusion relation is very strict for the moment, since our - /// infrastrure for graphs i simple: a mln::p_graph is included + /// infrastrure for graphs is simple: a mln::p_graph is included /// in another one if their are equal. /// /// \todo Refine this later, when we are able to express subgraph @@ -148,6 +153,7 @@ operator<=(const p_graph& lhs, const p_graph& rhs); + # ifndef MLN_INCLUDE_ONLY template<typename P>

16 years, 5 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches