URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2008-12-12 Matthieu Garrigues &lt;garrigues(a)lrde.epita.fr&gt; Make level::compare use test::predicate. * mln/level/compare.hh: . * mln/test/predicate.hh: Add a version which works on two images. Add the concept of vv2b function. * mln/fun/vv2b: New. * mln/core/concept/function.hh: . Add some vv2b functions. * mln/fun/vv2b/eq.hh: New. * mln/fun/vv2b/ge.hh: New. * mln/fun/vv2b/gt.hh: New. * mln/fun/vv2b/implies.hh: New. * mln/fun/vv2b/le.hh: New. * mln/fun/vv2b/lt.hh: New. --- core/concept/function.hh | 36 ++++++++++++++++++++++ fun/vv2b/eq.hh | 75 +++++++++++++++++++++++++++++++++++++++++++++++ fun/vv2b/ge.hh | 75 +++++++++++++++++++++++++++++++++++++++++++++++ fun/vv2b/gt.hh | 75 +++++++++++++++++++++++++++++++++++++++++++++++ fun/vv2b/implies.hh | 75 +++++++++++++++++++++++++++++++++++++++++++++++ fun/vv2b/le.hh | 75 +++++++++++++++++++++++++++++++++++++++++++++++ fun/vv2b/lt.hh | 75 +++++++++++++++++++++++++++++++++++++++++++++++ level/compare.hh | 31 ++++++++++--------- test/predicate.hh | 62 ++++++++++++++++++++++++++++++++++++-- 9 files changed, 560 insertions(+), 19 deletions(-) Index: trunk/milena/mln/core/concept/function.hh =================================================================== --- trunk/milena/mln/core/concept/function.hh (revision 3038) +++ trunk/milena/mln/core/concept/function.hh (revision 3039) @@ -52,6 +52,7 @@ template <typename E> struct Function_l2l; template <typename E> struct Function_vv2v; + template <typename E> struct Function_vv2b; /// Function category flag type. template <> @@ -324,6 +325,28 @@ Function_vv2v(const Function_vv2v&); }; + /*------------------------. + | Value, Value -> Boolean.| + `------------------------*/ + + template <> + struct Function_vv2b<void> { typedef Function<void> super; }; + + /// Base class for implementation of function-objects from + /// a couple of values to a boolean. + /// + /// The parameter \a E is the exact type. + /// + template <typename E> + struct Function_vv2b : public Function<E> + { + typedef bool result; + typedef Function_vv2b<void> category; + protected: + Function_vv2b(); + Function_vv2b(const Function_vv2b&); + }; + # ifndef MLN_INCLUDE_ONLY @@ -483,6 +506,19 @@ { } + template <typename E> + inline + Function_vv2b<E>::Function_vv2b() + { + } + + template <typename E> + inline + Function_vv2b<E>::Function_vv2b(const Function_vv2b<E>& rhs) + : Function<E>(rhs) + { + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: trunk/milena/mln/level/compare.hh =================================================================== --- trunk/milena/mln/level/compare.hh (revision 3038) +++ trunk/milena/mln/level/compare.hh (revision 3039) @@ -34,6 +34,10 @@ */ # include <mln/core/concept/image.hh> +# include <mln/fun/vv2b/eq.hh> +# include <mln/fun/vv2b/le.hh> +# include <mln/fun/vv2b/lt.hh> +# include <mln/test/predicate.hh> namespace mln @@ -82,42 +86,39 @@ inline bool operator == (const Image<L>& lhs_, const Image<R>& rhs_) { + typedef fun::vv2b::eq<mln_value(L), mln_value(R)> F; + const L& lhs = exact(lhs_); const R& rhs = exact(rhs_); mln_precondition(lhs.domain() == rhs.domain()); - mln_piter(L) p(lhs.domain()); - for_all(p) - if (! (lhs(p) == rhs(p))) - return false; - return true; + + return test::predicate(lhs_, rhs_, F()); } template <typename L, typename R> inline bool operator < (const Image<L>& lhs_, const Image<R>& rhs_) { + typedef fun::vv2b::lt<mln_value(L), mln_value(R)> F; + const L& lhs = exact(lhs_); const R& rhs = exact(rhs_); mln_precondition(lhs.domain() == rhs.domain()); - mln_piter(L) p(lhs.domain()); - for_all(p) - if (! (lhs(p) < rhs(p))) - return false; - return true; + + return test::predicate(lhs_, rhs_, F()); } template <typename L, typename R> // required! inline bool operator <= (const Image<L>& lhs_, const Image<R>& rhs_) { + typedef fun::vv2b::le<mln_value(L), mln_value(R)> F; + const L& lhs = exact(lhs_); const R& rhs = exact(rhs_); mln_precondition(lhs.domain() == rhs.domain()); - mln_piter(L) p(lhs.domain()); - for_all(p) - if (! (lhs(p) <= rhs(p))) - return false; - return true; + + return test::predicate(lhs_, rhs_, F()); } # endif // ! MLN_INCLUDE_ONLY Index: trunk/milena/mln/test/predicate.hh =================================================================== --- trunk/milena/mln/test/predicate.hh (revision 3038) +++ trunk/milena/mln/test/predicate.hh (revision 3039) @@ -54,6 +54,17 @@ bool predicate(const Image<I>& ima, const Function_v2b<F>& f); + /*! Test if all pixel values of \p lhs and \p rhs verify the + * predicate \p f. + * + * \param[in] lhs The image. + * \param[in] rhs The image. + * \param[in] f The predicate. + */ + template <typename I, typename J, typename F> + bool predicate(const Image<I>& lhs, const Image<J>& rhs, const Function_v2b<F>& f); + + /*! Test if all points of \p pset verify the predicate \p f. * * \param[in] pset The point set. @@ -70,9 +81,8 @@ template <typename I, typename F> inline - bool predicate_(trait::image::speed::any, const I& ima_, const F& f) + bool predicate_(trait::image::speed::any, const I& ima, const F& f) { - const I& ima = exact(ima_); mln_piter(I) p(ima.domain()); for_all(p) if (! f(ima(p))) @@ -82,9 +92,8 @@ template <typename I, typename F> inline - bool predicate_(trait::image::speed::fastest, const I& ima_, const F& f) + bool predicate_(trait::image::speed::fastest, const I& ima, const F& f) { - const I& ima = exact(ima_); mln_pixter(const I) pxl(ima); for_all(pxl) if (! f(pxl.val())) @@ -92,6 +101,33 @@ return true; } + template <typename I, typename J, typename F> + inline + bool predicate_(trait::image::speed::any, + trait::image::speed::any, + const I& lhs, const J& rhs, const F& f) + { + mln_piter(I) p(lhs.domain()); + for_all(p) + if (! f(lhs(p), rhs(p))) + return false; + return true; + } + + template <typename I, typename J, typename F> + inline + bool predicate_(trait::image::speed::fastest, + trait::image::speed::fastest, + const I& lhs, const J& rhs, const F& f) + { + mln_pixter(const I) pxl1(lhs); + mln_pixter(const I) pxl2(rhs); + for_all_2(pxl1, pxl2) + if (! f(pxl1.val(), pxl2.val())) + return false; + return true; + } + template <typename S, typename F> inline bool predicate_(const Site_Set<S>& pset, const F& f) @@ -117,6 +153,24 @@ exact(f)); } + + template <typename I, typename J, typename F> + inline + bool predicate(const Image<I>& lhs_, const Image<J>& rhs_, const Function_vv2b<F>& f) + { + const I& lhs = exact(lhs_); + const J& rhs = exact(rhs_); + + mln_precondition(lhs.has_data()); + mln_precondition(rhs.has_data()); + mln_precondition(lhs.domain() == rhs.domain()); + + return impl::predicate_(mln_trait_image_speed(I)(), + mln_trait_image_speed(J)(), + lhs, rhs, + exact(f)); + } + template <typename S, typename F> inline bool predicate(const Site_Set<S>& pset, const Function_p2b<F>& f) Index: trunk/milena/mln/fun/vv2b/implies.hh =================================================================== --- trunk/milena/mln/fun/vv2b/implies.hh (revision 0) +++ trunk/milena/mln/fun/vv2b/implies.hh (revision 3039) @@ -0,0 +1,75 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2B_IMPLIES_HH +# define MLN_FUN_VV2B_IMPLIES_HH + +/// \file mln/fun/vv2b/implies.hh +/// +/// Functor that computes "logical implies" between two values. + +# include <mln/core/concept/function.hh> +# include <mln/trait/op/and.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2b + { + + /// Functor computing logical-implies between two values. + template <typename L, typename R = L> + struct implies : public Function_vv2b< implies<L,R> > + { + bool operator()(const L& v1, const R& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R> + inline + bool + implies<L,R>::operator()(const L& v1, const R& v2) const + { + return (! v1) || v2; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2B_IMPLIES_HH Index: trunk/milena/mln/fun/vv2b/eq.hh =================================================================== --- trunk/milena/mln/fun/vv2b/eq.hh (revision 0) +++ trunk/milena/mln/fun/vv2b/eq.hh (revision 3039) @@ -0,0 +1,75 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2B_EQ_HH +# define MLN_FUN_VV2B_EQ_HH + +/// \file mln/fun/vv2b/eq.hh +/// +/// Functor that computes equal between two values. + +# include <mln/core/concept/function.hh> +# include <mln/trait/op/and.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2b + { + + /// Functor computing equal between two values. + template <typename L, typename R = L> + struct eq : public Function_vv2b< eq<L,R> > + { + bool operator()(const L& v1, const R& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R> + inline + bool + eq<L,R>::operator()(const L& v1, const R& v2) const + { + return v1 == v2; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2B_EQ_HH Index: trunk/milena/mln/fun/vv2b/gt.hh =================================================================== --- trunk/milena/mln/fun/vv2b/gt.hh (revision 0) +++ trunk/milena/mln/fun/vv2b/gt.hh (revision 3039) @@ -0,0 +1,75 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2B_GT_HH +# define MLN_FUN_VV2B_GT_HH + +/// \file mln/fun/vv2b/gt.hh +/// +/// Functor that computes "greater than" between two values. + +# include <mln/core/concept/function.hh> +# include <mln/trait/op/and.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2b + { + + /// Functor computing "greater than" between two values. + template <typename L, typename R = L> + struct gt : public Function_vv2b< gt<L,R> > + { + bool operator()(const L& v1, const R& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R> + inline + bool + gt<L,R>::operator()(const L& v1, const R& v2) const + { + return v1 > v2; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2B_GT_HH Index: trunk/milena/mln/fun/vv2b/ge.hh =================================================================== --- trunk/milena/mln/fun/vv2b/ge.hh (revision 0) +++ trunk/milena/mln/fun/vv2b/ge.hh (revision 3039) @@ -0,0 +1,75 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2B_GE_HH +# define MLN_FUN_VV2B_GE_HH + +/// \file mln/fun/vv2b/ge.hh +/// +/// Functor that computes "greater or equal than" between two values. + +# include <mln/core/concept/function.hh> +# include <mln/trait/op/and.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2b + { + + /// Functor computing "greater or equal than" between two values. + template <typename L, typename R = L> + struct ge : public Function_vv2b< ge<L,R> > + { + bool operator()(const L& v1, const R& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R> + inline + bool + ge<L,R>::operator()(const L& v1, const R& v2) const + { + return v1 >= v2; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2B_GE_HH Index: trunk/milena/mln/fun/vv2b/lt.hh =================================================================== --- trunk/milena/mln/fun/vv2b/lt.hh (revision 0) +++ trunk/milena/mln/fun/vv2b/lt.hh (revision 3039) @@ -0,0 +1,75 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2B_LT_HH +# define MLN_FUN_VV2B_LT_HH + +/// \file mln/fun/vv2b/lt.hh +/// +/// Functor that computes "lower than" between two values. + +# include <mln/core/concept/function.hh> +# include <mln/trait/op/and.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2b + { + + /// Functor computing "lower than" between two values. + template <typename L, typename R = L> + struct lt : public Function_vv2b< lt<L,R> > + { + bool operator()(const L& v1, const R& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R> + inline + bool + lt<L,R>::operator()(const L& v1, const R& v2) const + { + return v1 < v2; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2B_LT_HH Index: trunk/milena/mln/fun/vv2b/le.hh =================================================================== --- trunk/milena/mln/fun/vv2b/le.hh (revision 0) +++ trunk/milena/mln/fun/vv2b/le.hh (revision 3039) @@ -0,0 +1,75 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_VV2B_LE_HH +# define MLN_FUN_VV2B_LE_HH + +/// \file mln/fun/vv2b/le.hh +/// +/// Functor that computes "lower or equal than" between two values. + +# include <mln/core/concept/function.hh> +# include <mln/trait/op/and.hh> + + +namespace mln +{ + + namespace fun + { + + namespace vv2b + { + + /// Functor computing "lower or equal than" between two values. + template <typename L, typename R = L> + struct le : public Function_vv2b< le<L,R> > + { + bool operator()(const L& v1, const R& v2) const; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename L, typename R> + inline + bool + le<L,R>::operator()(const L& v1, const R& v2) const + { + return v1 <= v2; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::vv2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_VV2B_LE_HH