27 Apr
2005
27 Apr
'05
4:12 p.m.
2005-04-27 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
* oln/morpho/closing.hh: New-like file.
* oln/morpho/dilation.hh: Likewise.
* oln/morpho/elementary_erosion.hh: Likewise.
* oln/morpho/erosion.hh: Likewise.
* oln/morpho/geodesic_erosion.hh: Likewise.
* oln/morpho/opening.hh: Likewise.
* oln/morpho/stat.hh: Likewise.
* oln/morpho/tags.hh: Likewise.
Index: oln/morpho/closing.hh
===================================================================
--- oln/morpho/closing.hh (revision 0)
+++ oln/morpho/closing.hh (revision 0)
@@ -0,0 +1,103 @@
+// Copyright (C) 2001-2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_CLOSING_HH
+# define OLENA_MORPHO_CLOSING_HH
+
+# include <mlc/cmp.hh>
+# include <mlc/to_string.hh>
+
+# include <oln/morpho/erosion.hh>
+# include <oln/morpho/dilation.hh>
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+
+ // fwd decl of facade
+
+ template<typename I, typename W>
+ oln_type_of(I, concrete) closing(const abstract::image<I>& input,
+ const abstract::window<W>& win);
+
+
+
+ namespace impl {
+
+
+
+ // generic
+
+ template<typename I, typename W>
+ oln_type_of(I, concrete) closing_(const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ entering("generic");
+ oln_type_of(I, concrete) output;
+
+ output = dilation(erosion(input, win), -win);
+
+ exiting("generic");
+ return output;
+ }
+
+
+
+ } // end of namespace oln::morpho::impl
+
+
+
+
+ /// Generic closing (facade).
+
+ template<typename I, typename W>
+ oln_type_of(I, concrete) closing(const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+
+ entering("morpho::closing");
+ oln_type_of(I, concrete) output;
+
+ output = impl::closing_(input.exact(), win.exact());
+
+ exiting("morpho::closing");
+ return output;
+ }
+
+
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_CLOSING_HH
Index: oln/morpho/tags.hh
===================================================================
--- oln/morpho/tags.hh (revision 0)
+++ oln/morpho/tags.hh (revision 0)
@@ -0,0 +1,152 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_TAGS_HH
+# define OLENA_MORPHO_TAGS_HH
+
+# include <mlc/any.hh>
+# include <mlc/cmp.hh>
+# include <oln/basics.hh>
+
+# include <oln/morpho/stat.hh> // FIXME: rename!!!
+
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+ namespace tag
+ {
+
+ // Tags for selecting a given 'morphology' due to
+ // the couple of dual operations performed in erosion
+ // and dilation.
+
+
+ template <typename K>
+ struct kind : public mlc::any<K> // FIXME: name!
+ {
+
+ // min value in input on a window centered at p
+ template <typename I, typename W>
+ oln_type_of(I, value)
+ min(const abstract::image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win) const
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+ return this->exact().impl_min(input, p, win);
+ }
+
+ // max value in input on a window centered at p
+ template <typename I, typename W>
+ oln_type_of(I, value)
+ max(const abstract::image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win) const
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+ return this->exact().impl_max(input, p, win);
+ }
+
+ // min value in input of neighborhoods of p
+ template <typename I>
+ oln_type_of(I, value)
+ min_nbh(const abstract::image_with_nbh<I>& input,
+ const oln_type_of(I, point)& p) const
+ {
+ return this->exact().impl_min_nbh(input, p);
+ }
+
+ };
+
+
+
+ struct classical_type : public kind< classical_type >
+ {
+ // min value in input on a window centered at p
+ template <typename I, typename W>
+ oln_type_of(I, value)
+ impl_min(const abstract::image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win) const
+ {
+ return morpho::local_min(input, p, win);
+ }
+
+ // max value in input on a window centered at p
+ template <typename I, typename W>
+ oln_type_of(I, value)
+ impl_max(const abstract::image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win) const
+ {
+ return morpho::local_max(input, p, win);
+ }
+
+ // min value in input of neighborhoods of p
+ template <typename I>
+ oln_type_of(I, value)
+ impl_min_nbh(const abstract::image_with_nbh<I>& input,
+ const oln_type_of(I, point)& p) const
+ {
+ return morpho::local_min_nbh(input, p);
+ }
+
+ };
+
+ const classical_type classical = classical_type();
+
+
+ // Tags for approaches in reconstructions.
+
+ template <typename Op> struct oper {};
+
+ struct by_dilation_type : public oper< by_dilation_type > {};
+ struct by_erosion_type : public oper< by_erosion_type > {};
+
+
+ // Tags for common canvas.
+
+ template <typename A> struct algo {};
+
+ struct sequential_type : public algo< sequential_type > {};
+ struct hybrid_type : public algo< hybrid_type > {};
+ struct parallel_type : public algo< parallel_type > {};
+ struct unionfind_type : public algo< unionfind_type > {};
+
+ } // end of namespace oln::morpho::tag
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_EROSION_HH
Index: oln/morpho/opening.hh
===================================================================
--- oln/morpho/opening.hh (revision 0)
+++ oln/morpho/opening.hh (revision 0)
@@ -0,0 +1,118 @@
+// Copyright (C) 2001-2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_OPENING_HH
+# define OLENA_MORPHO_OPENING_HH
+
+# include <mlc/cmp.hh>
+# include <mlc/to_string.hh>
+
+# include <oln/morpho/erosion.hh>
+# include <oln/morpho/dilation.hh>
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+
+ // Fwd decl of opening's facade.
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) opening(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win);
+
+ // Facade for classical opening.
+
+ template<typename I, typename W>
+ oln_type_of(I, concrete) opening(const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ return opening(tag::classical, input, win);
+ }
+
+
+
+ namespace impl {
+
+
+ // generic
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) opening_(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ entering("->generic");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) output("output");
+ output = dilation(kind, erosion(kind, input, win), -win);
+
+ exiting("->generic");
+ return output;
+ }
+
+
+ // add some other impls here...
+
+
+ } // end of namespace oln::morpho::impl
+
+
+
+
+ /// Generic opening (facade).
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) opening(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+
+ entering("morpho::opening");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) output("output");
+ output = impl::opening_(kind, input.exact(), win.exact());
+
+ exiting("morpho::opening");
+ return output;
+ }
+
+
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_OPENING_HH
Index: oln/morpho/elementary_erosion.hh
===================================================================
--- oln/morpho/elementary_erosion.hh (revision 0)
+++ oln/morpho/elementary_erosion.hh (revision 0)
@@ -0,0 +1,113 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_ELEMENTARY_EROSION_HH
+# define OLENA_MORPHO_ELEMENTARY_EROSION_HH
+
+# include <oln/utils/record.hh>
+# include <oln/core/gen/image_with_nbh.hh>
+# include <oln/morpho/tags.hh>
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+
+ // Fwd decl of elementary erosion's facade.
+
+ template<typename K, typename I>
+ oln_type_of(I, concrete) elementary_erosion(const tag::kind<K>& kind,
+ const abstract::image_with_nbh<I>& input);
+
+ // Facade for classical elementary erosion.
+
+ template<typename I>
+ oln_type_of(I, concrete) elementary_erosion(const
abstract::image_with_nbh<I>& input)
+ {
+ return elementary_erosion(tag::classical, input);
+ }
+
+
+
+ namespace impl {
+
+
+ // generic
+
+ template<typename K, typename I>
+ oln_type_of(I, concrete) elementary_erosion_(const tag::kind<K>& kind,
+ const abstract::image_with_nbh<I>& input)
+ {
+ entering("->generic");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) output(input.size(), "output");
+
+ oln_type_of(I, piter) p(input.size());
+ for_all_p (p)
+ output[p] = kind.min_nbh(input, p);
+
+ exiting("->generic");
+ return output;
+ }
+
+
+ // add some other impls here...
+
+
+ } // end of namespace oln::morpho::impl
+
+
+
+
+ /// Generic elementary_erosion (facade).
+
+ template<typename K, typename I>
+ oln_type_of(I, concrete) elementary_erosion(const tag::kind<K>& kind,
+ const abstract::image_with_nbh<I>& input)
+ {
+ entering("morpho::elementary_erosion");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) output("output");
+ output = impl::elementary_erosion_(kind, input.exact());
+
+ exiting("morpho::elementary_erosion");
+ return output;
+ }
+
+
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_ELEMENTARY_EROSION_HH
Index: oln/morpho/dilation.hh
===================================================================
--- oln/morpho/dilation.hh (revision 0)
+++ oln/morpho/dilation.hh (revision 0)
@@ -0,0 +1,143 @@
+// Copyright (C) 2001-2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_DILATION_HH
+# define OLENA_MORPHO_DILATION_HH
+
+# include <mlc/cmp.hh>
+# include <mlc/to_string.hh>
+
+# include <oln/utils/record.hh>
+# include <oln/basics.hh>
+# include <oln/core/2d/window2d.hh>
+# include <oln/morpho/tags.hh>
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+
+ // Fwd decl of dilation's facade.
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) dilation(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win);
+
+ // Facade for classical dilation.
+
+ template<typename I, typename W>
+ oln_type_of(I, concrete) dilation(const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ return dilation(tag::classical, input, win);
+ }
+
+
+ namespace impl {
+
+ // generic
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) dilation_(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ entering("->generic");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) output(input.size(), "output");
+
+ oln_type_of(I, fwd_piter) p(input.size());
+ for_all_p (p)
+ output[p] = kind.min(input, p, win);
+
+ exiting("->generic");
+ return output;
+ }
+
+
+
+ // win is a 2D rectangle
+
+ template<typename K, typename I>
+ oln_type_of(I, concrete) dilation_(const tag::kind<K>& kind,
+ const abstract::image2d<I>& input,
+ const win_rectangle2d& win)
+ {
+ entering("->(image2d,win_rectangle2d)");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) temp("temp"), output("output");
+
+ win_hline2d hline(win.width); // FIXME: Cf. Soille, use L(i,dp)
+ win_vline2d vline(win.height);
+
+ temp = dilation(kind, input, hline);
+ output = dilation(kind, temp, vline);
+
+ exiting("->(image2d,win_rectangle2d)");
+ return output;
+ }
+
+
+ // add some other impls here...
+
+
+ } // end of namespace oln::morpho::impl
+
+
+
+
+ /// Generic dilation (facade).
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) dilation(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+ entering("morpho::dilation");
+
+ oln_type_of(I, concrete) output("output");
+ output = impl::dilation_(kind, input.exact(), win.exact());
+
+ exiting("morpho::dilation");
+ return output;
+ }
+
+
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_DILATION_HH
Index: oln/morpho/stat.hh
===================================================================
--- oln/morpho/stat.hh (revision 0)
+++ oln/morpho/stat.hh (revision 0)
@@ -0,0 +1,136 @@
+// Copyright (C) 2001, 2002, 2003, 2004, 2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_STAT_HH
+# define OLENA_MORPHO_STAT_HH
+
+# include <mlc/cmp.hh>
+# include <ntg/bin.hh>
+# include <oln/basics.hh>
+# include <oln/funobj/accum.hh>
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+ /// Local min on a function.
+
+ template <typename I, typename W>
+ oln_type_of(I, value) local_min(const abstract::image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+
+ oln_wn_type_of(W, fwd_iter) q(win);
+ funobj::min_accumulator<oln_type_of(I, value)> minval;
+
+ for_all_q_of_p (q, p)
+ if (input.hold(q))
+ minval(input[q]);
+
+ return minval;
+ }
+
+
+ template <typename I>
+ oln_type_of(I, value) local_min_nbh(const abstract::image_with_nbh<I>&
input,
+ const oln_type_of(I, point)& p)
+ {
+ oln_type_of(I, niter) n(input);
+ funobj::min_accumulator_init<oln_type_of(I, value)> minval(input[p]);
+
+ for_all_n_of_p (n, p)
+ if (input.hold(n))
+ minval(input[n]);
+
+ return minval;
+ }
+
+
+ /// Local min on a set.
+
+ template <typename I, typename W>
+ bool local_min(const abstract::binary_image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+
+ oln_wn_type_of(W, fwd_iter) q(win);
+ for_all_q_of_p (q, p)
+ if (input.hold(q) and not input[q])
+ return false;
+ return true;
+ }
+
+
+ /// Local max on a function.
+
+ template <typename I, typename W>
+ oln_type_of(I, value) local_max(const abstract::image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+
+ oln_wn_type_of(W, fwd_iter) q(win);
+ funobj::max_accumulator<oln_type_of(I, value)> maxval;
+
+ for_all_q_of_p (q, p)
+ if (input.hold(q))
+ maxval(input[q]);
+
+ return maxval;
+ }
+
+
+ /// Local max on a set.
+
+ template <typename I, typename W>
+ bool local_max(const abstract::binary_image<I>& input,
+ const oln_type_of(I, point)& p,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+
+ oln_wn_type_of(W, fwd_iter) q(win);
+ for_all_q_of_p (q, p)
+ if (input.hold(q) and input[q])
+ return true;
+ return false;
+ }
+
+
+ } // end of namespace morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_STAT_HH
Index: oln/morpho/erosion.hh
===================================================================
--- oln/morpho/erosion.hh (revision 0)
+++ oln/morpho/erosion.hh (revision 0)
@@ -0,0 +1,143 @@
+// Copyright (C) 2001-2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_EROSION_HH
+# define OLENA_MORPHO_EROSION_HH
+
+# include <mlc/cmp.hh>
+# include <mlc/to_string.hh>
+
+# include <oln/utils/record.hh>
+# include <oln/basics.hh>
+# include <oln/core/2d/window2d.hh>
+# include <oln/morpho/tags.hh>
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+
+ // Fwd decl of erosion's facade.
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) erosion(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win);
+
+ // Facade for classical erosion.
+
+ template<typename I, typename W>
+ oln_type_of(I, concrete) erosion(const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ return erosion(tag::classical, input, win);
+ }
+
+
+ namespace impl {
+
+ // generic
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) erosion_(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ entering("->generic");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) output(input.size(), "output");
+
+ oln_type_of(I, fwd_piter) p(input.size());
+ for_all_p (p)
+ output[p] = kind.min(input, p, win);
+
+ exiting("->generic");
+ return output;
+ }
+
+
+
+ // win is a 2D rectangle
+
+ template<typename K, typename I>
+ oln_type_of(I, concrete) erosion_(const tag::kind<K>& kind,
+ const abstract::image2d<I>& input,
+ const win_rectangle2d& win)
+ {
+ entering("->(image2d,win_rectangle2d)");
+ registering(input, "input");
+
+ oln_type_of(I, concrete) temp("temp"), output("output");
+
+ win_hline2d hline(win.width); // FIXME: Cf. Soille, use L(i,dp)
+ win_vline2d vline(win.height);
+
+ temp = erosion(kind, input, hline);
+ output = erosion(kind, temp, vline);
+
+ exiting("->(image2d,win_rectangle2d)");
+ return output;
+ }
+
+
+ // add some other impls here...
+
+
+ } // end of namespace oln::morpho::impl
+
+
+
+
+ /// Generic erosion (facade).
+
+ template<typename K, typename I, typename W>
+ oln_type_of(I, concrete) erosion(const tag::kind<K>& kind,
+ const abstract::image<I>& input,
+ const abstract::window<W>& win)
+ {
+ mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure();
+ entering("morpho::erosion");
+
+ oln_type_of(I, concrete) output("output");
+ output = impl::erosion_(kind, input.exact(), win.exact());
+
+ exiting("morpho::erosion");
+ return output;
+ }
+
+
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_EROSION_HH
Index: oln/morpho/geodesic_erosion.hh
===================================================================
--- oln/morpho/geodesic_erosion.hh (revision 0)
+++ oln/morpho/geodesic_erosion.hh (revision 0)
@@ -0,0 +1,112 @@
+// Copyright (C) 2005 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, 59 Temple Place - Suite 330, 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 OLENA_MORPHO_GEODESIC_EROSION_HH
+# define OLENA_MORPHO_GEODESIC_EROSION_HH
+
+# include <mlc/cmp.hh>
+# include <mlc/contract.hh>
+
+# include <oln/utils/record.hh>
+# include <oln/core/pw/all.hh>
+# include <oln/core/gen/image_with_nbh.hh> // FIXME: should be in core/abstract/
(?)
+# include <oln/morpho/elementary_erosion.hh>
+
+
+
+// FIXME: such routines should be written somewhere else...
+
+template <typename L, typename R>
+bool operator >= (const oln::abstract::image<L>& lhs,
+ const oln::abstract::image<R>& rhs)
+{
+ return oln::pw::check(oln::p_value(lhs) >= oln::p_value(rhs));
+}
+
+
+
+namespace oln {
+
+ namespace morpho {
+
+
+
+ /// Generic geodesic erosion.
+
+ template<typename K, typename I, typename II>
+ oln_type_of(I, concrete) geodesic_erosion(const tag::kind<K>& kind,
+ const abstract::image_with_nbh<I>& marker,
+ const abstract::image<II>& mask)
+ {
+ // FIXME: later, test the short code:
+ // FIXME: return max(elementary_erosion(kind, marker), mask)
+
+ // FIXME: and even later:
+ // FIXME: return elementary_erosion(kind, marker) _max_ mask
+
+ mlc::eq<oln_type_of(I, grid), oln_type_of(II, grid)>::ensure();
+
+ entering("morpho::geodesic_erosion");
+
+ registering(marker, "marker");
+ registering(mask, "mask");
+ precondition(marker.size() == mask.size()
+ and marker >= mask);
+
+ oln_type_of(I, concrete)
+ ero("ero"),
+ output(marker.size(), "output");
+
+ ero = elementary_erosion(kind, marker);
+
+ // FIXME: replace code below by a pw::max...
+ oln_type_of(I, fwd_piter) p(marker.size());
+ for_all_p (p)
+ output[p] = std::max(ero[p].value(), mask[p].value());
+
+ exiting("morpho::geodesic_erosion");
+ return output;
+ }
+
+
+ /// Generic classical geodesic erosion.
+
+ template<typename I, typename II>
+ oln_type_of(I, concrete) geodesic_erosion(const
abstract::image_with_nbh<I>& marker,
+ const abstract::image<II>& mask)
+ {
+ return geodesic_erosion(tag::classical, marker, mask);
+ }
+
+
+
+ } // end of namespace oln::morpho
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_MORPHO_GEODESIC_EROSION_HH