https://svn.lrde.epita.fr/svn/oln/trunk/milena
Index: ChangeLog
from Thierry Geraud <thierry.geraud(a)lrde.epita.fr>
Add hit-or-miss and p2v ternary+elif functions.
* tests/morpho_hit_or_miss.cc: New.
* mln/fun/p2v/elifs.hh: New.
* mln/fun/p2v/ternary.hh: New.
* mln/morpho/min.hh: New.
* mln/morpho/hit_or_miss.hh: New.
* mln/arith/min.hh: New.
* mln/value/int_u_sat.hh: New.
* img/picasso.pgm: New.
* mln/arith/revert.hh: Fix.
* mln/morpho/includes.hh: Update.
img/picasso.pgm | 0
mln/arith/min.hh | 147 ++++++++++++++++++++++++++
mln/arith/revert.hh | 2
mln/fun/p2v/elifs.hh | 84 +++++++++++++++
mln/fun/p2v/ternary.hh | 117 +++++++++++++++++++++
mln/morpho/hit_or_miss.hh | 243 ++++++++++++++++++++++++++++++++++++++++++++
mln/morpho/includes.hh | 4
mln/morpho/min.hh | 121 +++++++++++++++++++++
mln/value/int_u_sat.hh | 191 ++++++++++++++++++++++++++++++++++
tests/morpho_hit_or_miss.cc | 85 +++++++++++++++
10 files changed, 992 insertions(+), 2 deletions(-)
Index: tests/morpho_hit_or_miss.cc
--- tests/morpho_hit_or_miss.cc (revision 0)
+++ tests/morpho_hit_or_miss.cc (revision 0)
@@ -0,0 +1,85 @@
+// 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/morpho_hit_or_miss.cc
+ *
+ * \brief Test on mln::morpho::hit_or_miss.
+ */
+
+#include <mln/core/image2d_b.hh>
+#include <mln/value/int_u8.hh>
+
+#include <mln/core/win/rectangle2d.hh>
+#include <mln/core/window2d.hh>
+#include <mln/geom/shift.hh>
+#include <mln/set/diff.hh>
+
+#include <mln/io/load_pgm.hh>
+#include <mln/io/save_pgm.hh>
+#include <mln/level/fill.hh>
+#include <mln/level/stretch.hh>
+
+#include <mln/morpho/hit_or_miss.hh>
+
+
+int main()
+{
+ using namespace mln;
+ using value::int_u8;
+
+ window2d win_hit = geom::shift(win::rectangle2d(3, 3),
+ make::dpoint2d(+1, +1));
+ window2d win_miss = set::diff(win::rectangle2d(5, 5), win_hit);
+
+ {
+ bool hit[] = { 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 1, 1, 1,
+ 0, 0, 1, 1, 1 };
+ window2d win_hit_ = make::window2d(hit);
+ mln_precondition(win_hit_ = win_hit);
+
+ bool miss[] = { 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1,
+ 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0 };
+ window2d win_miss_ = make::window2d(miss);
+ mln_precondition(win_miss_ = win_miss);
+ }
+
+ border::thickness = 2;
+
+ image2d_b<int_u8>
+ lena = io::load_pgm("../img/picasso.pgm"),
+ out(lena.domain());
+
+ morpho::hit_or_miss(lena, win_hit, win_miss, out);
+
+ io::save_pgm(out, "out.pgm");
+}
Index: mln/fun/p2v/elifs.hh
--- mln/fun/p2v/elifs.hh (revision 0)
+++ mln/fun/p2v/elifs.hh (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.
+
+#ifndef MLN_FUN_P2V_ELIFS_HH
+# define MLN_FUN_P2V_ELIFS_HH
+
+/*! \file mln/fun/p2v/elifs.hh
+ *
+ * \brief FIXME.
+ */
+
+# include <mln/fun/p2v/ternary.hh>
+
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace p2v
+ {
+
+ template <typename T1, typename N1,
+ typename T2, typename N2,
+ typename O>
+ ternary_<T1, N1,
+ ternary_<T2, N2, O> >
+ elifs(const Function_p2b<T1>& f_if_1, const Function_p2v<N1>&
f_then_1,
+ const Function_p2b<T2>& f_if_2, const Function_p2v<N2>&
f_then_2,
+ const Function_p2v<O>& f_otherwise);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename T1, typename N1,
+ typename T2, typename N2,
+ typename O>
+ ternary_<T1, N1,
+ ternary_<T2, N2, O> >
+ elifs(const Function_p2b<T1>& f_if_1, const Function_p2v<N1>&
f_then_1,
+ const Function_p2b<T2>& f_if_2, const Function_p2v<N2>&
f_then_2,
+ const Function_p2v<O>& f_otherwise)
+ {
+ typedef ternary_<T2, N2, O> T2_N2_O;
+ T2_N2_O f_otherwise_1(f_if_2, f_then_2, f_otherwise);
+ ternary_<T1, N1, T2_N2_O> tmp(f_if_1, f_then_1, f_otherwise_1);
+ return tmp;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::fun::p2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+
+#endif // ! MLN_FUN_P2V_ELIFS_HH
Index: mln/fun/p2v/ternary.hh
--- mln/fun/p2v/ternary.hh (revision 0)
+++ mln/fun/p2v/ternary.hh (revision 0)
@@ -0,0 +1,117 @@
+// 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_TERNARY_HH
+# define MLN_FUN_P2V_TERNARY_HH
+
+/*! \file mln/fun/p2v/ternary.hh
+ *
+ * \brief FIXME.
+ */
+
+# include <mln/fun/internal/selector.hh>
+
+
+namespace mln
+{
+
+ namespace fun
+ {
+
+ namespace p2v
+ {
+
+ template <typename P, typename T, typename F>
+ struct ternary_
+ : fun::internal::selector_p2_<mln_result(T), ternary_<P,T,F> >::ret
+ {
+ typedef mln_result(T) result;
+
+ ternary_(const Function_p2b<P>& f_pred,
+ const Function_p2v<T>& f_true,
+ const Function_p2v<F>& f_false);
+
+ template <typename Pt>
+ result operator()(const Pt& p) const;
+
+ protected:
+ const P f_pred_;
+ const T f_true_;
+ const F f_false_;
+ };
+
+
+ template <typename P, typename T, typename F>
+ ternary_<P, T, F>
+ ternary(const Function_p2b<P>& f_pred,
+ const Function_p2v<T>& f_true,
+ const Function_p2v<F>& f_false);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <typename P, typename T, typename F>
+ ternary_<P,T,F>::ternary_(const Function_p2b<P>& f_pred,
+ const Function_p2v<T>& f_true,
+ const Function_p2v<F>& f_false)
+ : f_pred_(exact(f_pred)),
+ f_true_(exact(f_true)),
+ f_false_(exact(f_false))
+ {
+ }
+
+ template <typename P, typename T, typename F>
+ template <typename Pt>
+ mln_result(T)
+ ternary_<P,T,F>::operator()(const Pt& p) const
+ {
+ return f_pred_(p) ? f_true_(p) : f_false_(p);
+ }
+
+
+ template <typename P, typename T, typename F>
+ ternary_<P, T, F>
+ ternary(const Function_p2b<P>& f_pred,
+ const Function_p2v<T>& f_true,
+ const Function_p2v<F>& f_false)
+ {
+ ternary_<P, T, F> tmp(exact(f_pred),
+ exact(f_true),
+ exact(f_false));
+ return tmp;
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::fun::p2v
+
+ } // end of namespace mln::fun
+
+} // end of namespace mln
+
+
+#endif // ! MLN_FUN_P2V_TERNARY_HH
Index: mln/morpho/min.hh
--- mln/morpho/min.hh (revision 0)
+++ mln/morpho/min.hh (revision 0)
@@ -0,0 +1,121 @@
+// 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_MORPHO_MIN_HH
+# define MLN_MORPHO_MIN_HH
+
+# include <mln/level/compare.hh>
+# include <mln/logical/and.hh>
+# include <mln/arith/min.hh>
+
+
+namespace mln
+{
+
+ namespace morpho
+ {
+
+ /*! Morphological min: either a logical "and" (if morpho on sets)
+ * or an arithmetical min (if morpho on functions).
+ */
+ template <typename I, typename J, typename O>
+ void min(const Image<I>& lhs, const Image<J>& rhs,
+ Image<O>& output);
+
+ /*! Morphological min, inplace version: either a logical "and" (if
+ * morpho on sets) or an arithmetical min (if morpho on
+ * functions).
+ */
+ template <typename I, typename J>
+ void min_inplace(Image<I>& lhs, const Image<J>& rhs);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ namespace impl
+ {
+
+ template <typename I, typename J, typename O>
+ void min_(value::binary_kind, // binary => morphology on sets
+ const Image<I>& lhs, const Image<J>& rhs,
+ Image<O>& output)
+ {
+ return logical::and_(lhs, rhs, output);
+ }
+
+ template <typename K, typename I, typename J, typename O>
+ void min_(K, // otherwise => morphology on functions
+ const Image<I>& lhs, const Image<J>& rhs,
+ Image<O>& output)
+ {
+ return arith::min(lhs, rhs, output);
+ }
+
+ // in place
+
+ template <typename I, typename J>
+ void min_inplace_(value::binary_kind, // binary => morphology on sets
+ Image<I>& lhs, const Image<J>& rhs)
+ {
+ return logical::and_inplace(lhs, rhs);
+ }
+
+ template <typename K, typename I, typename J>
+ void min_inplace_(K, // otherwise => morphology on functions
+ Image<I>& lhs, const Image<J>& rhs)
+ {
+ return arith::min_inplace(lhs, rhs);
+ }
+
+ } // end of namespace mln::morpho::impl
+
+
+ // Facades.
+
+ template <typename I, typename J, typename O>
+ void min(const Image<I>& lhs, const Image<J>& rhs,
Image<O>& output)
+ {
+ mln_precondition(exact(rhs).domain() = exact(lhs).domain());
+ mln_precondition(exact(output).domain() = exact(lhs).domain());
+ impl::min_(mln_value_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(I)(), exact(lhs), exact(rhs));
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::morpho
+
+} // end of namespace mln
+
+
+#endif // ! MLN_MORPHO_MIN_HH
Index: mln/morpho/includes.hh
--- mln/morpho/includes.hh (revision 1062)
+++ mln/morpho/includes.hh (working copy)
@@ -49,13 +49,15 @@
# include <mln/border/fill.hh>
# include <mln/geom/sym.hh>
+# include <mln/set/inter.hh>
# include <mln/morpho/dilation.hh>
# include <mln/morpho/erosion.hh>
+# include <mln/morpho/min.hh>
+# include <mln/morpho/complementation.hh>
# include <mln/morpho/minus.hh>
# include <mln/morpho/plus.hh>
-# include <mln/morpho/complementation.hh>
#endif // ! MLN_MORPHO_INCLUDES_HH
Index: mln/morpho/hit_or_miss.hh
--- mln/morpho/hit_or_miss.hh (revision 0)
+++ mln/morpho/hit_or_miss.hh (revision 0)
@@ -0,0 +1,243 @@
+// 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_MORPHO_HIT_OR_MISS_HH
+# define MLN_MORPHO_HIT_OR_MISS_HH
+
+/*! \file mln/morpho/hit_or_miss.hh
+ *
+ * \brief Morphological hit-or-miss.
+ *
+ * \todo Save memory.
+ */
+
+# include <mln/morpho/includes.hh>
+# include <mln/pw/all.hh>
+# include <mln/fun/p2v/ternary.hh>
+
+
+namespace mln
+{
+
+ namespace morpho
+ {
+
+
+ bool constrained_hit_or_miss = true;
+
+
+ /*! Morphological hit-or-miss.
+ *
+ * This operator is HMT_(Bh,Bm) = e_Bh /\ (e_Bm o C).
+ */
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output);
+
+ /*! Morphological hit-or-miss opening.
+ *
+ * This operator is d_(-Bh) o HMT_(Bh,Bm).
+ */
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_opening(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output);
+
+ /*! Morphological hit-or-miss opening of the background.
+ *
+ * This operator is FIXME.
+ */
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_background_opening(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output);
+
+ /*! Morphological hit-or-miss closing.
+ *
+ * This operator is FIXME.
+ */
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_closing(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output);
+
+ /*! Morphological hit-or-miss closing of the background.
+ *
+ * This operator is FIXME.
+ */
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_background_closing(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ namespace impl
+ {
+
+ // Preconditions.
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_preconditions_(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ mln_precondition(exact(output).domain() = exact(input).domain());
+ mln_precondition(set::inter(exact(win_hit), exact(win_miss)).is_empty());
+ }
+
+ // On sets.
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_(value::binary_kind, // binary => morphology on sets
+ const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ erosion(input, win_hit, output); // output = ero(input)_hit
+
+ O temp_1(exact(input).domain());
+ complementation(input, temp_1); // temp1 = C(input)
+
+ O temp_2(exact(input).domain());
+ erosion(temp_1, win_miss, temp_2); // temp_2 = ero(C(input))_miss
+
+ logical::and_inplace(output, temp_2); // output = ero(input)_hit /\ ero(C(input))_miss
+ }
+
+ // On functions.
+
+ template <typename K,
+ typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_(K, // otherwise => morphology on functions
+ const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ typedef mln_value(O) V;
+
+ if (constrained_hit_or_miss) // CHMT.
+ {
+ if (exact(win_hit).is_centered())
+ {
+ O ero_fg(exact(input).domain()), dil_bg(exact(input).domain());
+ erosion(input, win_hit, ero_fg);
+ dilation(input, win_miss, dil_bg);
+ level::fill(output,
+ fun::p2v::ternary(pw::value(input) = pw::value(ero_fg) &&
pw::value(dil_bg) < pw::value(input),
+ pw::value(input) - pw::value(dil_bg),
+ pw::cst(V::zero)));
+ }
+ else if (exact(win_miss).is_centered())
+ {
+ O ero_bg(exact(input).domain()), dil_fg(exact(input).domain());
+ erosion(input, win_miss, ero_bg);
+ dilation(input, win_hit, dil_fg);
+ level::fill(output,
+ fun::p2v::ternary(pw::value(input) = pw::value(dil_fg) &&
pw::value(ero_bg) > pw::value(input),
+ pw::value(ero_bg) - pw::value(input),
+ pw::cst(V::zero)));
+ }
+ else
+ level::fill(output, pw::cst(V::zero));
+ }
+ else // Unconstrained: UHMT.
+ {
+ O ero(exact(input).domain()), dil(exact(input).domain());
+ erosion(input, win_hit, ero);
+ dilation(input, win_miss, dil);
+ level::fill(output,
+ fun::p2v::ternary(pw::value(dil) < pw::value(ero),
+ pw::value(ero) - pw::value(dil),
+ pw::cst(V::zero)));
+ }
+ }
+
+ } // end of mln::morpho::impl
+
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output);
+ impl::hit_or_miss_(mln_value_kind(I)(), input, win_hit, win_miss, output);
+ }
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_opening(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output);
+
+ O temp(exact(input).domain());
+ hit_or_miss(input, win_hit, win_miss, temp);
+ dilation(temp, geom::sym(win_hit), output);
+ }
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_background_opening(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output);
+ hit_or_miss_opening(input, win_miss, win_hit, output);
+ }
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_closing(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output);
+ I temp(input.domain());
+ complementation(input, temp);
+ hit_or_miss_opening(temp, win_hit, win_miss, output);
+ complementation_inplace(output);
+ }
+
+ template <typename I, typename Wh, typename Wm, typename O>
+ void hit_or_miss_background_closing(const Image<I>& input,
+ const Window<Wh>& win_hit, const Window<Wm>& win_miss,
+ Image<O>& output)
+ {
+ impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output);
+ hit_or_miss_closing(input, win_miss, win_hit, output);
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::morpho
+
+} // end of namespace mln
+
+
+#endif // ! MLN_MORPHO_HIT_OR_MISS_HH
Index: mln/arith/min.hh
--- mln/arith/min.hh (revision 0)
+++ mln/arith/min.hh (revision 0)
@@ -0,0 +1,147 @@
+// 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_MIN_HH
+# define MLN_ARITH_MIN_HH
+
+/*! \file mln/arith/min.hh
+ *
+ * \brief Point-wise min between images.
+ */
+
+# include <mln/core/concept/image.hh>
+
+
+namespace mln
+{
+
+ namespace arith
+ {
+
+ /*! Point-wise min 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 min(const Image<L>& lhs, const Image<R>& rhs,
Image<O>& output);
+
+
+ /*! Point-wise min of image \p lhs in image \p rhs.
+ *
+ * \param[in,out] lhs First operand image.
+ * \param[in] rhs Second operand image.
+ *
+ * This substraction performs: \n
+ * for all p of rhs.domain \n
+ * if rhs(p) < lhs(p) \n
+ * lhs(p) = rhs(p)
+ *
+ * \pre \p rhs.domain <= \p lhs.domain
+ */
+ template <typename L, typename R>
+ void min_inplace(Image<L>& lhs, const Image<R>& rhs);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ namespace impl
+ {
+
+ template <typename L, typename R, typename O>
+ void min_(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_piter(L) p(lhs.domain());
+ for_all(p)
+ output(p) = lhs(p) < rhs(p) ? lhs(p) : rhs(p);
+ }
+
+ template <typename L, typename R, typename O>
+ void min_(const Fast_Image<L>& lhs, const Fast_Image<R>& rhs,
Fast_Image<O>& output)
+ {
+ mln_pixter(const L) lp(exact(lhs));
+ mln_pixter(const R) rp(exact(rhs));
+ mln_pixter(O) op(exact(output));
+ for_all_3(lp, rp, op)
+ op.val() = lp.val() < rp.val() ? lp.val() : rp.val();
+ }
+
+ template <typename L, typename R>
+ void min_inplace_(Image<L>& lhs_, const Image<R>& rhs_)
+ {
+ L& lhs = exact(lhs_);
+ const R& rhs = exact(rhs_);
+ mln_piter(R) p(rhs.domain());
+ for_all(p)
+ if (rhs(p) < lhs(p))
+ lhs(p) = rhs(p);
+ }
+
+ template <typename L, typename R>
+ void min_inplace_(Fast_Image<L>& lhs, const Fast_Image<R>&
rhs)
+ {
+ mln_pixter(L) lp(exact(lhs));
+ mln_pixter(const R) rp(exact(rhs));
+ for_all_2(rp, lp)
+ if (rp.val() < lp.val())
+ lp.val() = rp.val();
+ }
+
+ } // end of namespace mln::arith::impl
+
+
+ // Facades.
+
+ template <typename L, typename R, typename O>
+ void min(const Image<L>& lhs, const Image<R>& rhs,
Image<O>& output)
+ {
+ mln_precondition(exact(rhs).domain() = exact(lhs).domain());
+ mln_precondition(exact(output).domain() = exact(lhs).domain());
+ impl::min_(exact(lhs), exact(rhs), exact(output));
+ }
+
+ template <typename L, typename R>
+ void min_inplace(Image<L>& lhs, const Image<R>& rhs)
+ {
+ mln_precondition(exact(rhs).domain() <= exact(lhs).domain());
+ impl::min_inplace_(exact(lhs), exact(rhs));
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::arith
+
+} // end of namespace mln
+
+
+#endif // ! MLN_ARITH_MIN_HH
Index: mln/arith/revert.hh
--- mln/arith/revert.hh (revision 1062)
+++ mln/arith/revert.hh (working copy)
@@ -95,7 +95,7 @@
mln_pixter(const I) ip(exact(input));
mln_pixter(O) op(exact(output));
for_all_2(ip, op)
- op.val() = mln_min(V) + (mln_max(V) - op.val());
+ op.val() = mln_min(V) + (mln_max(V) - ip.val());
}
} // end of namespace mln::arith::impl
Index: mln/value/int_u_sat.hh
--- mln/value/int_u_sat.hh (revision 0)
+++ mln/value/int_u_sat.hh (revision 0)
@@ -0,0 +1,191 @@
+// 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_INT_U_SAT_HH
+# define MLN_VALUE_INT_U_SAT_HH
+
+/*! \file mln/value/int_u_sat.hh
+ *
+ * \brief Define a generic class for unsigned integers with saturation
+ * behavior.
+ */
+
+# include <mln/metal/math.hh>
+# include <mln/value/internal/value_like.hh>
+# include <mln/value/internal/encoding.hh>
+# include <mln/value/props.hh>
+# include <mln/debug/format.hh>
+
+
+namespace mln
+{
+
+ namespace value
+ {
+
+
+ /*! \brief Unsigned integer value class with saturation behavior.
+ *
+ * The parameter is \c n the number of encoding bits.
+ */
+ template <unsigned n>
+ struct int_u_sat
+ : public internal::value_like_< typename
internal::encoding_unsigned_<n>::ret,
+ int_u_sat<n> >
+ {
+ protected:
+ typedef internal::value_like_< typename
internal::encoding_unsigned_<n>::ret,
+ int_u_sat<n> > super;
+
+ public:
+
+ /// Encoding associated type.
+ typedef typename super::enc enc;
+
+ /// Constructor without argument.
+ int_u_sat();
+
+ /// Constructor from an integer.
+ int_u_sat(int i);
+
+ /// Assignment from an integer.
+ int_u_sat<n>& operator=(int i);
+
+ /// Zero value.
+ static const int_u_sat<n> zero;
+
+ /// Unit value.
+ static const int_u_sat<n> one;
+
+ /// Self addition.
+ int_u_sat<n>& operator+=(int i);
+
+ /// Self subtraction.
+ int_u_sat<n>& operator-=(int i);
+ };
+
+
+ // Safety.
+ template <> struct int_u_sat<0>;
+ template <> struct int_u_sat<1>;
+
+
+
+ template <unsigned n>
+ struct props< int_u_sat<n> >
+ {
+ static const std::size_t card_ = metal::pow<2, n>::value;
+ static const int_u_sat<n> min() { return 0; }
+ static const int_u_sat<n> max() { return card_ - 1; }
+ static const unsigned nbits = n;
+ typedef data_kind kind;
+ typedef float sum;
+ };
+
+
+
+ /*! \brief Print a saturated unsigned integer \p i into the output
+ * stream \p ostr.
+ *
+ * \param[in,out] ostr An output stream.
+ * \param[in] i A saturated unsigned integer.
+ *
+ * \return The modified output stream \p ostr.
+ */
+ template <unsigned n>
+ std::ostream& operator<<(std::ostream& ostr, const
int_u_sat<n>& i);
+
+
+# ifndef MLN_INCLUDE_ONLY
+
+ template <unsigned n>
+ int_u_sat<n>::int_u_sat()
+ {
+ }
+
+ template <unsigned n>
+ int_u_sat<n>::int_u_sat(int i)
+ {
+ if (i < 0)
+ this->v_ = enc(0);
+ else if (i > mln_max(enc))
+ this->v_ = mln_max(enc);
+ else
+ this->v_ = enc(i);
+ }
+
+ template <unsigned n>
+ int_u_sat<n>&
+ int_u_sat<n>::operator=(int i)
+ {
+ if (i < 0)
+ this->v_ = enc(0);
+ else if (i > mln_max(enc))
+ this->v_ = mln_max(enc);
+ else
+ this->v_ = enc(i);
+ return *this;
+ }
+
+ template <unsigned n>
+ int_u_sat<n>&
+ int_u_sat<n>::operator+=(int i)
+ {
+ int v = int(this->v_) + i;
+ *this = v;
+ return *this;
+ }
+
+ template <unsigned n>
+ int_u_sat<n>&
+ int_u_sat<n>::operator-=(int i)
+ {
+ int v = int(this->v_) - i;
+ *this = v;
+ return *this;
+ }
+
+ template <unsigned n>
+ const int_u_sat<n> int_u_sat<n>::zero = 0;
+
+ template <unsigned n>
+ const int_u_sat<n> int_u_sat<n>::one = 1;
+
+ template <unsigned n>
+ std::ostream& operator<<(std::ostream& ostr, const
int_u_sat<n>& i)
+ {
+ return ostr << debug::format(i.to_equiv());
+ }
+
+# endif // ! MLN_INCLUDE_ONLY
+
+ } // end of namespace mln::value
+
+} // end of namespace mln
+
+
+#endif // ! MLN_VALUE_INT_U_SAT_HH
Index: img/picasso.pgm
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes on: img/picasso.pgm
___________________________________________________________________
Name: svn:mime-type
+ application/octet-stream