https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud &lt;thierry.geraud(a)lrde.epita.fr&gt; Update some classes with literals and precise int_u equiv. * mln/literal/ops.hh: New. * mln/literal/one.hh: New. * mln/literal/all.hh: New. * mln/value/int_u.hh: Update so that the equivalent type really is 'unsigned'. * mln/debug/all.hh: Clean-up. * mln/core/point.hh, * mln/core/window.hh, * mln/core/neighb.hh, * mln/core/dpoint.hh: New ctor overloads for coordinates. * mln/core/ops.hh (operator+, operator*): New overloads for unsigned. (operator++, operator--): New FIXMEs. * mln/core/concept/function.hh: New categories for sub-concepts of Function. * mln/core/concept/window.hh, * mln/metal/vec.hh, * mln/value/cast.hh, * mln/value/internal/value_like.hh, * mln/make/w_window.hh, * mln/test/positive.hh, * mln/convert/to_image.hh, * mln/convert/to_std_set.hh, * mln/convert/to_window.hh, * mln/convert/to_dpoint.hh, * mln/convert/to_w_window.hh, * mln/geom/bbox.hh, * mln/geom/shift.hh, * mln/fun/v2v/saturate.hh, * mln/win/octagon2d.hh, * mln/morpho/hit_or_miss.hh, * mln/norm/infty.hh, * mln/norm/l2.hh, * tests/window1d.cc, * tests/morpho_dilation_max_h.cc, * tests/morpho_erosion_min_h.cc, * tests/dpoint2d.cc, * tests/literal_zero.cc, * tests/labeling_foreground.cc, * tests/point1d.cc, * tests/window2d.cc, * tests/labeling_estimate.cc, * tests/dpoint1d.cc, * tests/dpoint3d.cc, * tests/value_int_u8.cc, * tests/point2d.cc: Update. * TODO: Clear. TODO | 9 +-- mln/convert/to_dpoint.hh | 2 mln/convert/to_image.hh | 4 - mln/convert/to_std_set.hh | 4 - mln/convert/to_w_window.hh | 2 mln/convert/to_window.hh | 12 ++--- mln/core/concept/function.hh | 41 +++++++++++++++++ mln/core/concept/window.hh | 4 - mln/core/dpoint.hh | 65 +++++++++++++++++++++++----- mln/core/neighb.hh | 44 ++++++++++++++++++- mln/core/ops.hh | 20 ++++++++ mln/core/point.hh | 37 ++++++++++++++-- mln/core/window.hh | 42 ++++++++++++++++++ mln/debug/all.hh | 6 +- mln/fun/v2v/saturate.hh | 12 +++-- mln/geom/bbox.hh | 2 mln/geom/shift.hh | 2 mln/literal/all.hh | 58 +++++++++++++++++++++++++ mln/literal/one.hh | 76 +++++++++++++++++++++++++++++++++ mln/literal/ops.hh | 89 +++++++++++++++++++++++++++++++++++++++ mln/make/w_window.hh | 4 - mln/metal/vec.hh | 17 +++++-- mln/morpho/hit_or_miss.hh | 3 + mln/norm/infty.hh | 27 +++++++++-- mln/norm/l2.hh | 3 + mln/test/positive.hh | 7 ++- mln/value/cast.hh | 2 mln/value/int_u.hh | 70 ++++++++++++++++++++++++++++-- mln/value/internal/value_like.hh | 2 mln/win/octagon2d.hh | 33 +++++++------- tests/dpoint1d.cc | 4 - tests/dpoint2d.cc | 4 - tests/dpoint3d.cc | 4 - tests/labeling_estimate.cc | 3 - tests/labeling_foreground.cc | 2 tests/literal_zero.cc | 11 ++++ tests/morpho_dilation_max_h.cc | 2 tests/morpho_erosion_min_h.cc | 2 tests/point1d.cc | 3 + tests/point2d.cc | 7 +++ tests/value_int_u8.cc | 7 ++- tests/window1d.cc | 6 +- tests/window2d.cc | 4 - 43 files changed, 661 insertions(+), 97 deletions(-) Index: tests/window1d.cc --- tests/window1d.cc (revision 1303) +++ tests/window1d.cc (working copy) @@ -46,8 +46,10 @@ mln_assertion(w.is_centered() = false); mln_assertion(w.is_symmetric() = true); - w.insert(make::dpoint1d(-1)); - w.insert(make::dpoint1d( 1)); + // w.insert(-1,0); // Do not compile as expected. + + w.insert(-1); + w.insert( 1); image1d<bool> ima = convert::to_image(w); debug::println(ima); Index: tests/morpho_dilation_max_h.cc --- tests/morpho_dilation_max_h.cc (revision 1303) +++ tests/morpho_dilation_max_h.cc (working copy) @@ -55,7 +55,7 @@ image2d<int_u8> lena = io::pgm::load("../img/lena.pgm"); { - vec_p<point2d> vec = convert::to_vec_p(rec, point2d::zero); + vec_p<point2d> vec = convert::to_vec_p(rec, point2d::origin); window2d win = convert::to_window(vec); image2d<int_u8> out(lena.domain()); Index: tests/morpho_erosion_min_h.cc --- tests/morpho_erosion_min_h.cc (revision 1303) +++ tests/morpho_erosion_min_h.cc (working copy) @@ -55,7 +55,7 @@ image2d<int_u8> lena = io::pgm::load("../img/lena.pgm"); { - vec_p<point2d> vec = convert::to_vec_p(rec, point2d::zero); + vec_p<point2d> vec = convert::to_vec_p(rec, point2d::origin); window2d win = convert::to_window(vec); image2d<int_u8> out(lena.domain()); Index: tests/dpoint2d.cc --- tests/dpoint2d.cc (revision 1303) +++ tests/dpoint2d.cc (working copy) @@ -48,8 +48,8 @@ mln_assertion(dp = q - p); mln_assertion(q = p + dp); - const int (&vec)[2] = dp.to_vec(); - mln_assertion(vec[0] = 3); + metal::vec<2, float> v = dp; + mln_assertion(v[0] / 2 = 1.5); p += dp; mln_assertion(q = p); Index: tests/literal_zero.cc --- tests/literal_zero.cc (revision 1303) +++ tests/literal_zero.cc (working copy) @@ -31,6 +31,9 @@ */ #include <mln/literal/zero.hh> +#include <mln/literal/one.hh> +#include <mln/literal/ops.hh> +#include <mln/value/int_u8.hh> int main() @@ -39,7 +42,15 @@ unsigned char c; c = literal::zero; + mln_assertion(c = 0); double d; d = literal::zero; + mln_assertion(d = 0); + + mln_assertion(literal::zero != literal::one); + + value::int_u8 u(literal::zero), uu; + uu = literal::zero; + mln_assertion(u = 0); } Index: tests/labeling_foreground.cc --- tests/labeling_foreground.cc (revision 1303) +++ tests/labeling_foreground.cc (working copy) @@ -50,7 +50,7 @@ out(lena.domain()); unsigned n; - labeling::foreground((pw::value(lena) > pw::cst(127)) | lena.domain(), + labeling::foreground((pw::value(lena) > pw::cst(127u)) | lena.domain(), c4(), out, n); io::pgm::save(out, "out.pgm"); mln_assertion(n = 14); Index: tests/point1d.cc --- tests/point1d.cc (revision 1303) +++ tests/point1d.cc (working copy) @@ -43,6 +43,9 @@ // assignment p[0] = 4; + metal::vec<1,int> v = p; + std::cout << v << std::endl; + p.ind() += 1; mln_assertion(p.ind() = 5 && p[0] = 5); Index: tests/window2d.cc --- tests/window2d.cc (revision 1303) +++ tests/window2d.cc (working copy) @@ -46,8 +46,8 @@ mln_assertion(w.is_centered() = false); mln_assertion(w.is_symmetric() = true); - w.insert(make::dpoint2d(-1,-1)); - w.insert(make::dpoint2d( 1, 1)); + w .insert(-1,-1) + .insert( 1, 1); image2d<bool> ima = convert::to_image(w); debug::println(ima); Index: tests/labeling_estimate.cc --- tests/labeling_estimate.cc (revision 1303) +++ tests/labeling_estimate.cc (working copy) @@ -49,8 +49,9 @@ image2d<int_u8> lena = io::pgm::load("../img/tiny.pgm"), out(lena.domain()); + // FIXME: Below, 127u (instead of 127) is mandatory to avoid a warning... unsigned n; - labeling::foreground((pw::value(lena) > pw::cst(127)) | lena.domain(), + labeling::foreground((pw::value(lena) > pw::cst(127u)) | lena.domain(), c4(), out, n); mln_assertion(n = 14); Index: tests/dpoint1d.cc --- tests/dpoint1d.cc (revision 1303) +++ tests/dpoint1d.cc (working copy) @@ -48,6 +48,6 @@ mln_assertion(dp = q - p); mln_assertion(q = p + dp); - const int (&vec)[1] = dp.to_vec(); - mln_assertion(vec[0] = 3); + metal::vec<1, float> v = dp; + mln_assertion(v[0] = 3); } Index: tests/dpoint3d.cc --- tests/dpoint3d.cc (revision 1303) +++ tests/dpoint3d.cc (working copy) @@ -48,6 +48,6 @@ mln_assertion(dp = q - p); mln_assertion(q = p + dp); - const int (&vec)[3] = dp.to_vec(); - mln_assertion(vec[1] = 6); + metal::vec<3, float> v = dp; + mln_assertion(v[1] = 6); } Index: tests/value_int_u8.cc --- tests/value_int_u8.cc (revision 1303) +++ tests/value_int_u8.cc (working copy) @@ -154,7 +154,12 @@ --i; mln_assertion(i = 234); - mln_assertion(-i = -234); + std::cout << (-i) << " FIXME Matthieu: add .f to literals " << i << std::endl; + mln_assertion(-i = -234); // FIXME: old version + mln_assertion(-i = -234.f); // FIXME: new better version + + mln_assertion(i * -2 != 0.f); + std::cout << (i) << " " << (i * -2) << " " << (-2 * int(i)) << std::endl; } // Multiplication Index: tests/point2d.cc --- tests/point2d.cc (revision 1303) +++ tests/point2d.cc (working copy) @@ -32,6 +32,7 @@ #include <iostream> #include <mln/core/point2d.hh> +#include <mln/literal/all.hh> @@ -62,6 +63,12 @@ point2d q_(5, 1); mln_assertion(q_ = q); } + { + point2d O(0,0); + point2d O_ = literal::zero; + mln_assertion(O_ = O); + mln_assertion(O = literal::zero); + } q.set_all(0); for (unsigned i = 0; i < p.dim; ++i) Index: TODO --- TODO (revision 1303) +++ TODO (working copy) @@ -55,14 +55,11 @@ *** type -value::proxy to dispatch read/write + the corresponding image type -a mean_value object { sum; count } and operator+ +... *** other -in Fast_Image: memcpy and memset-like methods (?) -.offset() into GenPixel -built-in op objects -> reverse lhs/rhs +... ** rename @@ -70,7 +67,7 @@ ** clean-up -select_function in fun::internal::selector_p2? etc. +... ** processing routines Index: mln/debug/all.hh --- mln/debug/all.hh (revision 1303) +++ mln/debug/all.hh (working copy) @@ -37,14 +37,16 @@ namespace mln { - /*! Namespace of routines that help to debug. - */ + /// Namespace of routines that help to debug. namespace debug {} } +# include <mln/debug/format.hh> +# include <mln/debug/iota.hh> # include <mln/debug/println.hh> +# include <mln/debug/println_with_border.hh> #endif // ! MLN_DEBUG_ALL_HH Index: mln/core/point.hh --- mln/core/point.hh (revision 1303) +++ mln/core/point.hh (working copy) @@ -39,14 +39,20 @@ # include <mln/metal/bool.hh> # include <mln/metal/vec.hh> +# include <mln/metal/converts_to.hh> # include <mln/core/h_vec.hh> namespace mln { - // fwd decl + /// \{ Fwd decls. template <typename M, typename C> struct dpoint_; + namespace literal { + struct zero_t; + struct one_t; + } + /// \} namespace internal @@ -102,13 +108,18 @@ /// Constructor without argument. point_(); - /// \{ Constructors with different numbers of argument w.r.t. the - /// dimension. + /// \{ Constructors with different numbers of arguments + /// (coordinates) w.r.t. the dimension. point_(C ind); point_(C row, C col); point_(C sli, C row, C col); /// \} + /// \{ Constructors with literals. + point_(const literal::zero_t&); + point_(const literal::one_t&); // Works only in 1D. + /// \} + /// Constructor; coordinates are set by function \p f. template <typename F> point_(const Function_i2v<F>& f); @@ -117,7 +128,7 @@ void set_all(C c); /// Origin point (all coordinates are 0). - static const point_<M,C> zero; + static const point_<M,C> origin; /// Shifting by \p dp. point_<M,C>& operator+=(const dpoint& dp); @@ -156,6 +167,8 @@ return this->coord_[i]; } + // Constructors. + template <typename M, typename C> point_<M,C>::point_() { @@ -189,19 +202,33 @@ template <typename F> point_<M,C>::point_(const Function_i2v<F>& f_) { + mlc_converts_to(mln_result(F), C)::check(); const F& f = exact(f_); for (unsigned i = 0; i < dim; ++i) coord_[i] = f(i); } template <typename M, typename C> + point_<M,C>::point_(const literal::zero_t&) + { + coord_.set_all(0); + } + + template <typename M, typename C> + point_<M,C>::point_(const literal::one_t&) + { + metal::bool_<(dim = 1)>::check(); + coord_[0] = 1; + } + + template <typename M, typename C> void point_<M,C>::set_all(C c) { coord_.set_all(c); } template <typename M, typename C> - const point_<M,C> point_<M,C>::zero = all(0); + const point_<M,C> point_<M,C>::origin = all(0); template <typename M, typename C> point_<M,C>& Index: mln/core/window.hh --- mln/core/window.hh (revision 1303) +++ mln/core/window.hh (working copy) @@ -31,6 +31,9 @@ /*! \file mln/core/window.hh * * \brief Definition of the generic window class mln::window. + * + * \todo Make naming coherent: we have window (without '_') but + * point_, neighb_, etc. */ # include <mln/core/concept/window.hh> @@ -89,6 +92,18 @@ /// Insert a delta-point \p dp. window<D>& insert(const D& dp); + /// \{ Insertion of a delta-point with different numbers of + /// arguments (coordinates) w.r.t. the dimension. + window<D>& insert(const mln_coord(D)& dind); // For 1D. + + window<D>& insert(const mln_coord(D)& drow, + const mln_coord(D)& dcol); // For 2D. + + window<D>& insert(const mln_coord(D)& dsli, + const mln_coord(D)& drow, + const mln_coord(D)& dcol); // For 3D. + /// \} + /// Apply a central symmetry to the target window. window<D>& sym(); @@ -137,6 +152,33 @@ template <typename D> window<D>& + window<D>::insert(const mln_coord(D)& dind) + { + D dp(dind); + mln_precondition(! has(dp)); + return this->insert(dp); + } + + template <typename D> + window<D>& + window<D>::insert(const mln_coord(D)& drow, const mln_coord(D)& dcol) + { + D dp(drow, dcol); + mln_precondition(! has(dp)); + return this->insert(dp); + } + + template <typename D> + window<D>& + window<D>::insert(const mln_coord(D)& dsli, const mln_coord(D)& drow, const mln_coord(D)& dcol) + { + D dp(dsli, drow, dcol); + mln_precondition(! has(dp)); + return this->insert(dp); + } + + template <typename D> + window<D>& window<D>::sym() { window<D> tmp; Index: mln/core/neighb.hh --- mln/core/neighb.hh (revision 1303) +++ mln/core/neighb.hh (working copy) @@ -91,7 +91,19 @@ * in the neighborhood definition; thus the client has not to * ensure the symmetry property; that is automatic. */ - void insert(const D& dp); + neighb_<D>& insert(const D& dp); + + /// \{ Insertion of a delta-point with different numbers of + /// arguments (coordinates) w.r.t. the dimension. + neighb_<D>& insert(const mln_coord(D)& dind); // For 1D. + + neighb_<D>& insert(const mln_coord(D)& drow, + const mln_coord(D)& dcol); // For 2D. + + neighb_<D>& insert(const mln_coord(D)& dsli, + const mln_coord(D)& drow, + const mln_coord(D)& dcol); // For 3D. + /// \} }; @@ -103,14 +115,42 @@ } template <typename D> - void + neighb_<D>& neighb_<D>::insert(const D& dp) { + mln_precondition(! has(dp)); typedef internal::set_of_<D> super; this->super::insert( dp); this->super::insert(-dp); + return *this; + } + + template <typename D> + neighb_<D>& + neighb_<D>::insert(const mln_coord(D)& dind) + { + D dp(dind); + mln_precondition(! has(dp)); + return this->insert(dp); + } + + template <typename D> + neighb_<D>& + neighb_<D>::insert(const mln_coord(D)& drow, const mln_coord(D)& dcol) + { + D dp(drow, dcol); + mln_precondition(! has(dp)); + return this->insert(dp); } + template <typename D> + neighb_<D>& + neighb_<D>::insert(const mln_coord(D)& dsli, const mln_coord(D)& drow, const mln_coord(D)& dcol) + { + D dp(dsli, drow, dcol); + mln_precondition(! has(dp)); + return this->insert(dp); + } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/ops.hh --- mln/core/ops.hh (revision 1303) +++ mln/core/ops.hh (working copy) @@ -41,6 +41,7 @@ namespace mln { + /*! \brief General definition of the "not equal to" operator. * * The "not equal to" operator is here defined for every milena @@ -135,6 +136,14 @@ // FIXME: Doc! template <typename O> + mln_trait_op_plus(O, unsigned) + operator+(unsigned lhs, const Object<O>& rhs) + { + return exact(rhs) + lhs; + } + + // FIXME: Doc! + template <typename O> mln_trait_op_plus(O, float) operator+(float lhs, const Object<O>& rhs) { @@ -154,6 +163,14 @@ // FIXME: Doc! template <typename O> + mln_trait_op_times(O, unsigned) + operator*(unsigned lhs, const Object<O>& rhs) + { + return exact(rhs) * lhs; + } + + // FIXME: Doc! + template <typename O> mln_trait_op_times(O, int) operator*(int lhs, const Object<O>& rhs) { @@ -177,6 +194,7 @@ } + # ifndef MLN_INCLUDE_ONLY template <typename O> @@ -184,6 +202,7 @@ { O tmp(exact(rhs)); // Copy. ++exact(rhs); // Pre-inc. + // FIXME: Activate: mln_postcondition(exact(rhs) = tmp + literal::one); return tmp; } @@ -192,6 +211,7 @@ { O tmp(exact(rhs)); // Copy. --exact(rhs); // Pre-dec. + // FIXME: Activate: mln_postcondition(exact(rhs) = tmp - literal::one); return tmp; } Index: mln/core/dpoint.hh --- mln/core/dpoint.hh (revision 1303) +++ mln/core/dpoint.hh (working copy) @@ -36,13 +36,20 @@ # include <mln/core/concept/dpoint.hh> # include <mln/core/internal/coord_impl.hh> # include <mln/fun/i2v/all.hh> +# include <mln/metal/vec.hh> +# include <mln/metal/converts_to.hh> namespace mln { - // fwd decl + /// \{ Fwd decls. template <typename M, typename C> struct point_; + namespace literal { + struct zero_t; + struct one_t; + } + /// \} /*! \brief Generic delta-point class. @@ -84,13 +91,18 @@ /// Constructor without argument. dpoint_(); - /// \{ Constructors with different numbers of argument w.r.t. the - /// dimension. + /// \{ Constructors with different numbers of arguments + /// (coordinates) w.r.t. the dimension. dpoint_(C ind); dpoint_(C row, C col); dpoint_(C sli, C row, C col); /// \} + /// \{ Constructors with literals. + dpoint_(const literal::zero_t&); + dpoint_(const literal::one_t&); // Works only in 1D. + /// \} + /// Constructor; coordinates are set by function \p f. template <typename F> dpoint_(const Function_i2v<F>& f); @@ -98,19 +110,18 @@ /// Set all coordinates to the value \p c. void set_all(C c); - /// Null delta-point (all coordinates are 0). + /// Zero delta-point. static const dpoint_<M,C> zero; - const C* coords_() const { return coord_; } - - /// Type of the array of coordinates. - typedef const C (&vec_t)[dim]; + /// Conversion towards a metal::vec. + template <typename Q> + operator metal::vec<M::dim, Q>() const; - /// Hook to coordinates. - vec_t to_vec() const { return coord_; } + /// Explicit conversion. + metal::vec<M::dim, C> to_vec() const; protected: - C coord_[dim]; + metal::vec<M::dim, C> coord_; }; @@ -160,9 +171,23 @@ } template <typename M, typename C> + dpoint_<M,C>::dpoint_(const literal::zero_t&) + { + coord_.set_all(0); + } + + template <typename M, typename C> + dpoint_<M,C>::dpoint_(const literal::one_t&) + { + metal::bool_<(dim = 1)>::check(); + coord_[0] = 1; + } + + template <typename M, typename C> template <typename F> dpoint_<M,C>::dpoint_(const Function_i2v<F>& f_) { + mlc_converts_to(mln_result(F), C)::check(); const F& f = exact(f_); for (unsigned i = 0; i < dim; ++i) coord_[i] = f(i); @@ -176,7 +201,23 @@ } template <typename M, typename C> - const dpoint_<M,C> dpoint_<M,C>::zero = all(0); + const dpoint_<M,C> + dpoint_<M,C>::zero = all(0); + + template <typename M, typename C> + template <typename Q> + dpoint_<M,C>::operator metal::vec<M::dim, Q> () const + { + return coord_; + } + + template <typename M, typename C> + metal::vec<M::dim, C> + dpoint_<M,C>::to_vec() const + { + return coord_; + } + # endif // ! MLN_INCLUDE_ONLY Index: mln/core/concept/function.hh --- mln/core/concept/function.hh (revision 1303) +++ mln/core/concept/function.hh (working copy) @@ -39,8 +39,19 @@ namespace mln { - // Fwd decl. + /// \{ + /// Fwd decls. template <typename E> struct Function; + template <typename E> struct Function_v2v; + template <typename E> struct Function_i2v; + template <typename E> struct Function_p2v; + template <typename E> struct Function_v2b; + template <typename E> struct Function_p2b; + template <typename E> struct Function_p2p; + template <typename E> struct Function_x2x; + /// \} + + // Function category flag type. template <> @@ -71,11 +82,15 @@ // Value -> Value. + template <> + struct Function_v2v<void> { typedef Function<void> super; }; + /// Base class for implementation of function-objects from value to /// value. template <typename E> struct Function_v2v : public Function<E> { + typedef Function_v2v<void> category; protected: Function_v2v(); Function_v2v(const Function_v2v&); @@ -84,11 +99,15 @@ // Index -> Value. + template <> + struct Function_i2v<void> { typedef Function_v2v<void> super; }; + /// Base class for implementation of function-objects from index to /// value. template <typename E> struct Function_i2v : public Function_v2v<E> { + typedef Function_i2v<void> category; protected: Function_i2v(); Function_i2v(const Function_i2v&); @@ -97,11 +116,15 @@ // Point -> Value. + template <> + struct Function_p2v<void> { typedef Function_v2v<void> super; }; + /// Base class for implementation of function-objects from point to /// value. template <typename E> struct Function_p2v : public virtual Function_v2v<E> { + typedef Function_p2v<void> category; protected: Function_p2v(); Function_p2v(const Function_p2v&); @@ -110,11 +133,15 @@ // Value -> bool. + template <> + struct Function_v2b<void> { typedef Function_v2v<void> super; }; + /// Base class for implementation of function-objects from value to /// bool. template <typename E> struct Function_v2b : public virtual Function_v2v<E> { + typedef Function_v2b<void> category; typedef bool result; protected: Function_v2b(); @@ -124,12 +151,16 @@ // Point -> bool. + template <> + struct Function_p2b<void> { typedef Function_p2v<void> super; }; // FIXME + /// Base class for implementation of function-objects from point to /// bool. template <typename E> struct Function_p2b : public Function_p2v<E>, public Function_v2b<E> { + typedef Function_p2b<void> category; typedef bool result; protected: Function_p2b(); @@ -139,11 +170,15 @@ // Point -> Point. + template <> + struct Function_p2p<void> { typedef Function_p2v<void> super; }; // FIXME + /// Base class for implementation of function-objects from point to /// point. template <typename E> struct Function_p2p : public Function_p2v<E> { + typedef Function_p2p<void> category; protected: Function_p2p(); Function_p2p(const Function_p2p&); @@ -152,11 +187,15 @@ // Vector -> Vector. + template <> + struct Function_x2x<void> { typedef Function_v2v<void> super; }; // FIXME + /// Base class for implementation of function-objects from vector to /// vector. template <typename E> struct Function_x2x : public Function_v2v<E> { + typedef Function_x2x<void> category; protected: Function_x2x(); Function_x2x(const Function_x2x&); Index: mln/core/concept/window.hh --- mln/core/concept/window.hh (revision 1303) +++ mln/core/concept/window.hh (working copy) @@ -123,8 +123,8 @@ // FIXME: Same grid! typedef mln_point(Wl) P; - mln_fwd_qiter(Wl) ql(exact(lhs), P::zero); - mln_fwd_qiter(Wr) qr(exact(rhs), P::zero); + mln_fwd_qiter(Wl) ql(exact(lhs), P::origin); + mln_fwd_qiter(Wr) qr(exact(rhs), P::origin); for (ql.start(), qr.start(); ql.is_valid() && qr.is_valid(); Index: mln/literal/ops.hh --- mln/literal/ops.hh (revision 0) +++ mln/literal/ops.hh (revision 0) @@ -0,0 +1,89 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LITERAL_OPS_HH +# define MLN_LITERAL_OPS_HH + +/*! \file mln/literal/ops.hh + * \brief Definitions of some operators. + */ + +# include <mln/core/concept/literal.hh> + + + +namespace mln +{ + + template <typename O, typename L> + bool operator=(const Object<O>& lhs, const Literal<L>& rhs); + + template <typename L, typename O> + bool operator=(const Literal<L>& lhs, const Object<O>& rhs); + + template <typename L1, typename L2> + bool operator=(const Literal<L1>& lhs, const Literal<L2>& rhs); + + template <typename L> + bool operator=(const Literal<L>& lhs, const Literal<L>& rhs); + + // FIXME: Add other operators... + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename O, typename L> + bool operator=(const Object<O>& lhs, const Literal<L>& rhs) + { + return exact(lhs) = O(exact(rhs)); + } + + template <typename L, typename O> + bool operator=(const Literal<L>& lhs, const Object<O>& rhs) + { + return rhs = lhs; + } + + template <typename L1, typename L2> + bool operator=(const Literal<L1>&, const Literal<L2>&) + { + return false; + } + + template <typename L> + bool operator=(const Literal<L>&, const Literal<L>&) + { + return true; + } + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + + +#endif // ! MLN_LITERAL_OPS_HH Index: mln/literal/one.hh --- mln/literal/one.hh (revision 0) +++ mln/literal/one.hh (revision 0) @@ -0,0 +1,76 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LITERAL_ONE_HH +# define MLN_LITERAL_ONE_HH + +/*! \file mln/literal/one.hh + * + * \brief Definition of the literal of mln::one. + */ + +# include <mln/core/concept/literal.hh> +# include <mln/metal/converts_to.hh> + + +namespace mln +{ + + namespace literal + { + + /// Type of literal one. + struct one_t : public Literal<one_t> + { + // FIXME: Cf. comments in literal/zero.hh. + + template <typename T> + operator T () const; + }; + + + /// Literal one. + static one_t one = one_t(); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename T> + one_t::operator T () const + { + mlc_converts_to(int, T)::check(); + return 1; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::literal + +} // end of namespace mln + + +#endif // ! MLN_LITERAL_ONE_HH Index: mln/literal/all.hh --- mln/literal/all.hh (revision 0) +++ mln/literal/all.hh (revision 0) @@ -0,0 +1,58 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LITERAL_ALL_HH +# define MLN_LITERAL_ALL_HH + +/*! \file mln/literal/all.hh + * + * \brief File that includes all literals. + */ + +namespace mln +{ + + /// Namespace of literals. + namespace literal {} + +} + + +# include <mln/literal/zero.hh> +# include <mln/literal/one.hh> + +// FIXME: Add: +// # include <mln/literal/white.hh> +// # include <mln/literal/black.hh> + +// # include <mln/literal/grays.hh> +// # include <mln/literal/colors.hh> + +# include <mln/literal/ops.hh> + + +#endif // ! MLN_LITERAL_ALL_HH Index: mln/metal/vec.hh --- mln/metal/vec.hh (revision 1303) +++ mln/metal/vec.hh (working copy) @@ -35,7 +35,6 @@ # include <mln/trait/all.hh> # include <mln/value/props.hh> # include <mln/fun/i2v/all.hh> -# include <mln/literal/zero.hh> # include <mln/value/concept/all.hh> @@ -45,6 +44,10 @@ namespace mln { + // Fwd decl. + namespace literal { struct zero_t; } + + namespace metal { @@ -139,7 +142,7 @@ vec(); - vec(mln::literal::zero_t); + vec(const literal::zero_t&); vec(const vec<n, T>& rhs); @@ -167,6 +170,9 @@ /// Zero value. static const vec<n, T> zero; + + /// Origin value. + static const vec<n, T> origin; }; } // end of namespace mln::metal @@ -323,9 +329,9 @@ } template <unsigned n, typename T> - vec<n,T>::vec(mln::literal::zero_t) + vec<n,T>::vec(const literal::zero_t&) { - this->set_all( mln::literal::zero ); + this->set_all(0); } template <unsigned n, typename T> @@ -416,6 +422,9 @@ template <unsigned n, typename T> const vec<n, T> vec<n, T>::zero = all(0); + template <unsigned n, typename T> + const vec<n, T> vec<n, T>::origin = all(0); + // eq Index: mln/value/cast.hh --- mln/value/cast.hh (revision 1303) +++ mln/value/cast.hh (working copy) @@ -61,7 +61,7 @@ } template <typename T, typename S> - typename S::equiv + typename S::equiv // FIXME: Is-that equiv here? cast_(const T&, const Value<S>& src) { return exact(src); Index: mln/value/int_u.hh --- mln/value/int_u.hh (revision 1303) +++ mln/value/int_u.hh (working copy) @@ -46,8 +46,10 @@ namespace mln { - // Fwd decl. + /// \{ Fwd decls. namespace value { template <unsigned n> struct int_u; } + namespace literal { struct zero_t; struct one_t; } + /// \} namespace trait @@ -68,6 +70,18 @@ }; template <unsigned n> + struct set_precise_binary_< promote, mln::value::int_u<n>, unsigned > + { + typedef unsigned ret; + }; + + template <unsigned n> + struct set_precise_binary_< promote, unsigned, mln::value::int_u<n> > + { + typedef unsigned ret; + }; + + template <unsigned n> struct set_precise_binary_< promote, mln::value::int_u<n>, float > { typedef float ret; @@ -119,8 +133,18 @@ /// Constructor from an integer. int_u(int i); - /// Conversion to an integer. - operator int() const; + /// \{ Constructors/assignments with literals. + int_u(const literal::zero_t&); + int_u& operator=(const literal::zero_t&); + int_u(const literal::one_t&); + int_u& operator=(const literal::one_t&); + /// \} + + /// Conversion to an unsigned integer. + operator unsigned() const; + + /// Unary operator minus. + int operator-() const; /// Assignment from an integer. int_u<n>& operator=(int i); @@ -181,12 +205,47 @@ } template <unsigned n> - int_u<n>::operator int() const + int_u<n>::int_u(const literal::zero_t&) + { + this->v_ = 0; + } + + template <unsigned n> + int_u<n>& + int_u<n>::operator=(const literal::zero_t&) + { + this->v_ = 0; + return *this; + } + + template <unsigned n> + int_u<n>::int_u(const literal::one_t&) + { + this->v_ = 1; + } + + template <unsigned n> + int_u<n>& + int_u<n>::operator=(const literal::one_t&) + { + this->v_ = 1; + return *this; + } + + template <unsigned n> + int_u<n>::operator unsigned() const { return this->v_; } template <unsigned n> + int + int_u<n>::operator-() const + { + return - int(this->v_); + } + + template <unsigned n> int_u<n>& int_u<n>::operator=(int i) { @@ -205,7 +264,8 @@ template <unsigned n> std::ostream& operator<<(std::ostream& ostr, const int_u<n>& i) { - return ostr << debug::format(i.to_equiv()); + // FIXME: This code could be factored for almost every Value<*>... + return ostr << debug::format(i.to_equiv()); // FIXME: is to_equiv OK? } # endif // ! MLN_INCLUDE_ONLY Index: mln/value/internal/value_like.hh --- mln/value/internal/value_like.hh (revision 1303) +++ mln/value/internal/value_like.hh (working copy) @@ -123,7 +123,7 @@ N value_like_<V,C,N,E>::to_interop() const { - return mln::internal::force_exact<E>(*this).operator N(); + return static_cast<N>(mln::internal::force_exact<E>(*this)); } template <typename V, typename C, typename N, typename E> Index: mln/make/w_window.hh --- mln/make/w_window.hh (revision 1303) +++ mln/make/w_window.hh (working copy) @@ -69,9 +69,9 @@ typedef mln_dpoint(W) D; typedef mln_point(D) P; mln::w_window<D, mln_result(F)> w_win; - mln_qiter(W) q(win, P::zero); + mln_qiter(W) q(win, P::origin); for_all(q) - w_win.insert(wei(q), q - P::zero); + w_win.insert(wei(q), q - P::origin); return w_win; } Index: mln/test/positive.hh --- mln/test/positive.hh (revision 1303) +++ mln/test/positive.hh (working copy) @@ -36,6 +36,7 @@ # include <mln/test/predicate.hh> # include <mln/pw/all.hh> # include <mln/fun/v2v/id.hh> +# include <mln/literal/zero.hh> namespace mln @@ -56,8 +57,12 @@ { const I& input = exact(input_); mln_precondition(input.has_data()); + // FIXME: Below the '>=' op should properly work with signed/unsigned without + // FIXME: warnings; so we really need to overload ops for functions when literals + // FIXME: are involved. + mln_value(I) zero_ = literal::zero; return test::predicate(input.domain(), - pw::value(input) >= pw::cst(0)); + pw::value(input) >= pw::cst(zero_)); // FIXME: test the version below. // return test::predicate(input, // fun::v2v::id<mln_value(I)>() >= pw::cst(0)); Index: mln/convert/to_image.hh --- mln/convert/to_image.hh (revision 1303) +++ mln/convert/to_image.hh (working copy) @@ -147,7 +147,7 @@ box_<P> b = geom::bbox(win); mln_image_from(W, bool) ima(b); level::fill(ima, false); - mln_qiter(W) q(win, P::zero); + mln_qiter(W) q(win, P::origin); for_all(q) ima(q) = true; return ima; @@ -168,7 +168,7 @@ typedef mln_point(W) P; box_<P> b = geom::bbox(w_win); mln_image_from(W, mln_weight(W)) ima(b); - mln_qiter(W) q(w_win, P::zero); + mln_qiter(W) q(w_win, P::origin); for_all(q) ima(q) = q.w(); return ima; Index: mln/convert/to_std_set.hh --- mln/convert/to_std_set.hh (revision 1303) +++ mln/convert/to_std_set.hh (working copy) @@ -59,9 +59,9 @@ typedef mln_dpoint(W) D; typedef mln_point(D) P; std::set<D> s; - mln_qiter(W) q(exact(win), P::zero); + mln_qiter(W) q(exact(win), P::origin); for_all(q) - s.insert(q - P::zero); + s.insert(q - P::origin); return s; } Index: mln/convert/to_window.hh --- mln/convert/to_window.hh (revision 1303) +++ mln/convert/to_window.hh (working copy) @@ -79,9 +79,9 @@ typedef mln_dpoint(N) D; typedef mln_point(D) P; window<D> win; - mln_niter(N) n(nbh, P::zero); + mln_niter(N) n(nbh, P::origin); for_all(n) - win.insert(n - P::zero); + win.insert(n - P::origin); return win; } @@ -92,10 +92,10 @@ typedef mln_dpoint(N) D; typedef mln_point(D) P; window<D> win; - mln_niter(N) n(nbh, P::zero); + mln_niter(N) n(nbh, P::origin); for_all(n) - if (n > P::zero) - win.insert(n - P::zero); + if (n > P::origin) + win.insert(n - P::origin); return win; } @@ -111,7 +111,7 @@ mln_piter(I) p(ima.domain()); for_all(p) if (ima(p)) - win.insert(p - P::zero); + win.insert(p - P::origin); return win; } Index: mln/convert/to_dpoint.hh --- mln/convert/to_dpoint.hh (revision 1303) +++ mln/convert/to_dpoint.hh (working copy) @@ -57,7 +57,7 @@ for (unsigned i = 0; i < P::dim; ++i) dp[i] = p[i]; typedef mln_point(P) P_; - mln_postcondition(dp = p - P_::zero); + mln_postcondition(dp = p - P_::origin); return dp; } Index: mln/convert/to_w_window.hh --- mln/convert/to_w_window.hh (revision 1303) +++ mln/convert/to_w_window.hh (working copy) @@ -62,7 +62,7 @@ mln_piter(I) p(input.domain()); for_all(p) if (input(p) != 0) - w_win.insert(input(p), p - P::zero); + w_win.insert(input(p), p - P::origin); return w_win; } Index: mln/geom/bbox.hh --- mln/geom/bbox.hh (revision 1303) +++ mln/geom/bbox.hh (working copy) @@ -80,7 +80,7 @@ mln_precondition(! win.is_empty()); typedef mln_point(W) P; - mln_qiter(W) q(win, P::zero); + mln_qiter(W) q(win, P::origin); std::pair<P, P> pp = geom::pmin_pmax(q); box_<P> tmp(pp.first, pp.second); Index: mln/geom/shift.hh --- mln/geom/shift.hh (revision 1303) +++ mln/geom/shift.hh (working copy) @@ -57,7 +57,7 @@ { typedef mln_point(W) P; window<mln_dpoint(W)> tmp; - mln_qiter(W) q(win, P::zero); + mln_qiter(W) q(win, P::origin); for_all(q) tmp.insert(convert::to_dpoint(q) + dp); return tmp; Index: mln/fun/v2v/saturate.hh --- mln/fun/v2v/saturate.hh (revision 1303) +++ mln/fun/v2v/saturate.hh (working copy) @@ -34,6 +34,7 @@ */ # include <mln/core/concept/function.hh> +# include <mln/metal/converts_to.hh> # include <mln/value/props.hh> @@ -86,11 +87,16 @@ V saturate<V>::operator()(const W& w) const { - if (w < min_) + // FIXME: Below we need something more powerful that mlc_converts_to + // FIXME: for instance, with W=int_s<10u> and V=int_u<8u>, it does not + // FIXME: works cause the cast is not obvious... + // mlc_converts_to(W, V)::check(); + V w_ = mln::value::cast<V>(w); + if (w_ < min_) return min_; - if (w > max_) + if (w_ > max_) return max_; - return mln::value::cast<V>(w); + return w_; } # endif // ! MLN_INCLUDE_ONLY Index: mln/win/octagon2d.hh --- mln/win/octagon2d.hh (revision 1303) +++ mln/win/octagon2d.hh (working copy) @@ -48,8 +48,9 @@ /*! \brief Octagon window defined on the 2D square grid. * * An octagon2d is centered and symmetrical. - * The length l of the octagon is such as l = 6*x + 1 - * where 0 <= x. + * + * The length L of the octagon is such as L = 6 * l + 1 + * where l >= 0. * * For instance: \n * o o o \n @@ -59,7 +60,7 @@ * o o o o o o o \n * o o o o o \n * o o o \n - * is defined with length = 7 (x = 0). + * is defined with L = 7 (l = 1). */ struct octagon2d : public Window< octagon2d >, public internal::dpoints_base_< dpoint2d, octagon2d > @@ -144,26 +145,26 @@ const int y = length / 6; const int x = y * 2; const int z = y + x; - insert(dpoint2d::zero); + insert(dpoint2d(0, 0)); for (int a = 1; a <= x; ++a) for (int b = 0; b <= x; ++b) { - insert(make::dpoint2d(a, b)); - insert(make::dpoint2d(-b, a)); - insert(make::dpoint2d(b, -a)); - insert(make::dpoint2d(-a, -b)); + insert(dpoint2d(a, b)); + insert(dpoint2d(-b, a)); + insert(dpoint2d(b, -a)); + insert(dpoint2d(-a, -b)); } for (int a = x + 1; a <= z; ++a) for (int b = -2 * x + a; b <= 2 * x - a; ++b) { - insert(make::dpoint2d(a, b)); - insert(make::dpoint2d(a, -b)); - insert(make::dpoint2d(-a, b)); - insert(make::dpoint2d(-a, -b)); - insert(make::dpoint2d(b, a)); - insert(make::dpoint2d(b, -a)); - insert(make::dpoint2d(-b, a)); - insert(make::dpoint2d(-b, -a)); + insert(dpoint2d(a, b)); + insert(dpoint2d(a, -b)); + insert(dpoint2d(-a, b)); + insert(dpoint2d(-a, -b)); + insert(dpoint2d(b, a)); + insert(dpoint2d(b, -a)); + insert(dpoint2d(-b, a)); + insert(dpoint2d(-b, -a)); } } Index: mln/morpho/hit_or_miss.hh --- mln/morpho/hit_or_miss.hh (revision 1303) +++ mln/morpho/hit_or_miss.hh (working copy) @@ -154,6 +154,9 @@ && pw::value(dil_bg) < pw::value(input), pw::value(input) - pw::value(dil_bg), pw::cst(V::zero))); + + // FIXME: Replace 'pw::cst(V::zero)' by 'pw::cst(V(literal::zero))' + // FIXME: and then by 'literal::zero'! } else if (exact(win_miss).is_centered()) { Index: mln/norm/infty.hh --- mln/norm/infty.hh (revision 1303) +++ mln/norm/infty.hh (working copy) @@ -34,6 +34,7 @@ */ # include <cmath> +# include <mln/metal/vec.hh> namespace mln @@ -42,9 +43,14 @@ namespace norm { - /// Infinity-norm of a vector \p vec. + /// Infinity-norm of a vector \p v (being a C static array). template <unsigned n, typename C> - C infty(const C (&vec)[n]); + C infty(const C (&v)[n]); + + /// Infinity-norm of a vector \p v (being a metal::vec). + template <unsigned n, typename C> + C infty(const metal::vec<n,C>& v); + /// Infinity-norm distance between vectors \p v1 and \p v2. template <unsigned n, typename C> @@ -54,12 +60,23 @@ # ifndef MLN_INCLUDE_ONLY template <unsigned n, typename C> - C infty(const C (&vec)[n]) + C infty(const C (&v)[n]) + { + C c = 0; + for (unsigned i = 0; i < n; ++i) + if (std::abs(v[i]) > c) + c = std::abs(v[i]); + return c; + } + + template <unsigned n, typename C> + C infty(const metal::vec<n,C>& v) { + // FIXME: Add a ctor to metal::vec... C c = 0; for (unsigned i = 0; i < n; ++i) - if (std::abs(vec[i]) > c) - c = std::abs(vec[i]); + if (std::abs(v[i]) > c) + c = std::abs(v[i]); return c; } Index: mln/norm/l2.hh --- mln/norm/l2.hh (revision 1303) +++ mln/norm/l2.hh (working copy) @@ -57,6 +57,9 @@ template <unsigned n, typename C> float l2_distance(const metal::vec<n,C>& vec1, const metal::vec<n,C>& vec2); + // FIXME: Replace float by mln_value_sum(C)... + + # ifndef MLN_INCLUDE_ONLY template <unsigned n, typename C>