https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud@lrde.epita.fr> Add delta to windows in mln. * tests/erosion.cc: New. * mln/arith/minus.hh: New. * mln/core/point.hh, * mln/core/dpoint.hh (vec_t, to_vec): New. * mln/core/rectangle2d.hh, * mln/core/concept/window.hh, * mln/core/concept/doc/window.hh, * mln/core/window.hh (delta): New. * mln/level/fill.hh: New overload. * mln/norm: New. * mln/norm/infty.hh: New. * mln/accu/min.hh: New. * mln/accu/sum.hh: New. * mln/accu/max.hh: New. * tests/window2d.cc: Use delta. * tests/box2d.cc: Add assertion. * tests/dpoint2d.cc: Test to_vec. * mln/morpho/erosion.hh: Add dispatch. * mln/accu/mean.hh: Rewrite. mln/accu/max.hh | 112 +++++++++++++++++++++++++++++++++++++++++ mln/accu/mean.hh | 17 +++--- mln/accu/min.hh | 112 +++++++++++++++++++++++++++++++++++++++++ mln/accu/sum.hh | 112 +++++++++++++++++++++++++++++++++++++++++ mln/arith/minus.hh | 82 ++++++++++++++++++++++++++++++ mln/core/concept/doc/window.hh | 5 + mln/core/concept/window.hh | 6 +- mln/core/dpoint.hh | 8 ++ mln/core/point.hh | 7 ++ mln/core/rectangle2d.hh | 10 +++ mln/core/window.hh | 24 ++++++++ mln/level/fill.hh | 24 ++++++++ mln/morpho/erosion.hh | 99 ++++++++++++++++++++++++++++++------ mln/norm/infty.hh | 86 +++++++++++++++++++++++++++++++ tests/box2d.cc | 1 tests/dpoint2d.cc | 3 + tests/erosion.cc | 78 ++++++++++++++++++++++++++++ tests/window2d.cc | 1 18 files changed, 761 insertions(+), 26 deletions(-) Index: tests/window2d.cc --- tests/window2d.cc (revision 1015) +++ tests/window2d.cc (working copy) @@ -49,4 +49,5 @@ w.insert(make::dpoint2d( 1, 1)); image2d_b<bool> ima = convert::to_image(w); debug::println(ima); + mln_assertion(w.delta() = 1); } Index: tests/erosion.cc --- tests/erosion.cc (revision 0) +++ tests/erosion.cc (revision 0) @@ -0,0 +1,78 @@ +// 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/median.cc + * + * \brief Test on mln::level::median. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/core/rectangle2d.hh> + +#include <mln/io/load_pgm.hh> +#include <mln/io/save_pgm.hh> + +#include <mln/value/int_u.hh> +#include <mln/level/fill.hh> +#include <mln/morpho/erosion.hh> + +#include <mln/fun/pw_value.hh> +#include <mln/fun/val.hh> +#include <mln/fun/ops.hh> + + +using namespace mln; +using namespace mln::value; + + +int main() +{ + rectangle2d rec(4, 4);//64, 64); + border::thickness = 66; + + image2d_b<int_u8> + lena = io::load_pgm("../img/lena.pgm"), + out(lena.domain()); + + morpho::erosion(lena, rec, out); + io::save_pgm(out, "out.pgm"); + + /* + { + image2d_b<bool> bin(lena.domain()), out(lena.domain()); + level::fill(bin, pw_value(1) > val(127)); + morpho::erosion(bin, rec, out); + + image2d_b<int_u8> test(lena.domain()); + image2d_b<int_u8>::piter p(lena.domain()); + for_all(p) + test(p) = out(p) ? 255 : 0; + io::save_pgm(test, "test.pgm"); + } + */ + +} Index: tests/box2d.cc --- tests/box2d.cc (revision 1015) +++ tests/box2d.cc (working copy) @@ -39,4 +39,5 @@ using namespace mln; box2d b = make::box2d(2, 3); + mln_assertion(b.nrows() = 2); } Index: tests/dpoint2d.cc --- tests/dpoint2d.cc (revision 1015) +++ tests/dpoint2d.cc (working copy) @@ -47,4 +47,7 @@ mln_assertion(dp = q - p); mln_assertion(q = p + dp); + + const int (&vec)[2] = dp.to_vec(); + mln_assertion(vec[0] = 3); } Index: mln/core/point.hh --- mln/core/point.hh (revision 1015) +++ mln/core/point.hh (working copy) @@ -96,6 +96,13 @@ /// Origin point (all coordinates are 0). static const point_<n,C> zero; + + /// Type of the array of coordinates. + typedef const C (&vec_t)[n]; + + /// Hook to coordinates. + vec_t to_vec() const { return coord_; } + protected: C coord_[n]; }; Index: mln/core/rectangle2d.hh --- mln/core/rectangle2d.hh (revision 1015) +++ mln/core/rectangle2d.hh (working copy) @@ -107,6 +107,11 @@ */ unsigned width() const; + /*! \brief Give the maximum coordinate gap between the window + * center and a window point. + */ + unsigned delta() const; + /// Get the symmetrical window. rectangle2d sym_() const; @@ -162,6 +167,11 @@ return 2 * half_width_ + 1; } + unsigned rectangle2d::delta() const + { + return half_width_ > half_height_ ? half_width_ : half_height_; + } + rectangle2d rectangle2d::sym_() const { return *this; Index: mln/core/dpoint.hh --- mln/core/dpoint.hh (revision 1015) +++ mln/core/dpoint.hh (working copy) @@ -96,6 +96,14 @@ /// Null delta-point (all coordinates are 0). static const dpoint_<n,C> zero; + const C* coords_() const { return coord_; } + + /// Type of the array of coordinates. + typedef const C (&vec_t)[n]; + + /// Hook to coordinates. + vec_t to_vec() const { return coord_; } + protected: C coord_[n]; }; Index: mln/core/concept/window.hh --- mln/core/concept/window.hh (revision 1015) +++ mln/core/concept/window.hh (working copy) @@ -59,6 +59,8 @@ bool is_centered() const; bool is_symmetric() const; + unsigned delta() const; + E sym_() const; */ @@ -93,8 +95,10 @@ m2 = 0; bool (E::*m3)() const = & E::is_symmetric; m3 = 0; - E (E::*m4)() const = & E::sym_; + unsigned (E::*m4)() const = & E::delta; m4 = 0; + E (E::*m_)() const = & E::sym_; + m_ = 0; } template <typename W> Index: mln/core/concept/doc/window.hh --- mln/core/concept/doc/window.hh (revision 1015) +++ mln/core/concept/doc/window.hh (working copy) @@ -76,6 +76,11 @@ */ bool is_symmetric() const; + /*! \brief Give the maximum coordinate gap between the window + center and a window point. + */ + unsigned delta() const; + /*! \brief Give the symmetrical window. */ E sym_() const; Index: mln/core/window.hh --- mln/core/window.hh (revision 1015) +++ mln/core/window.hh (working copy) @@ -41,6 +41,7 @@ # include <mln/convert/to_dpoint.hh> # include <mln/fun/all.hh> +# include <mln/norm/infty.hh> namespace mln @@ -97,6 +98,11 @@ */ bool is_symmetric() const; + /*! \brief Give the maximum coordinate gap between the window + center and a window point. + */ + unsigned delta() const; + /// Give the symmetrical window. window_<D> sym_() const; @@ -128,6 +134,8 @@ # ifndef MLN_INCLUDE_ONLY + // window_<D> + template <typename D> window_<D>::window_() { @@ -147,6 +155,20 @@ } template <typename D> + unsigned window_<D>::delta() const + { + unsigned d = 0; + const unsigned n = this->nelements(); + for (unsigned i = 0; i < n; ++i) + { + unsigned dd = norm::infty(this->element(i).to_vec()); + if (dd > d) + d = dd; + } + return d; + } + + template <typename D> window_<D> window_<D>::sym_() const { @@ -157,6 +179,8 @@ return tmp; } + // operators + template <typename W> window_<mln_dpoint(W)> operator+(const Window<W>& win, const mln_dpoint(W)& dp) Index: mln/morpho/erosion.hh --- mln/morpho/erosion.hh (revision 1015) +++ mln/morpho/erosion.hh (working copy) @@ -30,8 +30,11 @@ # include <mln/core/concept/image.hh> # include <mln/core/concept/window.hh> -// FIXME: # include <mln/border/assign.hh> +# include <mln/accu/min.hh> # include <mln/value/props.hh> +# include <mln/level/compare.hh> +# include <mln/level/fill.hh> +// FIXME: # include <mln/border/assign.hh> namespace mln @@ -40,8 +43,8 @@ namespace morpho { - template <typename I, typename W> - I erosion(const Image<I>& input, const Window<W>& win); + template <typename I, typename W, typename O> + void erosion(const Image<I>& input, const Window<W>& win, Image<O>& output); # ifndef MLN_INCLUDE_ONLY @@ -49,41 +52,103 @@ namespace impl { - template <typename I, typename W> - I erosion(const Image<I>& input_, const Window<W>& win_) + // on function + + template <typename I, typename W, typename O> + void erosion_on_function(const Image<I>& input_, const Window<W>& win_, Image<O>& output_) { const I& input = exact(input_); const W& win = exact(win_); + O& output = exact(output_); - typedef mln_value(I) value; + accu::min<mln_value(I)> min; - I output(input.domain()); mln_piter(I) p(input.domain()); mln_qiter(W) q(win, p); for_all(p) { - value v = mln_max(value); - for_all(q) if (input.owns_(q)) - { - if (input(q) < v) - v = input(q); + min.init(); + for_all(q) if (input.has(q)) + min.take(input(q)); + output(p) = min; + } } - output(p) = v; + + + // on set + + template <typename I, typename W, typename O> + void erosion_on_set(const Image<I>& input_, const Window<W>& win_, Image<O>& output_) + { + const I& input = exact(input_); + const W& win = exact(win_); + O& output = exact(output_); + + level::fill(output, input); + + mln_piter(I) p(input.domain()); + mln_qiter(W) q(win, p); + for_all(p) + if (input(p)) + for_all(q) if (input.has(q)) + if (! input(q)) + { + output(p) = false; + break; } - return output; } + + // ... + + + // FIXME: stage 3: dispatch w.r.t. fast property + + // stage 2: dispatch w.r.t. the value kind + + template <typename I, typename W, typename O> + void erosion_wrt_value(value::binary_kind, // binary => morphology on sets + const Image<I>& input, const Window<W>& win, Image<O>& output) + { + return impl::erosion_on_set(exact(input), exact(win), output); + } + + template <typename K, typename I, typename W, typename O> + void erosion_wrt_value(K, // otherwise => morphology on functions + const Image<I>& input, const Window<W>& win, Image<O>& output) + { + return impl::erosion_on_function(exact(input), exact(win), output); + } + + + // stage 1: dispatch w.r.t. the window type + + template <typename I, typename W, typename O> // general case + void erosion_wrt_win(const Image<I>& input, const Window<W>& win, Image<O>& output) + { + erosion_wrt_value(mln_kind(I)(), exact(input), exact(win), output); + } + +// template <typename I, typename O> // rectangle2d +// void erosion_wrt_win(const Image<I>& input, const rectangle2d& win, Image<O>& output) +// { +// return FIXME; +// } + + } // end of namespace mln::morpho::impl // facade - template <typename I, typename W> - I erosion(const Image<I>& input, const Window<W>& win) + template <typename I, typename W, typename O> + void erosion(const Image<I>& input, const Window<W>& win, Image<O>& output) { - return impl::erosion(exact(input), exact(win)); + impl::erosion_wrt_win(input, exact(win), output); + if (exact(win).is_centered()) + mln_postcondition(output <= input); } # endif // ! MLN_INCLUDE_ONLY Index: mln/level/fill.hh --- mln/level/fill.hh (revision 1015) +++ mln/level/fill.hh (working copy) @@ -34,6 +34,7 @@ */ # include <mln/core/concept/image.hh> +# include <mln/core/concept/function.hh> namespace mln @@ -53,6 +54,17 @@ void fill(Image<I>& ima, const mln_value(I)& v); + /*! Fill the whole image \p ima with the function \p f. + * + * \param[in,out] ima The image to be filled. + * \param[in] f The function. + * + * \pre \p ima has to be initialized. + */ + template <typename I, typename F> + void fill(Image<I>& ima, const Function_p2v<F>& f); + + /*! Fill the image \p ima by applying the function \p f. * * \param[in,out] ima The image to be filled. @@ -110,6 +122,18 @@ ima(p) = value; } + template <typename I, typename F> + void fill(Image<I>& ima_, + const Function_p2v<F>& f_) + { + I& ima = exact(ima_); + mln_precondition(ima.has_data()); + const F& f = exact(f_); + mln_piter(I) p(ima.domain()); + for_all(p) + ima(p) = f(p); + } + template <typename I> void fill(Image<I>& ima_, mln_value(I) (*f)(const mln_point(I)& p)) Index: mln/arith/minus.hh --- mln/arith/minus.hh (revision 0) +++ mln/arith/minus.hh (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. + +#ifndef MLN_ARITH_MINUS_HH +# define MLN_ARITH_MINUS_HH + +/*! \file mln/arith/minus.hh + * + * \brief Point-wise substraction between images. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace arith + { + + /*! Point-wise substraction of images \p lhs and \p rhs. + * + * \param[in] lhs First operand image. + * \param[in] rhs Second operand image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p lhs.domain = \p rhs.domain + */ + template <typename L, typename R, typename O> + void minus(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output); + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R, typename O> + void minus(const Image<L>& lhs_, const Image<R>& rhs_, Image<O>& output_) + { + const L& lhs = exact(lhs_); + const R& rhs = exact(rhs_); + O& output = exact(output_); + + mln_precondition(rhs.domain() = lhs.domain()); + mln_precondition(output.domain() = lhs.domain()); + + mln_piter(I) p(output.domain()); + for_all(p) + output(p) = lhs(p) - rhs(p); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::arith + +} // end of namespace mln + + +#endif // ! MLN_ARITH_MINUS_HH Index: mln/norm/infty.hh --- mln/norm/infty.hh (revision 0) +++ mln/norm/infty.hh (revision 0) @@ -0,0 +1,86 @@ +// 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_NORM_INFTY_HH +# define MLN_NORM_INFTY_HH + +/*! \file mln/norm/infty.hh + * + * \brief Define some infinity-norm related routines. + */ + +# include <cmath> + + +namespace mln +{ + + namespace norm + { + + /// Infinity-norm of a vector \p vec. + template <unsigned n, typename C> + C infty(const C (&vec)[n]); + + /// Infinity-norm distance between vectors \p v1 and \p v2. + template <unsigned n, typename C> + C infty_distance(const C (&v1)[n], const C (&v2)[n]); + + +# ifndef MLN_INCLUDE_ONLY + + template <unsigned n, typename C> + C infty(const C (&vec)[n]) + { + C c = 0; + for (unsigned i = 0; i < n; ++i) + if (std::abs(vec[i]) > c) + c = std::abs(vec[i]); + return c; + } + + template <unsigned n, typename C> + C infty_distance(const C (&v1)[n], const C (&v2)[n]) + { + C d = 0; + for (unsigned i = 0; i < n; ++i) + { + C dd = v2[i] > v1[i] ? v2[i] - v1[i] : v1[i] - v2[i]; + if (dd > d) + d = dd; + } + return d; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::norm + +} // end of namespace mln + + +#endif // ! MLN_NORM_INFTY_HH Index: mln/accu/min.hh --- mln/accu/min.hh (revision 0) +++ mln/accu/min.hh (revision 0) @@ -0,0 +1,112 @@ +// 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_MIN_HH +# define MLN_ACCU_MIN_HH + +/*! \file mln/accu/min.hh + * + * \brief Define an accumulator that computes a min. + */ + +# include <mln/core/concept/accumulator.hh> +# include <mln/value/props.hh> + + +namespace mln +{ + + namespace accu + { + + + /*! Generic min accumulator class. + * + * The parameter \c V is the type of values. + */ + template <typename V> + struct min : public Accumulator< min<V> > + { + typedef V value; + + min(); + void take(const value& v); + void init(); + + operator V() const; + V to_value() const; + + protected: + + V v_; + }; + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V> + min<V>::min() + { + init(); + } + + template <typename V> + void min<V>::take(const value& v) + { + if (v < v_) + v_ = v; + } + + template <typename V> + void + min<V>::init() + { + v_ = mln_max(V); + } + + template <typename V> + min<V>::operator V() const + { + return v_; + } + + template <typename V> + V + min<V>::to_value() const + { + return v_; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_MIN_HH Index: mln/accu/sum.hh --- mln/accu/sum.hh (revision 0) +++ mln/accu/sum.hh (revision 0) @@ -0,0 +1,112 @@ +// 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_SUM_HH +# define MLN_ACCU_SUM_HH + +/*! \file mln/accu/sum.hh + * + * \brief Define an accumulator that computes a sum. + */ + +# include <mln/core/concept/accumulator.hh> + + +namespace mln +{ + + namespace accu + { + + + /*! Generic sum accumulator class. + * + * Parameter \c V is the type of values that we sum. Parameter \c + * S is the type to store the sum value; the default type of + * \c S is \c V. + */ + template <typename V, typename S = V> + struct sum : public Accumulator< sum<V,S> > + { + typedef V value; + + sum(); + void take(const value& v); + void init(); + + operator S() const; + S to_value() const; + + protected: + + S sum_; + }; + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V, typename S> + sum<V,S>::sum() + { + init(); + } + + template <typename V, typename S> + void sum<V,S>::take(const value& v) + { + sum_ += v; + } + + template <typename V, typename S> + void + sum<V,S>::init() + { + sum_ = 0; + } + + template <typename V, typename S> + sum<V,S>::operator S() const + { + return to_value; + } + + template <typename V, typename S> + S + sum<V,S>::to_value() const + { + return sum_ / count_; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_SUM_HH Index: mln/accu/max.hh --- mln/accu/max.hh (revision 0) +++ mln/accu/max.hh (revision 0) @@ -0,0 +1,112 @@ +// 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_MAX_HH +# define MLN_ACCU_MAX_HH + +/*! \file mln/accu/max.hh + * + * \brief Define an accumulator that computes a max. + */ + +# include <mln/core/concept/accumulator.hh> +# include <mln/value/props.hh> + + +namespace mln +{ + + namespace accu + { + + + /*! Generic max accumulator class. + * + * The parameter \c V is the type of values. + */ + template <typename V> + struct max : public Accumulator< max<V> > + { + typedef V value; + + max(); + void take(const value& v); + void init(); + + operator V() const; + V to_value() const; + + protected: + + V v_; + }; + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V> + max<V>::max() + { + init(); + } + + template <typename V> + void max<V>::take(const value& v) + { + if (v > v_) + v_ = v; + } + + template <typename V> + void + max<V>::init() + { + v_ = mln_min(V); + } + + template <typename V> + max<V>::operator V() const + { + return v_; + } + + template <typename V> + V + max<V>::to_value() const + { + return v_; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_MAX_HH Index: mln/accu/mean.hh --- mln/accu/mean.hh (revision 1015) +++ mln/accu/mean.hh (working copy) @@ -33,7 +33,8 @@ * \brief Define an accumulator that computes a mean. */ -# include <mln/core/concept/accumulator.hh> +# include <mln/accu/counter.hh> +# include <mln/accu/sum.hh> namespace mln @@ -64,8 +65,8 @@ protected: - std::size_t count_; - S sum_; + accu::counter<V> count_; + accu::sum<V,S> sum_; }; @@ -81,16 +82,16 @@ template <typename V, typename S, typename M> void mean<V,S,M>::take(const value& v) { - ++count_; - sum_ += v; + count_.take(v); + sum_.take(v); } template <typename V, typename S, typename M> void mean<V,S,M>::init() { - count_ = 0; - sum_ = 0; + count_.init(); + sum_.init(); } template <typename V, typename S, typename M> @@ -103,7 +104,7 @@ M mean<V,S,M>::to_value() const { - return sum_ / count_; + return sum_.to_value() / count_.to_value(); } # endif // ! MLN_INCLUDE_ONLY