URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena
ChangeLog:
2007-10-01 Matthieu Garrigues <garrigues(a)lrde.epita.fr>
Add gray values.
* mln/value/gray.hh: General gray-level class where n bits is not know
at compile-time. This class is used for exchange between gray-level
types purpose.
* mln/value/graylevel.hh: Graylevel class on n bits.
* tests/value_gray.cc: Some tests.
---
diffstat not available
Index: trunk/milena/tests/value_gray.cc
===================================================================
--- trunk/milena/tests/value_gray.cc (revision 0)
+++ trunk/milena/tests/value_gray.cc (revision 1203)
@@ -0,0 +1,44 @@
+// 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.
+
+#include <mln/value/graylevel.hh>
+
+int main()
+{
+ using namespace mln::value;
+
+ gl8 a = white;
+ gl16 b = white;
+ assert((a == b) == true);
+ gl8 c = (a + b) / 2;
+ assert(c == white);
+ c = a;
+ assert(c == white);
+
+ c = (a * 2) / 2;
+ assert(c == white);
+}
Index: trunk/milena/mln/value/graylevel.hh
===================================================================
--- trunk/milena/mln/value/graylevel.hh (revision 0)
+++ trunk/milena/mln/value/graylevel.hh (revision 1203)
@@ -0,0 +1,208 @@
+// Copyright (C) 2006, 2007 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef MLN_CORE_VALUE_GRAYLEVEL_HH
+# define MLN_CORE_VALUE_GRAYLEVEL_HH
+
+# include <iostream>
+# include <mln/core/contract.hh>
+# include <mln/metal/math.hh>
+# include <mln/metal/bexpr.hh>
+# include <mln/value/internal/value_like.hh>
+# include <mln/value/internal/encoding.hh>
+# include <mln/value/gray.hh>
+# include <mln/value/props.hh>
+
+namespace mln
+{
+
+ namespace value
+ {
+
+ /// Fwd decl.
+ class gray;
+
+
+ /// General gray-level class on n bits.
+ template <unsigned n>
+ class graylevel
+ : public internal::value_like_< typename internal::encoding_unsigned_<n>::ret,
+ graylevel<n> >
+ {
+ protected:
+ typedef internal::value_like_< typename internal::encoding_unsigned_<n>::ret,
+ graylevel<n> > super;
+
+ public:
+
+ /// Encoding associated type.
+ typedef typename super::enc enc;
+
+ /// Ctor.
+ graylevel();
+
+ /// Ctor.
+ explicit graylevel(const int val);
+
+ /// Access to std type.
+ enc value() const;
+
+ /// Op encoding_t.
+ operator enc() const;
+
+ /// Op graylevel.
+ operator graylevel() const;
+
+ /// Op<.
+ bool operator<(const graylevel<n>& rhs) const;
+
+ graylevel<n>& operator=(const int val);
+ /// Op==.
+ // bool operator==(const graylevel<n>& rhs) const;
+
+ protected:
+ enc val_;
+ };
+
+
+ template <unsigned n>
+ struct props< graylevel<n> >
+ {
+ static const std::size_t card_ = metal::pow<2, n>::value;
+ static const graylevel<n> min() { return 0; }
+ static const graylevel<n> max() { return card_ - 1; }
+ static const unsigned nbits = n;
+ typedef data_kind kind;
+ typedef float sum;
+ typedef int interop;
+ };
+
+
+ /// Op<<.
+ template <unsigned n>
+ std::ostream& operator<<(std::ostream& ostr, const graylevel<n>& g);
+
+
+ /// Aliases.
+ typedef graylevel<8> gl8;
+ typedef graylevel<16> gl16;
+ typedef graylevel<32> gl32;
+
+
+ template <unsigned n, unsigned m>
+ bool operator==(const graylevel<n>& lhs, const graylevel<m>& rhs);
+
+ template <unsigned n, unsigned m>
+ gray operator+(const graylevel<n>& lhs, const graylevel<m>& rhs);
+
+ template <unsigned n, unsigned m>
+ gray operator-(const graylevel<n>& lhs, const graylevel<m>& rhs);
+
+ template <unsigned n>
+ gray operator*(int s, const graylevel<n>& rhs);
+
+ template <unsigned n>
+ gray operator*(const graylevel<n>& lhs, int s);
+
+ template <unsigned n>
+ gray operator/(const graylevel<n>& lhs, int s);
+
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ // Graylevel<n>.
+
+ template <unsigned n>
+ graylevel<n>::graylevel()
+ {
+ }
+
+ template <unsigned n>
+ graylevel<n>::graylevel(const int val)
+ : val_(val)
+ {
+ mln_precondition(val >= 0);
+ mln_precondition(unsigned(val) <= mln_max(enc));
+ }
+
+ template <unsigned n>
+ typename graylevel<n>::enc
+ graylevel<n>::value() const
+ {
+ return val_;
+ }
+
+ template <unsigned n>
+ graylevel<n>&
+ graylevel<n>::operator=(const int val)
+ {
+ mln_precondition(val >= 0);
+ mln_precondition(unsigned(val) <= mln_max(enc));
+ this->val_ = val;
+ return *this;
+ }
+
+ template <unsigned n>
+ graylevel<n>::operator graylevel() const
+ {
+ gray tmp(n, val_);
+ return tmp;
+ }
+
+ template <unsigned n>
+ graylevel<n>::operator typename graylevel<n>::enc() const
+ {
+ return val_;
+ }
+
+ template <unsigned n>
+ bool graylevel<n>::operator<(const graylevel<n>& rhs) const
+ {
+ return val_ < rhs.val_;
+ }
+
+ template <unsigned n>
+ std::ostream& operator<<(std::ostream& ostr, const graylevel<n>& g)
+ {
+ return ostr << g.value();
+ }
+
+ template <unsigned n, unsigned m>
+ bool operator==(const graylevel<n>& lhs, const graylevel<m>& rhs)
+ {
+ return gray(lhs) == gray(rhs);
+ }
+
+# endif
+
+
+ } // end of namespace mln::value
+
+} // end of namespace mln
+
+#endif // ! MLN_CORE_VALUE_GRAYLEVEL_HH
Index: trunk/milena/mln/value/gray.hh
===================================================================
--- trunk/milena/mln/value/gray.hh (revision 0)
+++ trunk/milena/mln/value/gray.hh (revision 1203)
@@ -0,0 +1,350 @@
+// Copyright (C) 2006, 2007 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef MLN_VALUE_GRAY_HH
+# define MLN_VALUE_GRAY_HH
+
+# include <iostream>
+# include <mln/value/graylevel.hh>
+
+
+
+namespace mln
+{
+
+ // Fwd decls.
+ namespace value
+ {
+ template <unsigned N> class graylevel;
+ class gray;
+
+ /// General gray-level class where n bits is not know at compile-time.
+ /// This class is used for exchange between gray-level types purpose.
+
+ class gray // FIXME do we need a super class?
+ //: public mln::internal::graylevel_value_< gray >
+ {
+ public:
+
+ /// Ctor.
+ gray();
+
+ /// Ctor.
+ template <unsigned N>
+ gray(const graylevel<N>& val);
+
+ /// Ctor.
+ gray(unsigned nbits, unsigned long val);
+
+ /// Access to std type.
+ unsigned long value() const;
+
+ unsigned nbits() const;
+
+ void set_nbits(unsigned nbits);
+
+ gray to_nbits(unsigned nbits) const;
+
+ template <unsigned N>
+ operator graylevel<N>() const;
+
+ protected:
+ unsigned nbits_;
+ unsigned long val_;
+ };
+
+ /// White.
+ extern const gray white;
+
+ /// Black.
+ extern const gray black;
+
+ std::ostream& operator<<(std::ostream& ostr, const gray& g);
+
+ bool operator==(const gray& lhs, const gray& rhs);
+ bool operator<(const gray& lhs, const gray& rhs);
+
+ gray operator+(const gray& lhs, const gray& rhs);
+ gray operator-(const gray& lhs, const gray& rhs);
+
+ gray operator*(int s, const gray& rhs);
+ gray operator*(const gray& lhs, int s);
+
+ gray operator/(const gray& lhs, int s);
+
+
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ const gray white = gray(1, 1);
+ const gray black = gray(1, 0);
+
+ template <unsigned N, unsigned M>
+ gray operator+(const graylevel<N>& lhs, const graylevel<M>& rhs)
+ {
+ return gray(lhs) + gray(rhs);
+ }
+
+ template <unsigned N, unsigned M>
+ gray operator-(const graylevel<N>& lhs, const graylevel<M>& rhs)
+ {
+ return gray(lhs) - gray(rhs);
+ }
+
+ template <unsigned N>
+ gray operator*(int s, const graylevel<N>& rhs)
+ {
+ mln_precondition(s >= 0);
+ gray tmp(N, s * rhs.value());
+ return tmp;
+ }
+
+ template <unsigned N>
+ gray operator*(const graylevel<N>& lhs, int s)
+ {
+ mln_precondition(s >= 0);
+ gray tmp(N, lhs.value() * s);
+ return tmp;
+ }
+
+ template <unsigned N>
+ gray operator/(const graylevel<N>& lhs, int s)
+ {
+ mln_precondition(s > 0);
+ gray tmp(N, lhs.value() / s);
+ return tmp;
+ }
+
+
+
+ // Gray.
+
+ gray::gray()
+ : nbits_(0)
+ {
+ }
+
+ template <unsigned n>
+ gray::gray(const graylevel<n>& g)
+ : nbits_(n),
+ val_(g.value())
+ {
+ }
+
+ gray::gray(unsigned nbits, unsigned long val)
+ : nbits_(nbits),
+ val_(val)
+ {
+ }
+
+ unsigned long gray::value() const
+ {
+ mln_invariant(nbits_ != 0);
+ return val_;
+ }
+
+ unsigned gray::nbits() const
+ {
+ return nbits_;
+ }
+
+ namespace internal
+ {
+
+ unsigned long two_pow_(unsigned n)
+ {
+ if (n == 0)
+ return 1;
+ else
+ return 2 * two_pow_(n - 1);
+ }
+
+ unsigned long two_pow_n_minus_1(unsigned n)
+ {
+ return two_pow_(n) - 1;
+ }
+
+ template <unsigned n_dest>
+ unsigned long convert(unsigned n_src, unsigned long val)
+ {
+ if (n_dest == n_src)
+ return val;
+ else
+ if (n_dest > n_src)
+ return val * two_pow_n_minus_1(n_dest) / two_pow_n_minus_1(n_src);
+ else
+ return val / two_pow_(n_src - n_dest);
+ }
+
+ } // end of mln::value::internal
+
+
+ void gray::set_nbits(unsigned nbits)
+ {
+ mln_precondition(nbits != 0);
+ mln_invariant(nbits_ != 0);
+ if (nbits == nbits_)
+ return;
+ if (nbits > nbits_)
+ {
+ val_ *= internal::two_pow_n_minus_1(nbits);
+ val_ /= internal::two_pow_n_minus_1(nbits_);
+ }
+ else // nbits < nbits_
+ {
+ val_ /= internal::two_pow_(nbits_ - nbits);
+ }
+ nbits_ = nbits;
+ }
+
+
+ gray gray::to_nbits(unsigned nbits) const
+ {
+ mln_precondition(nbits != 0);
+ mln_invariant(nbits_ != 0);
+ gray tmp(*this);
+ tmp.set_nbits(nbits);
+ return tmp;
+ }
+
+
+ template <unsigned n>
+ gray::operator graylevel<n>() const
+ {
+ mln_precondition(nbits_ != 0);
+ graylevel<n> tmp(internal::convert<n>(nbits_, val_));
+
+ mln_assertion(tmp.value() < internal::two_pow_(n));
+ return tmp;
+ }
+
+ // operators
+
+ std::ostream& operator<<(std::ostream& ostr, const gray& g)
+ {
+ return ostr << g.value() << '/' << g.nbits() << "nbits";
+ }
+
+ bool operator==(const gray& lhs, const gray& rhs)
+ {
+ mln_precondition(lhs.nbits() != 0 and rhs.nbits() != 0);
+ if (rhs.nbits() == lhs.nbits())
+ return lhs.value() == rhs.value();
+ if (lhs.nbits() > rhs.nbits())
+ return lhs.value() == rhs.to_nbits(lhs.nbits()).value();
+ else
+ return lhs.to_nbits(rhs.nbits()).value() == rhs.value();
+ }
+
+ bool operator<(const gray& lhs, const gray& rhs)
+ {
+ mln_precondition(lhs.nbits() != 0 and rhs.nbits() != 0);
+ if (rhs.nbits() == lhs.nbits())
+ return lhs.value() < rhs.value();
+ if (lhs.nbits() > rhs.nbits())
+ return lhs.value() < rhs.to_nbits(lhs.nbits()).value();
+ else
+ return lhs.to_nbits(rhs.nbits()).value() < rhs.value();
+ }
+
+ gray operator+(const gray& lhs, const gray& rhs)
+ {
+ mln_precondition(lhs.nbits() != 0 and rhs.nbits() != 0);
+ if (lhs.nbits() > rhs.nbits())
+ {
+ gray tmp(lhs.nbits(),
+ lhs.value() + rhs.to_nbits(lhs.nbits()).value());
+ return tmp;
+ }
+ else
+ {
+ gray tmp(rhs.nbits(),
+ lhs.to_nbits(rhs.nbits()).value() + rhs.value());
+ return tmp;
+ }
+ }
+
+ gray operator-(const gray& lhs, const gray& rhs)
+ {
+ mln_precondition(lhs.nbits() != 0 and rhs.nbits() != 0);
+ if (lhs.nbits() > rhs.nbits())
+ {
+ unsigned long l = rhs.to_nbits(lhs.nbits()).value();
+ assert(lhs.value() >= l);
+ gray tmp(lhs.nbits(),
+ lhs.value() - l);
+ return tmp;
+ }
+ else
+ {
+ unsigned long l = lhs.to_nbits(rhs.nbits()).value();
+ assert(l >= rhs.value());
+ gray tmp(rhs.nbits(),
+ l - rhs.value());
+ return tmp;
+ }
+ }
+
+ gray operator*(int s, const gray& rhs)
+ {
+ mln_precondition(s >= 0);
+ gray tmp(rhs.nbits(), rhs.value() * s);
+ return tmp;
+ }
+
+ gray operator*(const gray& lhs, int s)
+ {
+ mln_precondition(s >= 0);
+ gray tmp(lhs.nbits(), lhs.value() * s);
+ return tmp;
+ }
+
+ gray operator/(const gray& lhs, int s)
+ {
+ mln_precondition(s > 0);
+ gray tmp(lhs.nbits(), lhs.value() / s);
+ return tmp;
+ }
+
+// template <unsigned N>
+// graylevel<N>&
+// graylevel<N>::operator=(const gray& g)
+// {
+// mln_precondition(g.nbits() == N);
+// assert(g.value() < internal::two_pow_(N));
+// this->val = g.value(); // FIXME: Add static_cast.
+// }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::value
+
+} // end of namespace mln
+
+
+#endif // ! MLN_VALUE_GRAY_HH
https://svn.lrde.epita.fr/svn/oln/trunk/milena
Index: ChangeLog
from Thierry Geraud <thierry.geraud(a)lrde.epita.fr>
A lot of cleaning works.
Make the exact routines work with any data.
* mln/core/concept/object.hh (exact_t): New typedef.
* mln/core/internal/exact.hh: New.
* mln/core/exact.hh (exact): Update.
(exact): Remove overloads with const; useless.
* tests/core_exact.cc: New.
Rename init as initialize.
* mln/core/concept/image.hh (init): Rename as...
(initialize): ...this.
* tests/core_init.cc: Rename as...
* tests/core_initialize.cc: ...this.
Update.
* tests/image_if.cc,
* mln/core/clone.hh,
* mln/canvas/morpho/algebraic_union_find.hh,
* mln/canvas/labeling.hh: Update.
Augment and clean mln/metal.
* mln/metal/is_const.hh: New.
* mln/core/internal/image_morpher.hh: New include.
* mln/metal/goes_to.hh: New.
* mln/metal/converts_to.hh: New.
* mln/metal/is.hh: New.
* mln/metal/is_unqualif.hh: New.
* tests/metal_converts_to.cc: New.
* tests/metal_is.cc: New.
* tests/metal_unconst.cc: New.
* mln/metal/unqualif.hh: Add FIXME.
* mln/metal/unconst.hh: New overload.
Add FIXME.
* mln/metal/bool.hh (true_, false_): New aliases.
(eval, check): New in bool_<true>.
(eval, check_not): New in bool_<false>.
(to_bool): Remove.
* mln/metal/bexpr.hh (true_, false_): Remove; obsolete.
(mlc_not, mlc_and, mlc_or, mlc_xor): New.
* mln/metal/if.hh,
* mln/metal/all.hh,
* mln/metal/is_a.hh: Update.
* mln/fun/internal/selector.hh (tag_): Update.
* mln/value/props.hh (mln_is_lowq): Update.
* mln/metal/vec.hh: Fix missing inheritance.
Fix warning about missing cpy ctor.
* mln/metal/binary_arith_trait.hh: Add FIXME.
* tests/metal_vec.cc,
* tests/metal_mat.cc: Fix doc.
Start factoring the conversion op.
* mln/accu/internal: New directory.
* mln/accu/internal/base.hh: New.
* mln/core/concept/accumulator.hh: Augment todo entry.
* mln/accu/median.hh: Update inheritance.
* mln/level/fast_median.hh (to_result): Remove; useless.
Start trace mechanism.
* mln/trace: New directory.
* mln/trace/exiting.hh: New.
* mln/trace/quiet.hh: New.
* mln/trace/all.hh: New.
* mln/trace/entering.hh: New.
* tests/level_paste.cc: Add tracing calls.
Better browsing materials.
* mln/core/concept/browsing.hh: New.
* mln/canvas/browsing/fwd.hh: New.
* mln/canvas/browsing/snake_fwd.hh: Update.
* mln/fun/p2v/iota.hh: New.
* tests/canvas_browsing_fwd.cc: New.
Better and update image traits.
* mln/trait/images.hh: New bunch of macros.
(category): New.
(io): Add new flag types.
(default_image_, default_image_morpher_): Clean.
Fix comments.
* mln/core/image2d_b.hh (image_): Move at bof.
* mln/core/image1d_b.hh,
* mln/core/image3d_b.hh,
* mln/core/image_if.hh,
* mln/pw/image.hh (image_): New traits.
* mln/core/sub_image.hh: Update traits.
* mln/level/fill.hh (todo): Augment.
(fill): Check input writability.
* mln/level/paste.hh,
* mln/morpho/plus.hh,
* mln/morpho/min.hh,
* mln/morpho/minus.hh,
* mln/morpho/complementation.hh,
* mln/morpho/dilation.hh,
* mln/morpho/erosion.hh,
* mln/morpho/hit_or_miss.hh: Update with trait flags.
* tests/level_fill.cc: Add into comments an anti-test.
* tests/trait_images.cc: Update.
Introduce the notion of interval of values.
* mln/value/interval.hh: New.
* mln/value/all.hh: Update.
* mln/core/image_if.hh: New overload using interval.
Misc.
* mln/border/get.hh: Fix warning.
* mln/core/macros.hh (mln_result_): New.
* mln/core/ops.hh: New todo entry.
* mln/fun/ops.hh: Shorter names.
* mln/util/nil.hh: New.
* mln/util/ignore.hh,
* mln/util/eat.hh: Fix missing inheritance.
* TODO: Augment.
TODO | 18 ++
mln/accu/internal/base.hh | 93 ++++++++++++
mln/accu/median.hh | 4
mln/border/get.hh | 2
mln/canvas/browsing/fwd.hh | 103 ++++++++++++++
mln/canvas/browsing/snake_fwd.hh | 12 +
mln/canvas/labeling.hh | 8 -
mln/canvas/morpho/algebraic_union_find.hh | 10 -
mln/core/clone.hh | 2
mln/core/concept/accumulator.hh | 2
mln/core/concept/browsing.hh | 79 ++++++++++
mln/core/concept/image.hh | 4
mln/core/concept/object.hh | 8 -
mln/core/exact.hh | 48 ++----
mln/core/image1d_b.hh | 23 +++
mln/core/image2d_b.hh | 41 +++--
mln/core/image3d_b.hh | 23 +++
mln/core/image_if.hh | 88 +++++++++++-
mln/core/internal/exact.hh | 124 +++++++++++++++++
mln/core/internal/image_morpher.hh | 1
mln/core/macros.hh | 1
mln/core/ops.hh | 2
mln/core/sub_image.hh | 47 +++---
mln/fun/internal/selector.hh | 2
mln/fun/ops.hh | 16 +-
mln/fun/p2v/iota.hh | 102 ++++++++++++++
mln/level/fast_median.hh | 6
mln/level/fill.hh | 3
mln/level/paste.hh | 42 +++--
mln/metal/all.hh | 26 +++
mln/metal/bexpr.hh | 40 +----
mln/metal/binary_arith_trait.hh | 3
mln/metal/bool.hh | 36 +++--
mln/metal/converts_to.hh | 79 ++++++++++
mln/metal/goes_to.hh | 64 ++++++++
mln/metal/if.hh | 2
mln/metal/is.hh | 90 ++++++++++++
mln/metal/is_a.hh | 2
mln/metal/is_const.hh | 62 ++++++++
mln/metal/is_unqualif.hh | 53 +++++++
mln/metal/unconst.hh | 9 +
mln/metal/unqualif.hh | 3
mln/metal/vec.hh | 23 ++-
mln/morpho/complementation.hh | 2
mln/morpho/dilation.hh | 2
mln/morpho/erosion.hh | 2
mln/morpho/hit_or_miss.hh | 2
mln/morpho/min.hh | 4
mln/morpho/minus.hh | 2
mln/morpho/plus.hh | 2
mln/pw/image.hh | 25 +++
mln/trace/all.hh | 52 +++++++
mln/trace/entering.hh | 67 +++++++++
mln/trace/exiting.hh | 67 +++++++++
mln/trace/quiet.hh | 51 +++++++
mln/trait/images.hh | 216 +++++++++++++++++++-----------
mln/util/eat.hh | 2
mln/util/ignore.hh | 2
mln/util/nil.hh | 97 +++++++++++++
mln/value/all.hh | 2
mln/value/interval.hh | 101 ++++++++++++++
mln/value/props.hh | 2
tests/canvas_browsing_fwd.cc | 100 +++++++++++++
tests/core_exact.cc | 54 +++++++
tests/core_initialize.cc | 12 -
tests/image_if.cc | 2
tests/level_fill.cc | 7
tests/level_paste.cc | 2
tests/metal_converts_to.cc | 84 +++++++++++
tests/metal_is.cc | 82 +++++++++++
tests/metal_mat.cc | 4
tests/metal_unconst.cc | 93 ++++++++++++
tests/metal_vec.cc | 4
tests/trait_images.cc | 7
74 files changed, 2280 insertions(+), 277 deletions(-)
Index: tests/metal_mat.cc
--- tests/metal_mat.cc (revision 1201)
+++ tests/metal_mat.cc (working copy)
@@ -25,9 +25,9 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-/*! \file tests/level_median.cc
+/*! \file tests/metal_mat.cc
*
- * \brief Test on mln::median::median_dir.
+ * \brief Test on mln::metal::mat.
*/
#include <mln/metal/mat.hh>
Index: tests/core_initialize.cc
--- tests/core_initialize.cc (revision 1199)
+++ tests/core_initialize.cc (working copy)
@@ -25,9 +25,9 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-/*! \file tests/core_init.cc
+/*! \file tests/core_initialize.cc
*
- * \brief Tests on mln::init.
+ * \brief Tests on mln::initialize.
*/
#include <mln/core/image2d_b.hh>
@@ -47,7 +47,7 @@
{
I ima;
- init(ima, ref);
+ initialize(ima, ref);
debug::println(ima);
mln_assertion(ima.border() = ref.border());
}
@@ -55,19 +55,19 @@
{
I ima_; // to init'd
sub_image<I, box2d> ima = ref | b;
- init(ima_, ima);
+ initialize(ima_, ima);
debug::println(ima);
}
{
sub_image<I, box2d> ima;
- init(ima, ref);
+ initialize(ima, ref);
debug::println(ima);
}
{
sub_image<I, box2d> ima;
- init(ima, ref | b);
+ initialize(ima, ref | b);
debug::println(ima);
}
Index: tests/core_exact.cc
--- tests/core_exact.cc (revision 0)
+++ tests/core_exact.cc (revision 0)
@@ -0,0 +1,54 @@
+// 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.
+
+/*! \file tests/core_exact.cc
+ *
+ * \brief Tests on mln::exact.
+ */
+
+#include <typeinfo>
+#include <mln/core/exact.hh>
+
+
+struct test : mln::Object< test >
+{
+};
+
+
+int main()
+{
+ using namespace mln;
+
+ test t;
+ std::cout << typeid(exact(t)).name() << std::endl;;
+
+ Object<test>& t_ = t;
+ std::cout << typeid(exact(t_)).name() << std::endl;;
+
+ int i;
+ std::cout << typeid(exact(i)).name() << std::endl;;
+}
Index: tests/level_fill.cc
--- tests/level_fill.cc (revision 1201)
+++ tests/level_fill.cc (working copy)
@@ -31,6 +31,7 @@
*/
#include <mln/core/image2d_b.hh>
+#include <mln/core/sub_image.hh>
#include <mln/level/fill.hh>
#include <mln/debug/println.hh>
@@ -60,4 +61,10 @@
level::fill(ima, uc);
}
+// {
+// // do *not* compile so that's great since ima is not mutable
+// sub_image< const image2d_b<int>, box2d > ima;
+// level::fill(ima, 0);
+// }
+
}
Index: tests/metal_vec.cc
--- tests/metal_vec.cc (revision 1201)
+++ tests/metal_vec.cc (working copy)
@@ -25,9 +25,9 @@
// reasons why the executable file might be covered by the GNU General
// Public License.
-/*! \file tests/level_median.cc
+/*! \file tests/metal_vec.cc
*
- * \brief Test on mln::median::median_dir.
+ * \brief Test on mln::metal::vec.
*/
#include <mln/metal/vec.hh>
Index: tests/metal_converts_to.cc
--- tests/metal_converts_to.cc (revision 0)
+++ tests/metal_converts_to.cc (revision 0)
@@ -0,0 +1,84 @@
+// 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.
+
+/*! \file tests/metal_converts_to.cc
+ *
+ * \brief Test on mln::metal::converts_to.
+ */
+
+#include <mln/metal/converts_to.hh>
+
+
+
+struct from_1
+{
+};
+
+struct dest
+{
+ dest(const from_1&) {}
+};
+
+struct from_2
+{
+ operator dest() const { dest* tmp; return *tmp; }
+};
+
+
+struct base
+{
+};
+
+struct base_
+{
+protected:
+ base_(int) {}
+ base_(const base_&) {}
+};
+
+struct derived : base, base_
+{
+ derived() : base(), base_(0) {}
+};
+
+
+int main()
+{
+ using namespace mln;
+
+ metal::converts_to<int, float>::check();
+
+ metal::converts_to<from_1, dest>::check();
+ metal::converts_to<from_2, dest>::check();
+
+ metal::converts_to<derived*, base*>::check();
+ metal::converts_to<derived, base>::check();
+ metal::converts_to<derived, const base>::check();
+
+// metal::converts_to<derived, base_>::check_not();
+// metal::converts_to<derived, const base_>::check_not();
+}
Index: tests/metal_is.cc
--- tests/metal_is.cc (revision 0)
+++ tests/metal_is.cc (revision 0)
@@ -0,0 +1,82 @@
+// 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.
+
+/*! \file tests/metal_is.cc
+ *
+ * \brief Test on mln::metal::is.
+ */
+
+#include <mln/metal/is.hh>
+
+
+
+struct from_1
+{
+};
+
+struct dest
+{
+ dest(const from_1&) {}
+};
+
+struct from_2
+{
+ operator dest() const { dest* tmp; return *tmp; }
+};
+
+
+struct base
+{
+protected: base() {}
+};
+
+struct derived : base
+{
+};
+
+
+struct only
+{
+};
+
+
+int main()
+{
+ using namespace mln;
+
+ metal::is<only, only>::check();
+
+ metal::is<derived, base>::check();
+ metal::is<derived, const base>::check();
+ metal::is<derived*, const base*>::check();
+ metal::is<derived&, base&>::check();
+ metal::is<derived&, const base&>::check();
+
+ metal::is<int, float>::check_not();
+ metal::is<from_1, dest>::check_not();
+ metal::is<from_2, dest>::check_not();
+}
Index: tests/image_if.cc
--- tests/image_if.cc (revision 1201)
+++ tests/image_if.cc (working copy)
@@ -56,7 +56,7 @@
}
{
II ima_;
- init(ima_, ima_ref);
+ initialize(ima_, ima_ref);
debug::println(ima_);
}
}
Index: tests/level_paste.cc
--- tests/level_paste.cc (revision 1201)
+++ tests/level_paste.cc (working copy)
@@ -53,6 +53,8 @@
debug::iota(ima2);
debug::println(ima2);
+ trace::quiet = false;
+
level::paste(ima, ima2); // Fast version.
debug::println(ima2);
Index: tests/trait_images.cc
--- tests/trait_images.cc (revision 1201)
+++ tests/trait_images.cc (working copy)
@@ -31,7 +31,10 @@
*/
#include <mln/core/image2d_b.hh>
+
#include <mln/core/sub_image.hh>
+#include <mln/core/image_if.hh>
+#include <mln/fun/p2b/chess.hh>
int main()
@@ -46,4 +49,8 @@
std::cout << std::endl
<< "sub_image< image2d_b >: ";
mln::trait::print< sub_image<I, box2d> >(std::cout);
+
+ std::cout << std::endl
+ << "image_if< image2d_b >: ";
+ mln::trait::print< image_if<I, fun::p2b::chess_t> >(std::cout);
}
Index: tests/metal_unconst.cc
--- tests/metal_unconst.cc (revision 0)
+++ tests/metal_unconst.cc (revision 0)
@@ -0,0 +1,93 @@
+// 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.
+
+/*! \file tests/metal_unconst.cc
+ *
+ * \brief Test on mln::metal::unconst.
+ */
+
+#include <typeinfo>
+#include <string>
+
+#include <mln/metal/unconst.hh>
+#include <mln/core/exact.hh>
+
+
+
+int main()
+{
+ using namespace mln;
+
+ {
+ mlc_unconst_(int) var; // int
+ var = 0;
+ // void* v = var;
+ }
+ {
+ mlc_unconst_(const int) var; // int
+ var = 0;
+ // void* v = var;
+ }
+
+ {
+ mlc_unconst_(int*) var; // int*
+ var = 0;
+ // void v = var;
+ }
+ {
+ mlc_unconst_(const int*) var; // const int*
+ var = 0;
+ // void v = var;
+ }
+ {
+ mlc_unconst_(int *const) var; // int*
+ var = 0;
+ // void v = var;
+ }
+ {
+ mlc_unconst_(const int *const) var; // const int*
+ var = 0;
+ // void v = var;
+ }
+
+
+ {
+ int tmp = 0;
+ mlc_unconst_(int&) var = tmp; // int&
+ tmp = 51;
+ mln_assertion(var = 51);
+ // void* v = var;
+ }
+ {
+ int tmp = 0;
+ mlc_unconst_(const int&) var = tmp; // int&
+ tmp = 51;
+ mln_assertion(var = 51);
+ // void* v = var;
+ }
+
+}
Index: tests/canvas_browsing_fwd.cc
--- tests/canvas_browsing_fwd.cc (revision 0)
+++ tests/canvas_browsing_fwd.cc (revision 0)
@@ -0,0 +1,100 @@
+// 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.
+
+/*! \file tests/canvas_browsing_fwd.cc
+ *
+ * \brief Tests on mln::canvas::browsing::fwd.
+ */
+
+#include <mln/core/image2d_b.hh>
+#include <mln/canvas/browsing/fwd.hh>
+#include <mln/canvas/browsing/snake_fwd.hh>
+#include <mln/fun/p2v/iota.hh>
+#include <mln/pw/image.hh>
+#include <mln/debug/println.hh>
+
+
+
+// FIXME: Move code below into mln/canvas/browsing/iota.hh.
+
+
+template <typename I_, typename F>
+struct assign_browsing_functor
+{
+ typedef I_ I;
+
+ I input;
+ F f;
+
+ assign_browsing_functor(I& input, F f = F())
+ : input(input),
+ f(f)
+ {}
+
+ mln_psite(I) p;
+
+ void init() {}
+ void final() {}
+ void next()
+ {
+ input(p) = f(p);
+ }
+ void fwd() { next(); }
+ void bkd() { next(); }
+ void down() { next(); }
+};
+
+namespace mln
+{
+
+ template <typename I, typename F, typename B>
+ void my_test(Image<I>& ima_,
+ const Function_p2v<F>& f_,
+ const Browsing<B>& browse_)
+ {
+ I& ima = exact(ima_);
+ const F& f = exact(f_);
+ const B& browse = exact(browse_);
+
+ assign_browsing_functor<I, F> fun(ima, f);
+ browse(fun);
+ }
+
+}
+
+
+int main()
+{
+ using namespace mln;
+ image2d_b<unsigned> ima(3, 3);
+
+ my_test(ima, fun::p2v::iota, canvas::browsing::fwd);
+ debug::println(ima);
+
+ my_test(ima, fun::p2v::iota, canvas::browsing::snake_fwd);
+ debug::println(ima);
+}
Index: TODO
--- TODO (revision 1201)
+++ TODO (working copy)
@@ -1,6 +1,24 @@
-*- outline -*-
+* URGENT
+
+** accu
+
+*** héritage
+toutes les classes d'accu dérivent de base_ ; Cf. accu/median.hh
+virer l'op de convertion dans median_alt.hh
+ajouter le test de présence de l'op de convertion dans Accumulator
+m-a-j de la doc
+est-ce les tests tournent ?
+
+*** value -> argument
+m-a-j
+tests ?
+
+
+
+
* large changes
introduce grids
Index: mln/trait/images.hh
--- mln/trait/images.hh (revision 1201)
+++ mln/trait/images.hh (working copy)
@@ -31,18 +31,46 @@
/*! \file mln/core/trait/images.hh
*
* \brief Forward declarations of all image types.
+ *
+ * \todo Split this file into many.
*/
# include <iostream>
# include <string>
# include <mln/value/props.hh>
-# include <mln/metal/if.hh>
-# include <mln/metal/bool.hh>
+# include <mln/metal/all.hh>
+
+
+# define mln_trait_image_category(I) typename mln::trait::image_< I >::category
+# define mln_trait_image_kind(I) typename mln::trait::image_< I >::kind
+# define mln_trait_image_quant(I) typename mln::trait::image_< I >::quant
+# define mln_trait_image_value(I) typename mln::trait::image_< I >::value
+# define mln_trait_image_access(I) typename mln::trait::image_< I >::access
+# define mln_trait_image_space(I) typename mln::trait::image_< I >::space
+# define mln_trait_image_size(I) typename mln::trait::image_< I >::size
+# define mln_trait_image_support(I) typename mln::trait::image_< I >::support
+# define mln_trait_image_border(I) typename mln::trait::image_< I >::border
# define mln_trait_image_data(I) typename mln::trait::image_< I >::data
+# define mln_trait_image_io(I) typename mln::trait::image_< I >::io
+# define mln_trait_image_speed(I) typename mln::trait::image_< I >::speed
+
+
+// for io: I const => read_only, otherwise like I
+# define mln_trait_image_io_from_(I) \
+mlc_if( mlc_is_const(I), mln::trait::io::read_only, mln_trait_image_io(I) )
+
+// for data: if raw or linear => stored, otherwise like I (i.e., either stored or computed)
+#define mln_trait_image_data_from_(I) typename \
+mln::metal::if_< mln::metal::or_< mlc_equal( mln_trait_image_data(I), \
+ mln::trait::data::raw), \
+ mlc_equal( mln_trait_image_data(I), \
+ mln::trait::data::linear) >, \
+ mln::trait::data::stored, \
+ mln_trait_image_data(I) >::ret
namespace mln
@@ -76,21 +104,25 @@
template <typename I>
struct undefined_image_
{
+ typedef undef category; // primary, domain_morpher, value_morpher,
+ // or identity_morpher < morpher
+
// related to I::value
- typedef undef kind; // color, gray, binary < label, data
+ typedef undef kind; // color, gray, binary < logic < label, data
typedef undef quant; // low or high
- typedef undef value; // scalar, vectorial, structed
+ typedef undef value; // scalar, vectorial, structed, pointer
+ // FIXME: Make the difference between homogeneous and heterogeneous vectors...
// related to I::pset
- typedef undef access; // random, browse
+ typedef undef access; // random, browsing
typedef undef space; // one_d, two_d, three_d
typedef undef size; // huge or regular
typedef undef support; // irregular, aligned < regular
// global
typedef undef border; // none, stored, computed
- typedef undef data; // linear < stored, computed
- typedef undef io; // read_only < read_write
+ typedef undef data; // raw < linear < stored, computed
+ typedef undef io; // read_only < read, write_only < write, read_write < both read'n write
typedef undef speed; // slow, fast, or fastest
};
@@ -101,133 +133,171 @@
};
- template <typename I>
- void print(std::ostream& ostr)
- {
- typedef image_<I> the;
- ostr << "{ "
- << the::data().str() << ", "
- << the::kind().str() << ", "
- << the::quant().str() << ", "
- << the::value().str() << ", "
- << the::access().str() << ", "
- << the::space().str() << ", "
- << the::size().str() << ", "
- << the::support().str() << ", "
- << the::border().str() << ", "
- << the::io().str() << ", "
- << the::speed().str() << " }" << std::endl;
- }
+ struct category
+ {
+ struct any {};
+ struct primary : any { std::string str() const { return "category::primary"; } };
+ struct morpher : any {};
+ struct domain_morpher
+ : morpher { std::string str() const { return "category::domain_morpher"; } };
+ struct value_morpher
+ : morpher { std::string str() const { return "category::value_morpher"; } };
+ struct identity_morpher
+ : morpher { std::string str() const { return "category::identity_morpher"; } };
+ };
struct data
{
- struct computed { std::string str() const { return "data::computed"; } };
- struct stored { std::string str() const { return "data::stored"; } };
- struct linear : stored { std::string str() const { return "data::linear"; } };
+ struct any {};
+ struct computed : any { std::string str() const { return "data::computed"; } };
+ struct stored : any { std::string str() const { return "data::stored"; } };
+ struct linear
+ : stored { std::string str() const { return "data::linear"; } };
+ struct raw
+ : linear { std::string str() const { return "data::raw"; } };
};
struct quant
{
- struct low { std::string str() const { return "quant::low"; } };
- struct high { std::string str() const { return "quant::high"; } };
+ struct any {};
+ struct low : any { std::string str() const { return "quant::low"; } };
+ struct high : any { std::string str() const { return "quant::high"; } };
};
struct value
{
- struct scalar { std::string str() const { return "value::scalar"; } };
- struct vectorial { std::string str() const { return "value::vectorial"; } };
- struct structed { std::string str() const { return "value::structed"; } };
+ struct any {};
+ struct scalar : any { std::string str() const { return "value::scalar"; } };
+ struct vectorial : any { std::string str() const { return "value::vectorial"; } };
+ struct structed : any { std::string str() const { return "value::structed"; } };
+ struct pointer : any { std::string str() const { return "value::pointer"; } };
};
struct access
{
- struct random { std::string str() const { return "access::random"; } };
- struct iterative { std::string str() const { return "access::iterative"; } };
+ struct any {};
+ struct random : any { std::string str() const { return "access::random"; } };
+ struct browsing : any { std::string str() const { return "access::browsing"; } };
};
struct space
{
- struct one_d { std::string str() const { return "space::one_d"; } };
- struct two_d { std::string str() const { return "space::two_d"; } };
- struct three_d { std::string str() const { return "space::three_d"; } };
+ struct any {};
+ struct one_d : any { std::string str() const { return "space::one_d"; } };
+ struct two_d : any { std::string str() const { return "space::two_d"; } };
+ struct three_d : any { std::string str() const { return "space::three_d"; } };
+
+ struct fixme // So FIXME!
+ : any { std::string str() const { return "space::fixme"; } };
};
struct size
{
- struct huge { std::string str() const { return "size::huge"; } };
- struct regular { std::string str() const { return "size::regular"; } };
+ struct any {};
+ struct huge : any { std::string str() const { return "size::huge"; } };
+ struct regular : any { std::string str() const { return "size::regular"; } };
};
struct support
{
- struct irregular { std::string str() const { return "support::irregular"; } };
- struct regular { std::string str() const { return "support::regular"; } };
- struct aligned : regular { std::string str() const { return "support::aligned"; } };
+ struct any {};
+ struct irregular : any { std::string str() const { return "support::irregular"; } };
+ struct regular : any { std::string str() const { return "support::regular"; } };
+ struct aligned
+ : regular { std::string str() const { return "support::aligned"; } };
+
+ struct fixme // So FIXME!
+ : any { std::string str() const { return "support::fixme"; } };
};
struct border
{
- struct none { std::string str() const { return "border::none"; } };
- struct stored { std::string str() const { return "border::stored"; } };
- struct computed { std::string str() const { return "border::computed"; } };
+ struct any {};
+ struct none : any { std::string str() const { return "border::none"; } };
+ struct stored : any { std::string str() const { return "border::stored"; } };
+ struct computed : any { std::string str() const { return "border::computed"; } };
};
struct io
{
- struct read_only { std::string str() const { return "io::read_only"; } };
- struct read_write { std::string str() const { return "io::read_write"; } };
+ struct any {};
+ struct read : virtual any {};
+ struct write : virtual any {};
+ struct read_only
+ : read { std::string str() const { return "io::read_only"; } };
+ struct write_only
+ : write { std::string str() const { return "io::write_only"; } };
+ struct read_write
+ : read, write { std::string str() const { return "io::read_write"; } };
};
struct speed
{
- struct slow { std::string str() const { return "speed::slow"; } };
- struct fast { std::string str() const { return "speed::fast"; } };
- struct fastest { std::string str() const { return "speed::fastest"; } };
+ struct any {};
+ struct slow : any { std::string str() const { return "speed::slow"; } };
+ struct fast : any { std::string str() const { return "speed::fast"; } };
+ struct fastest
+ : fast { std::string str() const { return "speed::fastest"; } };
};
-
template <typename I>
+ void print(std::ostream& ostr)
+ {
+ typedef image_<I> the;
+ ostr << "{ "
+ << typename the::category().str() << ", "
+ << typename the::data().str() << ", "
+ << typename the::kind().str() << ", "
+ << typename the::quant().str() << ", "
+ << typename the::value().str() << ", "
+ << typename the::access().str() << ", "
+ << typename the::space().str() << ", "
+ << typename the::size().str() << ", "
+ << typename the::support().str() << ", "
+ << typename the::border().str() << ", "
+ << typename the::io().str() << ", "
+ << typename the::speed().str() << " }" << std::endl;
+ }
+
+
+
+ template <typename T, typename I>
struct default_image_ : undefined_image_<I>
{
private:
- typedef mln_value(I) T_;
- typedef metal::bool_<( mln_value_card_(T_) != 0 )> is_high_quant_;
+ typedef metal::bool_<( mln_value_card_(T) = 0 )> is_high_quant_;
public:
- typedef mln_value_kind(T_) kind;
+ typedef mln_value_kind(T) kind;
typedef mlc_if( is_high_quant_, trait::quant::high, trait::quant::low ) quant;
// FIXME: typedef undef value; // scalar, vectorial, structed
+
+ // speed is fast by default (neither "fastest" nor "slow")
+ typedef trait::speed::fast speed;
};
- template <typename I>
- struct default_image_morpher_ : default_image_<I>
+ template <typename D, typename T, typename I>
+ struct default_image_morpher_ : default_image_<T, I>
{
- private:
- typedef typename I::delegatee D_;
- public:
-
// value-related => delegation
- typedef typename image_<D_>::kind kind;
- typedef typename image_<D_>::quant quant;
- typedef typename image_<D_>::value value;
+ typedef typename image_<D>::kind kind;
+ typedef typename image_<D>::quant quant;
+ typedef typename image_<D>::value value;
// domain-related => delegation
- typedef typename image_<D_>::access access;
- typedef typename image_<D_>::space space;
- typedef typename image_<D_>::size size;
- typedef typename image_<D_>::support support;
+ typedef typename image_<D>::access access;
+ typedef typename image_<D>::space space;
+ typedef typename image_<D>::size size;
+ typedef typename image_<D>::support support;
// mostly global-related => delegation
- typedef typename image_<D_>::border border;
- typedef typename image_<D_>::data data;
- typedef typename image_<D_>::io io;
-
- // *but* speed is fast by default (not fastest!)
- typedef trait::speed::fast speed;
+ typedef typename image_<D>::border border;
+ typedef typename image_<D>::data data;
+ typedef typename image_<D>::io io;
};
Index: mln/core/macros.hh
--- mln/core/macros.hh (revision 1201)
+++ mln/core/macros.hh (working copy)
@@ -149,6 +149,7 @@
/// Shortcut to access the result type associated to T.
# define mln_result(T) typename T::result
+# define mln_result_(T) T::result
/// Shortcut to access the rvalue type associated to T.
# define mln_rvalue(T) typename T::rvalue
Index: mln/core/image_if.hh
--- mln/core/image_if.hh (revision 1201)
+++ mln/core/image_if.hh (working copy)
@@ -36,6 +36,7 @@
# include <mln/core/internal/image_domain_morpher.hh>
# include <mln/core/pset_if.hh>
# include <mln/pw/all.hh>
+# include <mln/value/interval.hh>
namespace mln
@@ -60,7 +61,36 @@
} // end of namespace mln::internal
- /*! \brief A base class for image adaptors.
+
+ namespace trait
+ {
+
+ template <typename I, typename F>
+ struct image_< image_if<I,F> > : default_image_morpher_< I, mln_value(I),
+ image_if<I,F> >
+ {
+ private:
+ typedef mln_trait_image_data(I) I_data_;
+ typedef mlc_equal(I_data_, trait::data::linear) I_data_are_linear_;
+ public:
+
+ typedef trait::category::domain_morpher category;
+
+ typedef mlc_if( mlc_is_const(I),
+ trait::io::read_only, // I const => read_only
+ mln_trait_image_io(I) ) io; // otherwise like I
+
+ typedef mlc_if( I_data_are_linear_,
+ trait::data::stored, // if linear then just stored
+ I_data_ ) data; // otherwise like I
+ };
+
+ } // end of namespace mln::trait
+
+
+
+
+ /*! \brief An image class FIXME.
*
*/
template <typename I, typename F>
@@ -95,8 +125,11 @@
+
// Operators.
+ // Image | Function_p2b.
+
template <typename I, typename F>
image_if<I, F>
operator | (Image<I>& ima, const Function_p2b<F>& f);
@@ -105,20 +138,37 @@
image_if<const I, F>
operator | (const Image<I>& ima, const Function_p2b<F>& f);
+ // Image | value.
+
template <typename I>
image_if< I,
- fun::equal_p2b_expr_< pw::value_<I>,
+ fun::eq_p2b_expr_< pw::value_<I>,
pw::cst_<mln_value(I)> > >
operator | (Image<I>& ima, const mln_value(I)& v);
template <typename I>
image_if< const I,
- fun::equal_p2b_expr_< pw::value_<I>,
+ fun::eq_p2b_expr_< pw::value_<I>,
pw::cst_<mln_value(I)> > >
operator | (const Image<I>& ima, const mln_value(I)& v);
- // FIXME: Add the notion of "interval of values"...
- // FIXME: so we can write: ima | from_to(v1, v2)
+ // Image | [from, to].
+
+ template <typename I>
+ image_if< I,
+ fun::and_p2b_expr_< fun::geq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> >,
+ fun::leq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> > > >
+ operator | (Image<I>& ima, const value::interval_<mln_value(I)>& vv);
+
+ template <typename I>
+ image_if< const I,
+ fun::and_p2b_expr_< fun::geq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> >,
+ fun::leq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> > > >
+ operator | (const Image<I>& ima, const value::interval_<mln_value(I)>& vv);
@@ -239,7 +289,7 @@
template <typename I>
image_if< I,
- fun::equal_p2b_expr_< pw::value_<I>,
+ fun::eq_p2b_expr_< pw::value_<I>,
pw::cst_<mln_value(I)> > >
operator | (Image<I>& ima, const mln_value(I)& v)
{
@@ -248,13 +298,37 @@
template <typename I>
image_if< const I,
- fun::equal_p2b_expr_< pw::value_<I>,
+ fun::eq_p2b_expr_< pw::value_<I>,
pw::cst_<mln_value(I)> > >
operator | (const Image<I>& ima, const mln_value(I)& v)
{
return ima | (pw::value(ima) = pw::cst(v));
}
+ template <typename I>
+ image_if< I,
+ fun::and_p2b_expr_< fun::geq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> >,
+ fun::leq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> > > >
+ operator | (Image<I>& ima, const value::interval_<mln_value(I)>& vv)
+ {
+ return ima | ( (pw::value(ima) >= pw::cst(vv.from)) &&
+ (pw::value(ima) <= pw::cst(vv.to)) );
+ }
+
+ template <typename I>
+ image_if< const I,
+ fun::and_p2b_expr_< fun::geq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> >,
+ fun::leq_p2b_expr_< pw::value_<I>,
+ pw::cst_<mln_value(I)> > > >
+ operator | (const Image<I>& ima, const value::interval_<mln_value(I)>& vv)
+ {
+ return ima | ( (pw::value(ima) >= pw::cst(vv.from)) &&
+ (pw::value(ima) <= pw::cst(vv.to)) );
+ }
+
# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln
Index: mln/core/exact.hh
--- mln/core/exact.hh (revision 1201)
+++ mln/core/exact.hh (working copy)
@@ -32,7 +32,7 @@
* \brief Definition of the mln::exact downcast routines.
*/
-# include <mln/core/concept/object.hh>
+# include <mln/core/internal/exact.hh>
namespace mln
@@ -51,49 +51,33 @@
*/
/// \{
- template <typename E>
- E* exact(Object<E>* ptr);
-
- template <typename E>
- const E* exact(const Object<E>* ptr);
-
- template <typename E>
- E& exact(Object<E>& ref);
-
- template <typename E>
- const E& exact(const Object<E>& ref);
+ template <typename T>
+ typename internal::exact_<T>::ret*
+ exact(T* ptr);
+
+ template <typename T>
+ typename internal::exact_<T>::ret&
+ exact(T& ref);
/// \}
-
-
# ifndef MLN_INCLUDE_ONLY
// exact
- template <typename E>
- E* exact(Object<E>* ptr)
- {
- return (E*)(void*)ptr;
- }
-
- template <typename E>
- const E* exact(const Object<E>* ptr)
- {
- return (const E*)(const void*)ptr;
- }
-
- template <typename E>
- E& exact(Object<E>& ref)
+ template <typename T>
+ typename internal::exact_<T>::ret*
+ exact(T* ptr)
{
- return *(E*)(void*)(&ref);
+ return internal::exact_<T>::run(ptr);
}
- template <typename E>
- const E& exact(const Object<E>& ref)
+ template <typename T>
+ typename internal::exact_<T>::ret&
+ exact(T& ref)
{
- return *(const E*)(const void*)(&ref);
+ return *exact(&ref);
}
# endif // ! MLN_INCLUDE_ONLY
Index: mln/core/internal/exact.hh
--- mln/core/internal/exact.hh (revision 0)
+++ mln/core/internal/exact.hh (revision 0)
@@ -0,0 +1,124 @@
+// 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_CORE_INTERNAL_EXACT_HH
+# define MLN_CORE_INTERNAL_EXACT_HH
+
+/*! \file mln/core/internal/exact.hh
+ * \brief Meta-code for the mln::exact downcast routines.
+ */
+
+# include <mln/core/concept/object.hh>
+
+
+namespace mln
+{
+
+ namespace internal
+ {
+
+ typedef char yes_;
+ struct no_ { char dummy[2]; };
+
+ template <typename T>
+ struct make_
+ {
+ static T* ptr();
+ };
+
+ template <unsigned id, typename T>
+ struct exact_ret_;
+
+ template <typename T>
+ struct exact_ret_< 1, T >
+ {
+ typedef typename T::exact_t ret;
+ };
+
+ template <typename T>
+ struct exact_ret_< 2, T >
+ {
+ typedef T ret;
+ };
+
+ template <typename E, typename T>
+ yes_ exact_selector_(Object<E>*, T*);
+
+ template <typename T>
+ no_ exact_selector_(void*, T* t);
+
+ template <typename E, typename T>
+ E* exact_run_(Object<E>* t, T*);
+
+ template <typename T>
+ T* exact_run_(void*, T* t);
+
+ template <typename T>
+ struct exact_
+ {
+ enum { id = sizeof(exact_selector_(make_<T>::ptr(),make_<T>::ptr())) };
+ typedef typename exact_ret_<id, T>::ret ret;
+ static ret* run(T* t)
+ {
+ return exact_run_(t, t);
+ }
+ };
+
+ template <typename T>
+ struct exact_<const T>
+ {
+ enum { id = sizeof(exact_selector_(make_<T>::ptr(),make_<T>::ptr())) };
+ typedef const typename exact_ret_<id, T>::ret ret;
+ static ret* run(const T* t)
+ {
+ return exact_run_((T*)t, (T*)t);
+ }
+ };
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename E, typename T>
+ E* exact_run_(Object<E>* t, T*)
+ {
+ return (E*)(void*)t;
+ }
+
+ template <typename T>
+ T* exact_run_(void*, T* t)
+ {
+ return t;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::internal
+
+} // end of namespace mln
+
+
+#endif // ! MLN_CORE_INTERNAL_EXACT_HH
Index: mln/core/internal/image_morpher.hh
--- mln/core/internal/image_morpher.hh (revision 1201)
+++ mln/core/internal/image_morpher.hh (working copy)
@@ -35,6 +35,7 @@
# include <mln/core/internal/image_base.hh>
# include <mln/metal/const.hh>
+# include <mln/metal/is_const.hh>
namespace mln
Index: mln/core/image2d_b.hh
--- mln/core/image2d_b.hh (revision 1201)
+++ mln/core/image2d_b.hh (working copy)
@@ -80,6 +80,28 @@
} // end of namespace mln::internal
+ namespace trait
+ {
+
+ template <typename T>
+ struct image_< image2d_b<T> > : default_image_< T, image2d_b<T> >
+ {
+ typedef trait::category::primary category;
+
+ typedef trait::access::random access;
+ typedef trait::space::two_d space;
+ typedef trait::size::regular size;
+ typedef trait::support::aligned support;
+
+ typedef trait::border::stored border;
+ typedef trait::data::raw data;
+ typedef trait::io::read_write io;
+ typedef trait::speed::fastest speed;
+ };
+
+ } // end of namespace mln::trait
+
+
namespace trait
{
@@ -208,25 +230,6 @@
void init_(tag::image_t, mln::image2d_b<T>& target, const J& model);
- namespace trait
- {
-
- template <typename T>
- struct image_< image2d_b<T> > : default_image_< image2d_b<T> >
- {
- typedef trait::access::random access;
- typedef trait::space::two_d space;
- typedef trait::size::regular size;
- typedef trait::support::aligned support;
-
- typedef trait::border::stored border;
- typedef trait::data::linear data;
- typedef trait::io::read_write io;
- typedef trait::speed::fastest speed;
- };
-
- } // end of namespace mln::trait
-
# ifndef MLN_INCLUDE_ONLY
Index: mln/core/ops.hh
--- mln/core/ops.hh (revision 1201)
+++ mln/core/ops.hh (working copy)
@@ -30,6 +30,8 @@
/*! \file mln/core/ops.hh
* \brief Definitions of some operators.
+ *
+ * \todo Traits are in mln/trait/ not in mln/metal/!
*/
# include <mln/core/concept/object.hh>
Index: mln/core/sub_image.hh
--- mln/core/sub_image.hh (revision 1201)
+++ mln/core/sub_image.hh (working copy)
@@ -55,6 +55,33 @@
+ namespace trait
+ {
+
+ template <typename I, typename S>
+ struct image_< sub_image<I,S> > : default_image_morpher_< I, mln_value(I),
+ sub_image<I,S> >
+ {
+// private:
+// typedef mln_trait_image_data(I) I_data_;
+// typedef mlc_equal(I_data_, trait::data::linear) I_data_are_linear_;
+// public:
+
+ typedef trait::category::domain_morpher category;
+
+ typedef trait::border::none border; // no more accessible border
+
+ typedef mln_trait_image_io_from_(I) io; // un-write when I const
+
+ typedef mln_trait_image_data_from_(I) data;
+// typedef mlc_if( I_data_are_linear_,
+// trait::data::stored, // if linear then just stored
+// I_data_ ) data; // otherwise like I
+ };
+
+ } // end of namespace mln::trait
+
+
// FIXME: Doc!
@@ -95,26 +122,6 @@
void init_(tag::image_t, sub_image<I,S>& target, const J& model);
- namespace trait
- {
-
- template <typename I, typename S>
- struct image_< sub_image<I,S> > : default_image_morpher_< sub_image<I,S> >
- {
- private:
- typedef mln_trait_image_data(I) I_data_;
- typedef mlc_equal(I_data_, trait::data::linear) I_data_are_linear_;
- public:
-
- typedef trait::border::none border; // no more accessible border
-
- typedef mlc_if( I_data_are_linear_,
- trait::data::stored, // if linear then just stored
- I_data_ ) data; // otherwise like I
- };
-
- } // end of namespace mln::trait
-
# ifndef MLN_INCLUDE_ONLY
Index: mln/core/concept/image.hh
--- mln/core/concept/image.hh (revision 1201)
+++ mln/core/concept/image.hh (working copy)
@@ -110,7 +110,7 @@
* \pre (not target.has_data) and model.has_data
*/
template <typename I, typename J>
- void init(Image<I>& target, const Image<J>& model);
+ void initialize(Image<I>& target, const Image<J>& model);
@@ -165,7 +165,7 @@
}
template <typename I, typename J>
- void init(Image<I>& target, const Image<J>& model)
+ void initialize(Image<I>& target, const Image<J>& model)
{
mln_precondition(! exact(target).has_data());
mln_precondition(exact(model).has_data());
Index: mln/core/concept/browsing.hh
--- mln/core/concept/browsing.hh (revision 0)
+++ mln/core/concept/browsing.hh (revision 0)
@@ -0,0 +1,79 @@
+// 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_CORE_CONCEPT_BROWSING_HH
+# define MLN_CORE_CONCEPT_BROWSING_HH
+
+/*! \file mln/core/concept/browsing.hh
+ * \brief Definition of the concept of mln::Browsing.
+ */
+
+# include <mln/core/concept/object.hh>
+
+
+namespace mln
+{
+
+ /*! \brief Base class for implementation classes that are browsings.
+ *
+ * \see mln::doc::Browsing for a complete documentation of this
+ * class contents.
+ */
+ template <typename E>
+ struct Browsing : public Object<E>
+ {
+ void init();
+ void final();
+
+ protected:
+ Browsing();
+ };
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename E>
+ Browsing<E>::Browsing()
+ {
+ }
+
+ template <typename E>
+ void Browsing<E>::init()
+ {
+ }
+
+ template <typename E>
+ void Browsing<E>::final()
+ {
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+} // end of namespace mln
+
+
+#endif // ! MLN_CORE_CONCEPT_BROWSING_HH
Index: mln/core/concept/object.hh
--- mln/core/concept/object.hh (revision 1201)
+++ mln/core/concept/object.hh (working copy)
@@ -39,12 +39,15 @@
# include <mln/core/macros.hh>
# include <mln/core/contract.hh>
# include <mln/core/internal/fixme.hh>
+# include <mln/trace/all.hh>
# include <mln/metal/is_a.hh>
/*! \namespace mln
* \brief The namespace mln corresponds to the Milena (mini-Olena) project.
*
+ * FIXME: Re-write this description.
+ *
* The contents of mln mimics the contents of the olena project but
* in a simplified way. Some classes have the same name in both
* projects and roughly have the same behavior.
@@ -63,6 +66,7 @@
template <typename E>
struct Object
{
+ typedef E exact_t;
protected:
Object();
};
@@ -81,8 +85,8 @@
# include <mln/core/exact.hh>
-# include <mln/core/ops.hh>
-# include <mln/trait/ch_value.hh>
+# include <mln/metal/all.hh>
+# include <mln/core/ops.hh> // FIXME: Read FIXME in mln/metal/binary_arith_trait.hh!
#endif // ! MLN_CORE_CONCEPT_OBJECT_HH
Index: mln/core/concept/accumulator.hh
--- mln/core/concept/accumulator.hh (revision 1201)
+++ mln/core/concept/accumulator.hh (working copy)
@@ -32,7 +32,7 @@
*
* \brief Definition of the concept of mln::Accumulator.
*
- * \todo Rename value as argument.
+ * \todo Rename value as argument + Add a conversion op.
*/
# include <mln/core/concept/object.hh>
Index: mln/core/clone.hh
--- mln/core/clone.hh (revision 1201)
+++ mln/core/clone.hh (working copy)
@@ -59,7 +59,7 @@
{
// FIXME: Add a static check that mln_concrete(I) actually *is* concrete...
mln_concrete(I) tmp;
- init(tmp, model);
+ initialize(tmp, model);
level::fill(tmp, model);
return tmp;
}
Index: mln/core/image1d_b.hh
--- mln/core/image1d_b.hh (revision 1201)
+++ mln/core/image1d_b.hh (working copy)
@@ -94,6 +94,29 @@
+ namespace trait
+ {
+
+ template <typename T>
+ struct image_< image1d_b<T> > : default_image_< T, image1d_b<T> >
+ {
+ typedef trait::category::primary category;
+
+ typedef trait::access::random access;
+ typedef trait::space::one_d space;
+ typedef trait::size::regular size;
+ typedef trait::support::aligned support;
+
+ typedef trait::border::stored border;
+ typedef trait::data::raw data;
+ typedef trait::io::read_write io;
+ typedef trait::speed::fastest speed;
+ };
+
+ } // end of namespace mln::trait
+
+
+
/*! \brief Basic 1D image class.
*
* The parameter \c T is the type of pixel values. This image class
Index: mln/core/image3d_b.hh
--- mln/core/image3d_b.hh (revision 1201)
+++ mln/core/image3d_b.hh (working copy)
@@ -93,6 +93,29 @@
+ namespace trait
+ {
+
+ template <typename T>
+ struct image_< image3d_b<T> > : default_image_< T, image3d_b<T> >
+ {
+ typedef trait::category::primary category;
+
+ typedef trait::access::random access;
+ typedef trait::space::three_d space;
+ typedef trait::size::regular size;
+ typedef trait::support::aligned support;
+
+ typedef trait::border::stored border;
+ typedef trait::data::raw data;
+ typedef trait::io::read_write io;
+ typedef trait::speed::fastest speed;
+ };
+
+ } // end of namespace mln::trait
+
+
+
/*! \brief Basic 3D image class.
*
* The parameter \c T is the type of pixel values. This image class
Index: mln/metal/is_const.hh
--- mln/metal/is_const.hh (revision 0)
+++ mln/metal/is_const.hh (revision 0)
@@ -0,0 +1,62 @@
+// 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_METAL_IS_CONST_HH
+# define MLN_METAL_IS_CONST_HH
+
+# include <mln/metal/bool.hh>
+
+
+# define mlc_is_const(T) mln::metal::is_const< T >
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ template <typename T>
+ struct is_const : false_
+ {};
+
+ template <typename T>
+ struct is_const< const T > : true_
+ {};
+
+ template <typename T>
+ struct is_const< const T& > : true_
+ {};
+
+ // FIXME: What about "T*const" and "const T*"?
+
+ } // end of namespace mln::metal
+
+} // end of namespace mln
+
+
+#endif // ! MLN_METAL_IS_CONST_HH
Index: mln/metal/unqualif.hh
--- mln/metal/unqualif.hh (revision 1201)
+++ mln/metal/unqualif.hh (working copy)
@@ -34,6 +34,7 @@
# define mlc_unqualif(T) typename mln::metal::unqualif< T >::ret
+# define mlc_unqualif_(T) mln::metal::unqualif< T >::ret
namespace mln
@@ -42,6 +43,8 @@
namespace metal
{
+ // FIXME: May be recursive!
+
template <typename T>
struct unqualif
{
Index: mln/metal/unconst.hh
--- mln/metal/unconst.hh (revision 1201)
+++ mln/metal/unconst.hh (working copy)
@@ -30,6 +30,7 @@
# define mlc_unconst(T) typename mln::metal::unconst< T >::ret
+# define mlc_unconst_(T) mln::metal::unconst< T >::ret
namespace mln
@@ -38,6 +39,8 @@
namespace metal
{
+ // FIXME: What about "const T *const"?
+
template <typename T>
struct unconst
{
@@ -50,6 +53,12 @@
typedef T ret;
};
+ template <typename T>
+ struct unconst< const T& >
+ {
+ typedef T& ret;
+ };
+
} // end of namespace mln::metal
} // end of namespace mln
Index: mln/metal/bool.hh
--- mln/metal/bool.hh (revision 1201)
+++ mln/metal/bool.hh (working copy)
@@ -40,32 +40,44 @@
namespace metal
{
- // Fwd decls.
- struct true_;
- struct false_;
-
-
-
- // FIXME: Doc!
-
+ // Fwd decl.
template <bool b> struct bool_;
+ /// "true" type.
template <>
struct bool_< true >
{
- typedef true_ type;
static const bool value = true;
- enum { to_bool = true };
+ typedef bool_<true> eval;
+ static void check();
};
+ typedef bool_<true> true_;
+
+
+ /// "false" type.
template <>
struct bool_< false >
{
- typedef false_ type;
static const bool value = false;
- enum { to_bool = false };
+ typedef bool_<false> eval;
+ static void check_not();
};
+ typedef bool_<false> false_;
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ void true_::check()
+ {
+ }
+
+ void false_::check_not()
+ {
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln::metal
Index: mln/metal/if.hh
--- mln/metal/if.hh (revision 1201)
+++ mln/metal/if.hh (working copy)
@@ -71,7 +71,7 @@
* FIXME: Doc!
*/
template <typename Cond, typename Then, typename Else>
- struct if_ : internal::helper_if_< Cond::to_bool, Then, Else >
+ struct if_ : internal::helper_if_< Cond::value, Then, Else >
{
// ret is inherited.
};
Index: mln/metal/goes_to.hh
--- mln/metal/goes_to.hh (revision 0)
+++ mln/metal/goes_to.hh (revision 0)
@@ -0,0 +1,64 @@
+// 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_CORE_METAL_GOES_TO_HH
+# define MLN_CORE_METAL_GOES_TO_HH
+
+/*! \file mln/metal/goes_to.hh
+ *
+ * \brief Definition of a type that means "goes to".
+ */
+
+# include <mln/metal/converts_to.hh>
+# include <mln/metal/is.hh>
+
+
+# define mlc_goes_to(T, U) mln::metal::goes_to< T, U >
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ /*! \brief "goes-to" check.
+ *
+ * FIXME: Doc!
+ */
+ template <typename T, typename U>
+ struct goes_to : or_< mlc_converts_to(T,U), mlc_is(T,U) >::eval
+ {};
+
+
+ } // end of namespace mln::metal
+
+} // end of namespace mln
+
+
+#endif // ! MLN_CORE_METAL_GOES_TO_HH
Index: mln/metal/converts_to.hh
--- mln/metal/converts_to.hh (revision 0)
+++ mln/metal/converts_to.hh (revision 0)
@@ -0,0 +1,79 @@
+// 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_CORE_METAL_CONVERTS_TO_HH
+# define MLN_CORE_METAL_CONVERTS_TO_HH
+
+/*! \file mln/metal/converts_to.hh
+ *
+ * \brief Definition of a type that means "converts to".
+ */
+
+# include <mln/metal/is_a.hh>
+# include <mln/metal/const.hh>
+
+
+# define mlc_converts_to(T, U) mln::metal::converts_to< T, U >
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ namespace internal
+ {
+
+ template <typename T, typename U>
+ struct helper_converts_to_
+ {
+ static yes_ selector(U);
+ static no_ selector(...);
+ };
+
+ } // end of namespace mln::metal::internal
+
+
+
+ /*! \brief "converts-to" check.
+ *
+ * FIXME: Doc!
+ */
+ template <typename T, typename U>
+ struct converts_to : bool_<( sizeof(internal::helper_converts_to_<T, U>::selector(*internal::make_<mlc_const(T)>::ptr()) )
+ =
+ sizeof(internal::yes_) )>
+ {};
+
+ } // end of namespace mln::metal
+
+} // end of namespace mln
+
+
+#endif // ! MLN_CORE_METAL_CONVERTS_TO_HH
Index: mln/metal/all.hh
--- mln/metal/all.hh (revision 1201)
+++ mln/metal/all.hh (working copy)
@@ -42,15 +42,35 @@
} // end of namespace mln
-# include <mln/metal/bexpr.hh> // <- bool.hh
+# include <mln/metal/none.hh>
+
+# include <mln/metal/abort.hh>
+# include <mln/metal/bexpr.hh>
+# include <mln/metal/bool.hh>
# include <mln/metal/equal.hh>
# include <mln/metal/if.hh>
+
+# include <mln/metal/converts_to.hh>
+# include <mln/metal/is.hh>
# include <mln/metal/is_a.hh>
+# include <mln/metal/goes_to.hh>
+
# include <mln/metal/math.hh>
-# include <mln/metal/none.hh>
-# include <mln/metal/unqualif.hh> // <- unconst.hh, unptr.hh, unref.hh
+
+# include <mln/metal/const.hh>
+# include <mln/metal/unconst.hh>
+# include <mln/metal/is_const.hh>
+
+# include <mln/metal/unptr.hh>
+# include <mln/metal/unref.hh>
+
+# include <mln/metal/unqualif.hh>
+# include <mln/metal/is_unqualif.hh>
+
# include <mln/metal/vec.hh>
+# include <mln/metal/mat.hh>
+// FIXME: Remove the following includes below!
# include <mln/metal/same_coord.hh>
# include <mln/metal/same_point.hh>
Index: mln/metal/is_a.hh
--- mln/metal/is_a.hh (revision 1201)
+++ mln/metal/is_a.hh (working copy)
@@ -78,7 +78,7 @@
template <typename T, template <class> class U>
struct is_a : bool_<( sizeof( internal::helper_is_a_< T, U >::selector(internal::make_< T >::ptr()) )
=
- sizeof( internal::yes_ ) )>::type
+ sizeof( internal::yes_ ) )>
{};
Index: mln/metal/is.hh
--- mln/metal/is.hh (revision 0)
+++ mln/metal/is.hh (revision 0)
@@ -0,0 +1,90 @@
+// 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_CORE_METAL_IS_HH
+# define MLN_CORE_METAL_IS_HH
+
+/*! \file mln/metal/is.hh
+ *
+ * \brief Definition of a type that means "converts to".
+ */
+
+# include <mln/metal/is_a.hh>
+
+
+# define mlc_is(T, U) mln::metal::is< T, U >
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ namespace internal
+ {
+
+ template <typename T, typename U>
+ struct helper_is_
+ {
+ static yes_ selector(U&);
+ static no_ selector(...);
+ };
+
+ } // end of namespace mln::metal::internal
+
+
+
+ /*! \brief "is" check.
+ *
+ * FIXME: Doc!
+ */
+ template <typename T, typename U>
+ struct is : bool_<( sizeof(internal::helper_is_<T, U>::selector(*internal::make_<T>::ptr()))
+ =
+ sizeof(internal::yes_) )>
+ {};
+
+ template <typename T, typename U>
+ struct is< T*, U* > : is<T, U>::eval
+ {};
+
+ template <typename T, typename U>
+ struct is< T&, U& > : is<T, U>::eval
+ {};
+
+ template <typename T, typename U>
+ struct is< T**, U** > : false_
+ {};
+
+ } // end of namespace mln::metal
+
+} // end of namespace mln
+
+
+#endif // ! MLN_CORE_METAL_IS_HH
Index: mln/metal/vec.hh
--- mln/metal/vec.hh (revision 1201)
+++ mln/metal/vec.hh (working copy)
@@ -31,7 +31,7 @@
# include <iostream>
# include <cmath>
-# include <mln/core/contract.hh>
+# include <mln/core/concept/object.hh>
# include <mln/metal/binary_arith_trait.hh>
// FIXME: Document.
@@ -43,18 +43,22 @@
namespace metal
{
+ // Fwd decl.
+ template <unsigned n, typename T> class vec;
+
+
namespace internal
{
template <unsigned n, typename T>
- class vec_base_
+ class vec_base_ : public Object< vec<n,T> >
{
protected:
T data_[n];
};
template <typename T>
- class vec_base_ <1, T>
+ class vec_base_ <1, T> : public Object< vec<1,T> >
{
public:
void set(const T& val0)
@@ -66,7 +70,7 @@
};
template <typename T>
- class vec_base_ <2, T>
+ class vec_base_ <2, T> : public Object< vec<2,T> >
{
public:
void set(const T& val0, const T& val1)
@@ -79,7 +83,7 @@
};
template <typename T>
- class vec_base_ <3, T>
+ class vec_base_ <3, T> : public Object< vec<3,T> >
{
public:
void set(const T& val0, const T& val1, const T& val2)
@@ -93,7 +97,7 @@
};
template <typename T>
- class vec_base_ <4, T>
+ class vec_base_ <4, T> : public Object< vec<4,T> >
{
public:
void set(const T& val0, const T& val1, const T& val2, const T& val3)
@@ -115,10 +119,10 @@
template <unsigned n, typename T>
class vec : public internal::vec_base_<n, T>
{
- typedef internal::vec_base_<n, T> super;
+ typedef internal::vec_base_<n, T> super_;
protected:
- using super::data_;
+ using super_::data_;
public:
@@ -222,10 +226,12 @@
vec<3, typename binary_arith_trait<T, U>::ret>
vprod(const vec<3, T>& lhs, const vec<3, U>& rhs);
+
# ifndef MLN_INCLUDE_ONLY
template <unsigned n, typename T>
vec<n,T>::vec(const vec<n,T>& rhs)
+ : super_()
{
for (unsigned i = 0; i < n; ++i)
data_[i] = rhs[i];
@@ -234,6 +240,7 @@
template <unsigned n, typename T>
template <typename U>
vec<n,T>::vec(const vec<n, U>& rhs)
+ : super_()
{
for (unsigned i = 0; i < n; ++i)
data_[i] = rhs[i];
Index: mln/metal/binary_arith_trait.hh
--- mln/metal/binary_arith_trait.hh (revision 1201)
+++ mln/metal/binary_arith_trait.hh (working copy)
@@ -32,6 +32,9 @@
# define mlc_bin_arith(T, U) typename mln::metal::binary_arith_trait< T , U >::ret
+// FIXME: Move in mln/trait/!
+
+
namespace mln
{
Index: mln/metal/is_unqualif.hh
--- mln/metal/is_unqualif.hh (revision 0)
+++ mln/metal/is_unqualif.hh (revision 0)
@@ -0,0 +1,53 @@
+// 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_METAL_IS_UNQUALIF_HH
+# define MLN_METAL_IS_UNQUALIF_HH
+
+# include <mln/metal/equal.hh>
+# include <mln/metal/unqualif.hh>
+
+# define mlc_is_unqualif(T) mln::metal::is_unqualif< T >
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ template <typename T>
+ struct is_unqualif : equal<T, mlc_unqualif(T)>::eval
+ {
+ };
+
+ } // end of namespace mln::metal
+
+} // end of namespace mln
+
+
+#endif // ! MLN_METAL_IS_UNQUALIF_HH
Index: mln/metal/bexpr.hh
--- mln/metal/bexpr.hh (revision 1201)
+++ mln/metal/bexpr.hh (working copy)
@@ -36,6 +36,11 @@
# include <mln/metal/bool.hh>
+# define mlc_not( B ) mln::metal::not_< B >
+# define mlc_and( B1, B2 ) mln::metal::and_< B1, B2 >
+# define mlc_or( B1, B2 ) mln::metal::or_ < B1, B2 >
+# define mlc_xor( B1, B2 ) mln::metal::xor_< B1, B2 >
+
namespace mln
{
@@ -43,57 +48,30 @@
namespace metal
{
-
- /// "true" type.
- struct true_
- {
- static void check();
- typedef true_ eval;
- enum { to_bool = true };
- };
-
-
- /// "false" type.
- struct false_
- {
- typedef false_ eval;
- enum { to_bool = false };
- };
-
-
/// Negate type.
template <typename B>
- struct not_ : bool_<( ! B::to_bool )>::type
+ struct not_ : bool_<( ! B::value )>
{};
/// And type.
template <typename L, typename R>
- struct and_ : bool_<( L::to_bool && R::to_bool )>::type
+ struct and_ : bool_<( L::value && R::value )>
{};
/// Or type.
template <typename L, typename R>
- struct or_ : bool_<( L::to_bool || R::to_bool )>::type
+ struct or_ : bool_<( L::value || R::value )>
{};
/// Xor type.
template <typename L, typename R>
- struct xor_ : bool_<( L::to_bool ^ R::to_bool )>::type
+ struct xor_ : bool_<( L::value ^ R::value )>
{};
-
-# ifndef MLN_INCLUDE_ONLY
-
- void true_::check()
- {
- }
-
-# endif // ! MLN_INCLUDE_ONLY
-
} // end of namespace mln::metal
} // end of namespace mln
Index: mln/level/fill.hh
--- mln/level/fill.hh (revision 1201)
+++ mln/level/fill.hh (working copy)
@@ -32,7 +32,7 @@
*
* \brief Fill an image, that is, set pixel values.
*
- * \todo Overload for fast images.
+ * \todo Re-organize this file contents + Overload for fast images.
*/
# include <cstring>
@@ -157,6 +157,7 @@
template <typename I>
void fill(Image<I>& ima, const mln_value(I)& value)
{
+ mlc_is(mln_trait_image_io(I), trait::io::write)::check(); // FIXME: Only the upcoming general facade!!!
mln_precondition(exact(ima).has_data());
impl::fill_with_value(exact(ima), value);
}
Index: mln/level/fast_median.hh
--- mln/level/fast_median.hh (revision 1201)
+++ mln/level/fast_median.hh (working copy)
@@ -121,7 +121,7 @@
for_all(q_bot)
med.take(q_bot.val());
- output(p) = med.to_result();
+ output(p) = med;
if (fwd)
// browse line fwd
@@ -132,7 +132,7 @@
med.untake(q_fm.val());
for_all(q_fp)
med.take(q_fp.val());
- output(p) = med.to_result();
+ output(p) = med;
}
else
// browse line bkd
@@ -143,7 +143,7 @@
med.untake(q_bm.val());
for_all(q_bp)
med.take(q_bp.val());
- output(p) = med.to_result();
+ output(p) = med;
}
// change browsing
fwd = ! fwd;
Index: mln/level/paste.hh
--- mln/level/paste.hh (revision 1201)
+++ mln/level/paste.hh (working copy)
@@ -70,45 +70,47 @@
{
template <typename I, typename J>
- void paste_generic_(const Image<I>& data_, Image<J>& destination_)
+ void paste_generic_(const I& data, J& destination)
{
- const I& data = exact(data_);
- J& destination = exact(destination_);
-
+ trace::entering("level::impl::paste_generic_");
mln_piter(I) p(data.domain());
for_all(p)
destination(p) = data(p);
+ trace::exiting("level::impl::paste_generic_");
}
template <typename I, typename J>
- void paste_fast_(const Fast_Image<I>& data_, Fast_Image<J>& destination_)
+ void paste_lines_(const I& data, J& destination)
{
- const I& data = exact(data_);
- J& destination = exact(destination_);
-
+ trace::entering("level::impl::paste_lines_");
typedef mln_point(I) P;
std::size_t n = data.bbox().len(P::dim - 1);
+ // FIXME: Works only for raw data images
+ // FIXME: For linear data images, we should get the len for each line...
- typename I::line_piter p(data.domain());
+ typename I::line_piter p(data.domain()); // FIXME: Alias mln_line_piter!
for_all(p)
memcpy_(inplace(make::pixel(destination, p)),
make::pixel(data, p),
n);
+ trace::exiting("level::impl::paste_lines_");
}
// Disjunction.
template <typename I, typename J>
- void paste_(const Image<I>& data, Image<J>& destination)
+ void paste_(mln::trait::data::any, const I& data,
+ mln::trait::data::any, J& destination)
{
paste_generic_(data, destination);
}
template <typename I, typename J>
- void paste_(const Fast_Image<I>& data, Fast_Image<J>& destination)
+ void paste_(mln::trait::data::raw, const I& data,
+ mln::trait::data::raw, J& destination)
{
if (sizeof(mln_value(I)) = sizeof(mln_value(J)))
- paste_fast_(data, destination);
+ paste_lines_(data, destination);
else
paste_generic_(data, destination);
}
@@ -119,10 +121,20 @@
// Facade.
template <typename I, typename J>
- void paste(const Image<I>& data, Image<J>& destination)
+ void paste(const Image<I>& data_, Image<J>& destination_)
{
- mln_precondition(exact(data).domain() <= exact(destination).domain());
- impl::paste_(exact(data), exact(destination));
+ trace::entering("level::paste");
+ mlc_is(mln_trait_image_io(J), trait::io::write)::check();
+ mlc_converts_to(mln_value(I), mln_value(J))::check();
+
+ const I& data = exact(data_);
+ J& destination = exact(destination_);
+ mln_precondition(data.domain() <= destination.domain());
+
+ // Remember: raw < linear < stored, computed.
+ impl::paste_(mln_trait_image_data(I)(), data,
+ mln_trait_image_data(J)(), destination);
+ trace::exiting("level::paste");
}
# endif // ! MLN_INCLUDE_ONLY
Index: mln/accu/median.hh
--- mln/accu/median.hh (revision 1201)
+++ mln/accu/median.hh (working copy)
@@ -33,7 +33,7 @@
* \brief Define a generic median accumulator class.
*/
-# include <mln/core/concept/accumulator.hh>
+# include <mln/accu/internal/base.hh>
# include <mln/accu/histo.hh>
@@ -48,7 +48,7 @@
* with type \c S.
*/
template <typename S>
- struct median : public Accumulator< median<S> >
+ struct median : public mln::accu::internal::base_< mln_value(S), median<S> >
{
typedef mln_value(S) value;
typedef value result;
Index: mln/accu/internal/base.hh
--- mln/accu/internal/base.hh (revision 0)
+++ mln/accu/internal/base.hh (revision 0)
@@ -0,0 +1,93 @@
+// 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_ACCU_INTERNAL_BASE_HH
+# define MLN_ACCU_INTERNAL_BASE_HH
+
+/*! \file mln/accu/internal/base.hh
+ *
+ * \brief Define a base class for implementation of accumulator
+ * classes.
+ */
+
+# include <mln/core/concept/accumulator.hh>
+# include <mln/metal/unconst.hh>
+# include <mln/metal/unref.hh>
+
+
+namespace mln
+{
+
+ namespace accu
+ {
+
+ namespace internal
+ {
+
+ /*! Generic min accumulator class.
+ *
+ * Base class for implementation of accumulator classes.
+ */
+ template <typename R, typename E>
+ struct base_ : public Accumulator<E>
+ {
+ typedef mlc_unconst(R) tmp_;
+ typedef mlc_unref(tmp_) result_;
+ public:
+
+ typedef R result;
+
+ operator result_() const;
+
+ protected:
+ base_();
+ };
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename R, typename E>
+ base_<R,E>::base_()
+ {
+ }
+
+ template <typename R, typename E>
+ base_<R,E>::operator typename base_<R,E>::result_ () const
+ {
+ return exact(this)->to_result();
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::accu::internal
+
+ } // end of namespace mln::accu
+
+} // end of namespace mln
+
+
+#endif // ! MLN_ACCU_INTERNAL_BASE_HH
Index: mln/value/interval.hh
--- mln/value/interval.hh (revision 0)
+++ mln/value/interval.hh (revision 0)
@@ -0,0 +1,101 @@
+// 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_VALUE_INTERVAL_HH
+# define MLN_VALUE_INTERVAL_HH
+
+/*! \file mln/value/interval.hh
+ *
+ * \brief Define an interval between two values.
+ *
+ * \todo Likewise, code value::not_equal(t), less_than, etc.
+ */
+
+# include <mln/core/concept/object.hh>
+
+
+namespace mln
+{
+
+ namespace value
+ {
+
+ /// FIXME: Doc!
+
+ template <typename T>
+ struct interval_ : public Object< interval_<T> >
+ {
+ interval_(const T& from, const T& to);
+ T from, to;
+
+ template <typename U>
+ operator interval_<U>() const;
+ };
+
+
+ template <typename T>
+ interval_<T>
+ interval(const T& from, const T& to);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename T>
+ interval_<T>::interval_(const T& from, const T& to)
+ : from(from),
+ to(to)
+ {
+ mln_precondition(from <= to);
+ }
+
+ template <typename T>
+ template <typename U>
+ interval_<T>::operator interval_<U>() const
+ {
+ mln_invariant(from <= to);
+ interval_<U> tmp(from, to);
+ mln_postcondition(tmp.from <= tmp.to);
+ return tmp;
+ }
+
+ template <typename T>
+ interval_<T>
+ interval(const T& from, const T& to)
+ {
+ mln_precondition(from <= to);
+ interval_<T> tmp(from, to);
+ return tmp;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::value
+
+} // end of namespace mln
+
+
+#endif // ! MLN_VALUE_INTERVAL_HH
Index: mln/value/props.hh
--- mln/value/props.hh (revision 1201)
+++ mln/value/props.hh (working copy)
@@ -66,7 +66,7 @@
/// Test is the value type \c T is low quantized.
-# define mln_is_lowq(T) typename metal::bool_<( mln_card_(T) != 0 )>::type
+# define mln_is_lowq(T) typename metal::bool_<( mln_card_(T) != 0 )>
/// Give the summation type for values of type \c T.
Index: mln/value/all.hh
--- mln/value/all.hh (revision 1201)
+++ mln/value/all.hh (working copy)
@@ -49,6 +49,8 @@
# include <mln/value/props.hh>
# include <mln/value/proxy.hh>
+# include <mln/value/interval.hh>
+
// FIXME: that includes concept/image.hh!
Index: mln/border/get.hh
--- mln/border/get.hh (revision 1201)
+++ mln/border/get.hh (working copy)
@@ -63,7 +63,7 @@
}
template <typename S, typename E>
- unsigned get__(const mln::internal::image_base_<S,E>& ima)
+ unsigned get__(const mln::internal::image_base_<S,E>&)
{
return 0;
}
Index: mln/pw/image.hh
--- mln/pw/image.hh (revision 1201)
+++ mln/pw/image.hh (working copy)
@@ -36,6 +36,7 @@
# include <mln/core/internal/image_primary.hh>
# include <mln/core/concept/function.hh>
# include <mln/value/set.hh>
+# include <mln/metal/unqualif.hh>
namespace mln
@@ -71,6 +72,30 @@
+ namespace trait
+ {
+
+ // FIXME: the result type should *not* be qualified
+
+ template <typename F, typename S>
+ struct image_< pw::image<F,S> > : default_image_< mlc_unqualif(mln_result(F)),
+ pw::image<F,S> >
+ {
+ typedef trait::category::primary category;
+
+ typedef trait::access::browsing access;
+ typedef trait::space::fixme space;
+ typedef trait::size::regular size;
+ typedef trait::support::fixme support;
+
+ typedef trait::border::none border;
+ typedef trait::data::computed data;
+ typedef trait::io::read_only io;
+ };
+
+ } // end of namespace mln::trait
+
+
namespace pw
{
Index: mln/fun/ops.hh
--- mln/fun/ops.hh (revision 1201)
+++ mln/fun/ops.hh (working copy)
@@ -122,12 +122,12 @@
{
// -> p2v
- mln_decl_binary_expr_(p2v, p2b, equal, =);
- mln_decl_binary_expr_(p2v, p2b, not_equal, !=);
+ mln_decl_binary_expr_(p2v, p2b, eq, =);
+ mln_decl_binary_expr_(p2v, p2b, neq, !=);
mln_decl_binary_expr_(p2v, p2b, less, <);
- mln_decl_binary_expr_(p2v, p2b, less_or_equal, <=);
- mln_decl_binary_expr_(p2v, p2b, greater_or_equal, >=);
+ mln_decl_binary_expr_(p2v, p2b, leq , <=);
+ mln_decl_binary_expr_(p2v, p2b, geq, >=);
mln_decl_binary_expr_(p2v, p2b, greater, >);
mln_decl_binary_expr_(p2b, p2b, and, &&);
@@ -147,12 +147,12 @@
// -> v2b
- mln_decl_binary_expr_(v2v, v2b, equal, =);
- mln_decl_binary_expr_(v2v, v2b, not_equal, !=);
+ mln_decl_binary_expr_(v2v, v2b, eq, =);
+ mln_decl_binary_expr_(v2v, v2b, neq, !=);
mln_decl_binary_expr_(v2v, v2b, less, <);
- mln_decl_binary_expr_(v2v, v2b, less_or_equal, <=);
- mln_decl_binary_expr_(v2v, v2b, greater_or_equal, >=);
+ mln_decl_binary_expr_(v2v, v2b, leq, <=);
+ mln_decl_binary_expr_(v2v, v2b, geq, >=);
mln_decl_binary_expr_(v2v, v2b, greater, >);
mln_decl_binary_expr_(v2b, v2b, and, &&);
Index: mln/fun/p2v/iota.hh
--- mln/fun/p2v/iota.hh (revision 0)
+++ mln/fun/p2v/iota.hh (revision 0)
@@ -0,0 +1,102 @@
+// 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_FUN_P2V_IOTA_HH
+# define MLN_FUN_P2V_IOTA_HH
+
+/*! \file mln/fun/p2v/iota.hh
+ *
+ * \brief Iota function.
+ */
+
+# include <mln/core/concept/function.hh>
+
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace p2v
+ {
+
+ struct iota_t : public Function_p2v< iota_t >
+ {
+ typedef unsigned result;
+
+ iota_t();
+
+ template <typename P>
+ unsigned operator()(const P&) const;
+
+ unsigned value() const;
+ void reset() const;
+
+ protected:
+ mutable unsigned i_;
+ }
+
+ iota;
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ iota_t::iota_t()
+ {
+ reset();
+ }
+
+ template <typename P>
+ unsigned
+ iota_t::operator()(const P&) const
+ {
+ return ++i_;
+ }
+
+ unsigned
+ iota_t::value() const
+ {
+ return i_;
+ }
+
+ void
+ iota_t::reset() const
+ {
+ i_ = 0;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::fun::p2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+
+#endif // ! MLN_FUN_P2V_IOTA_HH
Index: mln/fun/internal/selector.hh
--- mln/fun/internal/selector.hh (revision 1201)
+++ mln/fun/internal/selector.hh (working copy)
@@ -160,7 +160,7 @@
template <typename T>
struct tag_
{
- enum { value = mlc_is_a(T, Point_Site)::to_bool
+ enum { value = mlc_is_a(T, Point_Site)::value
? p_
: v_ };
};
Index: mln/trace/exiting.hh
--- mln/trace/exiting.hh (revision 0)
+++ mln/trace/exiting.hh (revision 0)
@@ -0,0 +1,67 @@
+// 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. Specificenteringy, 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_TRACE_EXITING_HH
+# define MLN_TRACE_EXITING_HH
+
+/*! \file mln/trace/exiting.hh
+ *
+ * \brief Definition of the trace exiting procedure.
+ */
+
+# include <string>
+# include <mln/trace/quiet.hh>
+
+
+namespace mln
+{
+
+ namespace trace
+ {
+
+ void exiting(const std::string& scope);
+
+# ifndef MLN_INCLUDE_ONLY
+
+ void exiting(const std::string&)
+ {
+ if (quiet)
+ return;
+ --tab;
+ for (unsigned i = 0; i < tab; ++i)
+ std::cout << " ";
+ std::cout << "}" << std::endl;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::trace
+
+} // end of namespace mln
+
+
+#endif // ! MLN_TRACE_EXITING_HH
Index: mln/trace/quiet.hh
--- mln/trace/quiet.hh (revision 0)
+++ mln/trace/quiet.hh (revision 0)
@@ -0,0 +1,51 @@
+// 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. Specificenteringy, 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_TRACE_QUIET_HH
+# define MLN_TRACE_QUIET_HH
+
+/*! \file mln/trace/quiet.hh
+ *
+ * \brief Definition of the trace quiet Boolean value.
+ */
+
+
+namespace mln
+{
+
+ namespace trace
+ {
+
+ static bool quiet = true;
+ static unsigned tab = 0;
+
+ } // end of namespace mln::trace
+
+} // end of namespace mln
+
+
+#endif // ! MLN_TRACE_QUIET_HH
Index: mln/trace/all.hh
--- mln/trace/all.hh (revision 0)
+++ mln/trace/all.hh (revision 0)
@@ -0,0 +1,52 @@
+// 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_TRACE_ALL_HH
+# define MLN_TRACE_ALL_HH
+
+/*! \file mln/trace/all.hh
+ *
+ * \brief File that includes all trace-related routines.
+ */
+
+
+namespace mln
+{
+
+ /*! Namespace of routines related to the trace mechanism.
+ */
+ namespace trace {}
+
+} // end of namespace mln
+
+
+# include <mln/trace/quiet.hh>
+# include <mln/trace/entering.hh>
+# include <mln/trace/exiting.hh>
+
+
+#endif // ! MLN_TRACE_ALL_HH
Index: mln/trace/entering.hh
--- mln/trace/entering.hh (revision 0)
+++ mln/trace/entering.hh (revision 0)
@@ -0,0 +1,67 @@
+// 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. Specificenteringy, 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_TRACE_ENTERING_HH
+# define MLN_TRACE_ENTERING_HH
+
+/*! \file mln/trace/entering.hh
+ *
+ * \brief Definition of the trace entering procedure.
+ */
+
+# include <string>
+# include <mln/trace/quiet.hh>
+
+
+namespace mln
+{
+
+ namespace trace
+ {
+
+ void entering(const std::string& scope);
+
+# ifndef MLN_INCLUDE_ONLY
+
+ void entering(const std::string& scope)
+ {
+ if (quiet)
+ return;
+ for (unsigned i = 0; i < tab; ++i)
+ std::cout << " ";
+ std::cout << scope << " {" << std::endl;
+ ++tab;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::trace
+
+} // end of namespace mln
+
+
+#endif // ! MLN_TRACE_ENTERING_HH
Index: mln/morpho/plus.hh
--- mln/morpho/plus.hh (revision 1201)
+++ mln/morpho/plus.hh (working copy)
@@ -85,7 +85,7 @@
{
mln_precondition(exact(rhs).domain() = exact(lhs).domain());
mln_precondition(exact(output).domain() = exact(lhs).domain());
- impl::plus_(mln_value_kind(mln_value(I))(), exact(lhs), exact(rhs), output);
+ impl::plus_(mln_trait_image_kind(I)(), exact(lhs), exact(rhs), output);
}
template <typename I, typename J>
Index: mln/morpho/min.hh
--- mln/morpho/min.hh (revision 1201)
+++ mln/morpho/min.hh (working copy)
@@ -101,14 +101,14 @@
{
mln_precondition(exact(rhs).domain() = exact(lhs).domain());
mln_precondition(exact(output).domain() = exact(lhs).domain());
- impl::min_(mln_value_kind(mln_value(I))(), exact(lhs), exact(rhs), output);
+ impl::min_(mln_trait_image_kind(I)(), exact(lhs), exact(rhs), output);
}
template <typename I, typename J>
void min_inplace(Image<I>& lhs, const Image<J>& rhs)
{
mln_precondition(exact(rhs).domain() = exact(lhs).domain());
- impl::min_inplace_(mln_value_kind(mln_value(I))(), exact(lhs), exact(rhs));
+ impl::min_inplace_(mln_trait_image_kind(I)(), exact(lhs), exact(rhs));
}
# endif // ! MLN_INCLUDE_ONLY
Index: mln/morpho/minus.hh
--- mln/morpho/minus.hh (revision 1201)
+++ mln/morpho/minus.hh (working copy)
@@ -85,7 +85,7 @@
{
mln_precondition(exact(rhs).domain() = exact(lhs).domain());
mln_precondition(exact(output).domain() = exact(lhs).domain());
- impl::minus_(mln_value_kind(mln_value(I))(), exact(lhs), exact(rhs), output);
+ impl::minus_(mln_trait_image_kind(I)(), exact(lhs), exact(rhs), output);
}
template <typename I, typename J>
Index: mln/morpho/complementation.hh
--- mln/morpho/complementation.hh (revision 1201)
+++ mln/morpho/complementation.hh (working copy)
@@ -85,7 +85,7 @@
void complementation(const Image<I>& input, Image<O>& output)
{
mln_precondition(exact(output).domain() = exact(input).domain());
- impl::complementation_(mln_value_kind(mln_value(I))(), exact(input), output);
+ impl::complementation_(mln_trait_image_kind(I)(), exact(input), output);
}
template <typename I>
Index: mln/morpho/dilation.hh
--- mln/morpho/dilation.hh (revision 1201)
+++ mln/morpho/dilation.hh (working copy)
@@ -134,7 +134,7 @@
template <typename I, typename W, typename O>
void dilation_wrt_win(const Image<I>& input, const Window<W>& win, Image<O>& output)
{
- dilation_wrt_value(mln_value_kind(mln_value(I))(), exact(input), exact(win), output);
+ dilation_wrt_value(mln_trait_image_kind(I)(), exact(input), exact(win), output);
// |
// --> call stage 2: dispatch w.r.t. the value kind
}
Index: mln/morpho/erosion.hh
--- mln/morpho/erosion.hh (revision 1201)
+++ mln/morpho/erosion.hh (working copy)
@@ -137,7 +137,7 @@
template <typename I, typename W, typename O>
void erosion_wrt_win(const Image<I>& input, const Window<W>& win, Image<O>& output)
{
- erosion_wrt_value(mln_value_kind(mln_value(I))(), exact(input), exact(win), output);
+ erosion_wrt_value(mln_trait_image_kind(I)(), exact(input), exact(win), output);
// |
// --> call stage 2: dispatch w.r.t. the value kind
}
Index: mln/morpho/hit_or_miss.hh
--- mln/morpho/hit_or_miss.hh (revision 1201)
+++ mln/morpho/hit_or_miss.hh (working copy)
@@ -190,7 +190,7 @@
Image<O>& output)
{
impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output);
- impl::hit_or_miss_(mln_value_kind(mln_value(I))(), input, win_hit, win_miss, output);
+ impl::hit_or_miss_(mln_trait_image_kind(I)(), input, win_hit, win_miss, output);
}
template <typename I, typename Wh, typename Wm, typename O>
Index: mln/canvas/morpho/algebraic_union_find.hh
--- mln/canvas/morpho/algebraic_union_find.hh (revision 1201)
+++ mln/canvas/morpho/algebraic_union_find.hh (working copy)
@@ -68,10 +68,7 @@
mln_ch_value(O, A) data;
algebraic_union_find(F& f)
- : f(f),
- deja_vu(f.output.domain()),
- parent(f.output.domain()),
- data(f.output.domain())
+ : f(f)
{
run();
}
@@ -80,7 +77,10 @@
{
// init
{
+ initialize(deja_vu, f.input);
mln::level::fill(deja_vu, false);
+ initialize(parent, f.input);
+ initialize(data, f.input);
f.init();
}
// first pass
@@ -119,7 +119,7 @@
void make_set(const point& p)
{
parent(p) = p;
- data(p).take_as_init(make::pix(f.input, p));
+ data(p).take_as_init(make::pix(f.input, p)); // FIXME: algebraic so p!
}
bool is_root(const point& p) const
Index: mln/canvas/browsing/snake_fwd.hh
--- mln/canvas/browsing/snake_fwd.hh (revision 1201)
+++ mln/canvas/browsing/snake_fwd.hh (working copy)
@@ -33,6 +33,7 @@
* \brief Browsing in a snake-way, forward.
*/
+# include <mln/core/concept/browsing.hh>
# include <mln/core/dpoint2d.hh> // for "up"
# include <mln/geom/size2d.hh>
@@ -62,14 +63,21 @@
* } \n
*
*/
+
+ struct snake_fwd_t : public Browsing< snake_fwd_t >
+ {
template <typename F>
- void snake_fwd(F& f);
+ void operator()(F& f) const;
+ }
+
+ snake_fwd;
# ifndef MLN_INCLUDE_ONLY
template <typename F>
- void snake_fwd(F& f)
+ void
+ snake_fwd_t::operator()(F& f) const
{
mln_precondition(f.input.has_data());
int
Index: mln/canvas/browsing/fwd.hh
--- mln/canvas/browsing/fwd.hh (revision 0)
+++ mln/canvas/browsing/fwd.hh (revision 0)
@@ -0,0 +1,103 @@
+// 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_CANVAS_BROWSING_FWD_HH
+# define MLN_CANVAS_BROWSING_FWD_HH
+
+/*! \file mln/canvas/browsing/fwd.hh
+ *
+ * \brief Canvas for browsing forward.
+ */
+
+# include <mln/core/concept/browsing.hh>
+# include <mln/core/concept/image.hh>
+
+
+namespace mln
+{
+
+ namespace canvas
+ {
+
+ namespace browsing
+ {
+
+ /*! FIXME: Doc!
+ *
+ *
+ * F shall feature: \n
+ * { \n
+ * --- as typedef: \n
+ * I; \n
+ * --as attributes: \n
+ * input; \n
+ * p; \n
+ * --- as method: \n
+ * void init(); \n
+ * void next(); \n
+ * void final(); \n
+ * } \n
+ *
+ */
+
+ struct fwd_t : public Browsing< fwd_t >
+ {
+ template <typename F>
+ void operator()(F& f) const;
+ }
+
+ fwd;
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename F>
+ void
+ fwd_t::operator()(F& f) const
+ {
+ mln_precondition(f.input.has_data());
+ typedef typename F::I I;
+ mln_fwd_piter(I) p(f.input.domain());
+ f.init();
+ for_all(p)
+ {
+ f.p = p;
+ f.next();
+ }
+ f.final();
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::canvas::browsing
+
+ } // end of namespace mln::canvas
+
+} // end of namespace mln
+
+
+#endif // ! MLN_CANVAS_BROWSING_FWD_HH
Index: mln/canvas/labeling.hh
--- mln/canvas/labeling.hh (revision 1201)
+++ mln/canvas/labeling.hh (working copy)
@@ -62,9 +62,7 @@
mln_ch_value(O, point) parent;
labeling(F& f)
- : f(f),
- deja_vu(f.output.domain()),
- parent(f.output.domain())
+ : f(f)
{
run();
}
@@ -73,8 +71,10 @@
{
// init
{
- f.nlabels = 0;
+ initialize(deja_vu, f.input);
mln::level::fill(deja_vu, false);
+ initialize(parent, f.input);
+ f.nlabels = 0;
f.init();
}
// first pass
Index: mln/util/nil.hh
--- mln/util/nil.hh (revision 0)
+++ mln/util/nil.hh (revision 0)
@@ -0,0 +1,97 @@
+// 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_UTIL_NIL_HH
+# define MLN_UTIL_NIL_HH
+
+/*! \file mln/util/nil.hh
+ *
+ * \brief Definition of an "niler" object.
+ */
+
+# include <mln/core/concept/object.hh>
+
+
+namespace mln
+{
+
+ namespace util
+ {
+
+ /// Nil structure.
+ struct nil : public Object< nil >
+ {
+ nil();
+
+ // Just like util::eat:
+
+ template <typename T>
+ nil(const T&);
+
+ template <typename T>
+ nil& operator=(const T&);
+
+ // Just like util::ignore:
+
+ template <typename T>
+ operator T() const;
+ };
+
+# ifndef MLN_INCLUDE_ONLY
+
+ // nil
+
+ nil::nil()
+ {
+ }
+
+ template <typename T>
+ nil::nil(const T&)
+ {
+ }
+
+ template <typename T>
+ nil&
+ nil::operator=(const T&)
+ {
+ return *this;
+ }
+
+ template <typename T>
+ nil::operator T() const
+ {
+ return T();
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::util
+
+} // end of namespace mln
+
+
+#endif // ! MLN_UTIL_NIL_HH
Index: mln/util/ignore.hh
--- mln/util/ignore.hh (revision 1201)
+++ mln/util/ignore.hh (working copy)
@@ -43,7 +43,7 @@
{
/// Ignore structure.
- struct ignore
+ struct ignore : public Object< ignore >
{
ignore();
Index: mln/util/eat.hh
--- mln/util/eat.hh (revision 1201)
+++ mln/util/eat.hh (working copy)
@@ -43,7 +43,7 @@
{
/// Eat structure.
- struct eat
+ struct eat : public Object< eat >
{
eat();
URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena
ChangeLog:
2007-10-01 Simon Nivault <simon.nivault(a)lrde.epita.fr>
Add trait for operators * + -.
* mln/core/trait/mult.hh: Rename as...
* mln/core/trait/op_mult.hh: ...this.
* mln/core/trait/op_minus.hh: New.
* mln/core/trait/op_plus.hh: New.
* mln/core/trait/op_uminus.hh: New.
* mln/core/trait/all.hh: Include files above.
---
all.hh | 5 ++
op_minus.hh | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
op_mult.hh | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
op_plus.hh | 135 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
op_uminus.hh | 83 ++++++++++++++++++++++++++++++++++
5 files changed, 505 insertions(+)
Index: trunk/milena/mln/core/trait/mult.hh (deleted)
===================================================================
Index: trunk/milena/mln/core/trait/op_plus.hh
===================================================================
--- trunk/milena/mln/core/trait/op_plus.hh (revision 0)
+++ trunk/milena/mln/core/trait/op_plus.hh (revision 1200)
@@ -0,0 +1,135 @@
+// Copyright (C) 2006 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_TRAIT_OP_PLUS_HH
+# define MLN_TRAIT_OP_PLUS_HH
+
+
+# define mln_op_plus(T, U) typename mln::trait::op_plus< T , U >::ret
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ template <unsigned n, typename T>
+ class vec;
+
+ template <unsigned n, unsigned m, typename T>
+ class mat;
+
+ } // end of namespace mln::metal
+
+ namespace trait
+ {
+
+ template <typename T, typename U>
+ struct op_plus;
+
+
+ template <typename T>
+ struct op_plus<T, T>
+ {
+ typedef T ret;
+ };
+
+ template <>
+ struct op_plus<int, float>
+ {
+ typedef float ret;
+ };
+ template <>
+ struct op_plus<float, int>
+ {
+ typedef float ret;
+ };
+
+ template <>
+ struct op_plus<int, double>
+ {
+ typedef double ret;
+ };
+ template <>
+ struct op_plus<double, int>
+ {
+ typedef double ret;
+ };
+
+ template <>
+ struct op_plus<double, float>
+ {
+ typedef double ret;
+ };
+ template <>
+ struct op_plus<float, double>
+ {
+ typedef double ret;
+ };
+
+ template <unsigned n, typename T, typename U>
+ struct op_plus<metal::vec<n, T>, U>
+ {
+ typedef metal::vec<n, mln_op_plus(T, U)> ret;
+ };
+ template <typename U, unsigned n, typename T>
+ struct op_plus<U, metal::vec<n, T> >
+ {
+ typedef metal::vec<n, mln_op_plus(T, U)> ret;
+ };
+
+ template <unsigned n, typename T, typename U>
+ struct op_plus<metal::vec<n, T>, metal::vec<n, U> >
+ {
+ typedef metal::vec<n, mln_op_plus(T, U)> ret;
+ };
+
+ template <unsigned n, unsigned m, typename T, typename U>
+ struct op_plus<metal::mat<n, m, T>, U>
+ {
+ typedef metal::mat<n, m, mln_op_plus(T, U)> ret;
+ };
+ template <typename U, unsigned n, unsigned m, typename T>
+ struct op_plus<U, metal::mat<n, m, T> >
+ {
+ typedef metal::mat<n, m, mln_op_plus(T, U)> ret;
+ };
+
+ template <unsigned n, unsigned m, typename T, typename U>
+ struct op_plus<metal::mat<n, m, T>, metal::mat<n, m, U> >
+ {
+ typedef metal::mat<n, m, mln_op_plus(T, U)> ret;
+ };
+
+
+ } // end of namespace mln::trait
+
+} // end of namespace mln
+
+#endif // ! MLN_TRAIT_OP_PLUS_HH
Index: trunk/milena/mln/core/trait/all.hh
===================================================================
--- trunk/milena/mln/core/trait/all.hh (revision 1199)
+++ trunk/milena/mln/core/trait/all.hh (revision 1200)
@@ -46,6 +46,11 @@
# include <mln/core/trait/is_fast.hh>
# include <mln/core/trait/pixter.hh>
+# include <mln/core/trait/op_mult.hh>
+# include <mln/core/trait/op_plus.hh>
+# include <mln/core/trait/op_minus.hh>
+# include <mln/core/trait/op_uminus.hh>
+# include <mln/core/trait/promote.hh>
#endif // ! MLN_CORE_TRAIT_ALL_HH
Index: trunk/milena/mln/core/trait/op_minus.hh
===================================================================
--- trunk/milena/mln/core/trait/op_minus.hh (revision 0)
+++ trunk/milena/mln/core/trait/op_minus.hh (revision 1200)
@@ -0,0 +1,141 @@
+// Copyright (C) 2006 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_TRAIT_OP_MINUS_HH
+# define MLN_TRAIT_OP_MINUS_HH
+
+
+# define mln_op_minus(T, U) typename mln::trait::op_minus< T , U >::ret
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ template <unsigned n, typename T>
+ class vec;
+
+ template <unsigned n, unsigned m, typename T>
+ class mat;
+
+ } // end of namespace mln::metal
+
+ namespace trait
+ {
+
+ template <typename T, typename U>
+ struct op_minus;
+
+
+ template <typename T>
+ struct op_minus<T, T>
+ {
+ typedef T ret;
+ };
+
+ template <typename T>
+ struct op_minus<unsigned, T>
+ {
+ typedef mln_op_minus(signed, T) ret;
+ };
+
+ template <>
+ struct op_minus<int, float>
+ {
+ typedef float ret;
+ };
+ template <>
+ struct op_minus<float, int>
+ {
+ typedef float ret;
+ };
+
+ template <>
+ struct op_minus<int, double>
+ {
+ typedef double ret;
+ };
+ template <>
+ struct op_minus<double, int>
+ {
+ typedef double ret;
+ };
+
+ template <>
+ struct op_minus<double, float>
+ {
+ typedef double ret;
+ };
+ template <>
+ struct op_minus<float, double>
+ {
+ typedef double ret;
+ };
+
+ template <unsigned n, typename T, typename U>
+ struct op_minus<metal::vec<n, T>, U>
+ {
+ typedef metal::vec<n, mln_op_minus(T, U)> ret;
+ };
+ template <typename U, unsigned n, typename T>
+ struct op_minus<U, metal::vec<n, T> >
+ {
+ typedef metal::vec<n, mln_op_minus(T, U)> ret;
+ };
+
+ template <unsigned n, typename T, typename U>
+ struct op_minus<metal::vec<n, T>, metal::vec<n, U> >
+ {
+ typedef metal::vec<n, mln_op_minus(T, U)> ret;
+ };
+
+ template <unsigned n, unsigned m, typename T, typename U>
+ struct op_minus<metal::mat<n, m, T>, U>
+ {
+ typedef metal::mat<n, m, mln_op_minus(T, U)> ret;
+ };
+ template <typename U, unsigned n, unsigned m, typename T>
+ struct op_minus<U, metal::mat<n, m, T> >
+ {
+ typedef metal::mat<n, m, mln_op_minus(T, U)> ret;
+ };
+
+ template <unsigned n, unsigned m, typename T, typename U>
+ struct op_minus<metal::mat<n, m, T>, metal::mat<n, m, U> >
+ {
+ typedef metal::mat<n, m, mln_op_minus(T, U)> ret;
+ };
+
+
+ } // end of namespace mln::trait
+
+} // end of namespace mln
+
+#endif // ! MLN_TRAIT_OP_MINUS_HH
Index: trunk/milena/mln/core/trait/op_uminus.hh
===================================================================
--- trunk/milena/mln/core/trait/op_uminus.hh (revision 0)
+++ trunk/milena/mln/core/trait/op_uminus.hh (revision 1200)
@@ -0,0 +1,83 @@
+// Copyright (C) 2006 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_TRAIT_OP_UMINUS_HH
+# define MLN_TRAIT_OP_UMINUS_HH
+
+
+# define mln_op_uminus(T) typename mln::trait::op_uminus< T >::ret
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ template <unsigned n, typename T>
+ class vec;
+
+ template <unsigned n, unsigned m, typename T>
+ class mat;
+
+ } // end of namespace mln::metal
+
+ namespace trait
+ {
+
+ template <typename T>
+ struct op_uminus
+ {
+ typedef T ret;
+ };
+
+
+ template <>
+ struct op_uminus<unsigned>
+ {
+ typedef signed ret;
+ };
+
+ template <unsigned n, typename T>
+ struct op_uminus<metal::vec<n, T> >
+ {
+ typedef metal::vec<n, mln_op_uminus(T)> ret;
+ };
+
+ template <unsigned n, unsigned m, typename T>
+ struct op_uminus<metal::mat<n, m, T> >
+ {
+ typedef metal::mat<n, m, mln_op_uminus(T)> ret;
+ };
+
+
+ } // end of namespace mln::trait
+
+} // end of namespace mln
+
+#endif // ! MLN_TRAIT_OP_UMINUS_HH
Index: trunk/milena/mln/core/trait/op_mult.hh
===================================================================
--- trunk/milena/mln/core/trait/op_mult.hh (revision 0)
+++ trunk/milena/mln/core/trait/op_mult.hh (revision 1200)
@@ -0,0 +1,141 @@
+// Copyright (C) 2006 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_TRAIT_OP_MULT_HH
+# define MLN_TRAIT_OP_MULT_HH
+
+
+# define mln_op_mult(T, U) typename mln::trait::op_mult< T , U >::ret
+
+
+
+namespace mln
+{
+
+ namespace metal
+ {
+
+ template <unsigned n, typename T>
+ class vec;
+
+ template <unsigned n, unsigned m, typename T>
+ class mat;
+
+ } // end of namespace mln::metal
+
+ namespace trait
+ {
+
+ template <typename T, typename U>
+ struct op_mult;
+
+
+ template <typename T>
+ struct op_mult<T, T>
+ {
+ typedef T ret;
+ };
+
+ template <>
+ struct op_mult<int, float>
+ {
+ typedef float ret;
+ };
+ template <>
+ struct op_mult<float, int>
+ {
+ typedef float ret;
+ };
+
+ template <>
+ struct op_mult<int, double>
+ {
+ typedef double ret;
+ };
+ template <>
+ struct op_mult<double, int>
+ {
+ typedef double ret;
+ };
+
+ template <>
+ struct op_mult<double, float>
+ {
+ typedef double ret;
+ };
+ template <>
+ struct op_mult<float, double>
+ {
+ typedef double ret;
+ };
+
+ template <unsigned n, typename T, typename U>
+ struct op_mult<metal::vec<n, T>, U>
+ {
+ typedef metal::vec<n, mln_op_mult(T, U)> ret;
+ };
+ template <typename U, unsigned n, typename T>
+ struct op_mult<U, metal::vec<n, T> >
+ {
+ typedef metal::vec<n, mln_op_mult(T, U)> ret;
+ };
+
+ template <unsigned n, unsigned m, typename T, typename U>
+ struct op_mult<metal::mat<n, m, T>, U>
+ {
+ typedef metal::mat<n, m, mln_op_mult(T, U)> ret;
+ };
+ template <typename U, unsigned n, unsigned m, typename T>
+ struct op_mult<U, metal::mat<n, m, T> >
+ {
+ typedef metal::mat<n, m, mln_op_mult(T, U)> ret;
+ };
+
+ template <unsigned n, unsigned o, typename T, unsigned m, typename U>
+ struct op_mult<metal::mat<n, o, T>, metal::mat<o, m, U> >
+ {
+ typedef metal::mat<n, m, mln_op_mult(T, U)> ret;
+ };
+
+ template <unsigned m, unsigned n, typename T, typename U>
+ struct op_mult<metal::mat<m, n, T>, metal::vec<n, U> >
+ {
+ typedef metal::mat<m, 1, mln_op_mult(T, U)> ret;
+ };
+
+ template <unsigned n, typename U, unsigned m, typename T>
+ struct op_mult< metal::vec<n, U>, metal::mat<n, m, T> >
+ {
+ typedef metal::mat<1, m, mln_op_mult(T, U)> ret;
+ };
+
+
+ } // end of namespace mln::trait
+
+} // end of namespace mln
+
+#endif // ! MLN_TRAIT_OP_MULT_HH
