Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

cleanup-2008 2008: Add some documentation about site set properties.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/branches/cleanup-2008/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add some documentation about site set properties. * mln/trait/site_set/props.hh: Add some doc. * mln/trait/site_sets.hh: Likewise. site_set/props.hh | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++---- site_sets.hh | 21 ++++++++++++ 2 files changed, 103 insertions(+), 6 deletions(-) Index: mln/trait/site_set/props.hh --- mln/trait/site_set/props.hh (revision 2007) +++ mln/trait/site_set/props.hh (working copy) @@ -37,6 +37,43 @@ # include <mln/trait/undef.hh> + +// Properties of site sets. +// ======================== + +// nsites: /any/ +// | +// + -- unknown +// | +// + -- known + +// bbox: /any/ +// | +// + -- unknown +// | +// + -- /known/ +// | +// + -- lazy +// | +// + -- straight + +// contents: /any/ +// | +// + -- fixed +// | +// + -- /dynamic/ +// | +// + -- growing +// | +// + -- free + +// arity: /any/ +// | +// + -- unique +// | +// + -- multiple + + namespace mln { @@ -46,34 +83,73 @@ namespace site_set { + + /// Site set property about the 'nsites' method presence. struct nsites { - struct any {}; + /// Base class for the site set 'nsites' property. + struct any { protected: any() {} }; + + /// Property that states that the number of sites cannot be + /// retrieved from a site set in O(1) complexity so the site + /// set does not feature the 'nsites' methods. struct unknown : any { std::string name() const { return "nsites::unknown"; } }; + + /// Property that states that a site set features the method + /// 'nsites' because the number of sites is known so its + /// retrieval has O(1) complexity. struct known : any { std::string name() const { return "nsites::known"; } }; }; + + /// Site set property about the 'bbox' method presence. struct bbox { - struct any {}; + /// Base class for the site set 'bbox' property. + struct any { protected: any() {} }; + + /// Property that states that the bounding box of a site set + /// is not featured as a method. This is either because the + /// notion of bounding box is meaningless for the site set + /// type, or because the bounding box cannot be retrieved in + /// O(1) complexity. struct unknown : any { std::string name() const { return "bbox::unknown"; } }; - struct known : any {}; + + /// Property that states that the bounding box of a site set + /// is featured by the 'bbox' method. It means that the + /// notion of bounding box makes sense and that such a piece + /// of information can be retrieved in O(1) complexity. + /// Warning: this property is pseudo-abstract. The more + /// precise properties are 'lazy' and 'straight'. + struct known : any { protected: known() {} }; + + /// Property that states that the bounding box of a site set + /// is computed by the site set in a lazy way. struct lazy : known { std::string name() const { return "bbox::lazy"; } }; + + /// Property that states that the bounding box of a site set + /// is always kept up to date by the site set. struct straight : known { std::string name() const { return "bbox::straight"; } }; }; + + /// Site set property about how the contents can evolve. struct contents { - struct any {}; + /// Base class for the site set 'contents' property. + struct any { protected: any() {} }; struct fixed : any { std::string name() const { return "contents::fixed"; } }; - struct dynamic : any {}; + struct dynamic : any { protected: dynamic() {} }; struct growing : dynamic { std::string name() const { return "contents::growing"; } }; struct free : dynamic { std::string name() const { return "contents::dynamic"; } }; }; + /// Site set property about the unicity or multiplicity of its + /// elements. struct arity { - struct any {}; + /// Base class for the site set 'arity' property. + struct any { protected: any() {} }; struct unique : any { std::string name() const { return "arity::unique"; } }; struct multiple : any { std::string name() const { return "arity::multiple"; } }; }; Index: mln/trait/site_sets.hh --- mln/trait/site_sets.hh (revision 2007) +++ mln/trait/site_sets.hh (working copy) @@ -37,9 +37,20 @@ # include <mln/trait/site_set/props.hh> +/// Shortcut to the site set property about the 'nsites' method +/// presence. # define mln_trait_site_set_nsites(S) typename mln::trait::site_set_< S >::nsites + +/// Shortcut to the site set property about the 'bbox' method +/// presence. # define mln_trait_site_set_bbox(S) typename mln::trait::site_set_< S >::bbox + +/// Shortcut to the site set property about how the contents can +/// evolve. # define mln_trait_site_set_contents(S) typename mln::trait::site_set_< S >::contents + +/// Shortcut to the site set property about the unicity or +/// multiplicity of its elements. # define mln_trait_site_set_arity(S) typename mln::trait::site_set_< S >::arity @@ -50,6 +61,7 @@ namespace trait { + /// Pack of 'undefined' type values for properties of site sets. template <typename I> struct undefined_site_set_ { @@ -59,6 +71,15 @@ typedef undef arity; // Unique or multiple. }; + + /*! \brief The trait pack structure for properties of site sets. + * + * This structure is specialized for every concrete class of site + * set so that properties are properly defined. + * + * \see mln::doc::Site_Set for the documentation of the "site set" + * concept. + */ template <typename I> struct site_set_ : undefined_site_set_ {

16 years, 7 months

Re: [Olena-patches] 2000: Fix tests/util/graph.

by Vivien Delmon

Roland Levillain wrote: > https://svn.lrde.epita.fr/svn/oln/trunk/milena > > > Index: ChangeLog > from Roland Levillain <roland(a)lrde.epita.fr> > > Fix tests/util/graph. > > * tests/util/graph.cc: Catch up with the new interface of > mln::util::graph<V, E>. > s/add_node/add_vertex/. > > graph.cc | 12 ++++++------ > 1 file changed, 6 insertions(+), 6 deletions(-) > > Index: tests/util/graph.cc > --- tests/util/graph.cc (revision 1999) > +++ tests/util/graph.cc (working copy) > @@ -37,12 +37,12 @@ > > util::graph<void> g; > > - g.add_node (); // 0 > - g.add_node (); // 1 > - g.add_node (); // 2 > - g.add_node (); // 3 > - g.add_node (); // 4 > - g.add_node (); // 5 > + g.add_vertex (); // 0 > + g.add_vertex (); // 1 > + g.add_vertex (); // 2 > + g.add_vertex (); // 3 > + g.add_vertex (); // 4 > + g.add_vertex (); // 5 > g.add_edge (0, 1); > g.add_edge (0, 2); > g.add_edge (3, 4); Faire un pauvre patch de renommage juste pour avoir le 2000 ème patch c'est petit ... -- Vivien Delmon - ZiXiS - CSI 2009

16 years, 7 months

cleanup-2008 2007: Add some tutorial-like files about cubical complex.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/branches/cleanup-2008/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add some tutorial-like files about cubical complex. * sandbox/geraud/cs2d/tuto.cc: New. * sandbox/geraud/cs2d/tuto_bis.cc: New. tuto.cc | 145 +++++++++++++++++++++++++++++++ tuto_bis.cc | 277 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 422 insertions(+) Index: sandbox/geraud/cs2d/tuto.cc --- sandbox/geraud/cs2d/tuto.cc (revision 0) +++ sandbox/geraud/cs2d/tuto.cc (revision 0) @@ -0,0 +1,145 @@ +# include <mln/core/image2d.hh> +# include <mln/core/image_if.hh> + +# include <mln/core/neighb2d.hh> +# include <mln/core/window2d.hh> +# include <mln/convert/to_window.hh> + +# include <mln/debug/println.hh> +# include <mln/fun/p2v/iota.hh> +# include <mln/level/paste.hh> +# include <mln/level/fill.hh> +# include <mln/morpho/dilation.hh> + + + + struct is_cell_t : mln::Function_p2b<is_cell_t> + { + typedef bool result; + bool operator()(const mln::point2d& p) const + { + return p.row() % 2 == 0 && p.col() % 2 == 0; + } + } + is_cell; + + struct is_edge_t : mln::Function_p2b<is_edge_t> + { + typedef bool result; + bool operator()(const mln::point2d& p) const + { + return p.row() % 2 + p.col() % 2 == 1; + } + } + is_edge; + + struct is_point_t : mln::Function_p2b<is_point_t> + { + typedef bool result; + bool operator()(const mln::point2d& p) const + { + return p.row() % 2 && p.col() % 2; + } + } + is_point; + + + +int main() +{ + using namespace mln; + + window2d c4 = convert::to_window(mln::c4()); + + { + image2d<char> ima(3, 5); + + level::fill(ima, 'o'); + + debug::println(ima); + // o o o o o + // o o o o o + // o o o o o + + debug::println(ima | is_cell); + // o o o + // + // o o o + + level::fill(inplace(ima | is_cell), 'c'); + level::fill(inplace(ima | is_edge), 'e'); + level::fill(inplace(ima | is_point), 'p'); + + debug::println(ima); + // c e c e c + // e p e p e + // c e c e c + } + + { + image2d<int> ima(3, 5); + + level::fill(ima, 0); + debug::println(ima); + // 0 0 0 0 0 + // 0 0 0 0 0 + // 0 0 0 0 0 + + level::fill(inplace(ima | is_cell), fun::p2v::iota); + debug::println(ima | is_cell); + // 1 2 3 + // + // 4 5 6 + + // --- for the record: + // debug::println(morpho::dilation(ima, win::square(3))); + + debug::println(ima); + // 1 0 2 0 3 + // 0 0 0 0 0 + // 4 0 5 0 6 + + debug::println(ima | is_edge); + // 0 0 + // 0 0 0 + // 0 0 + + debug::println(morpho::dilation(ima | is_edge, c4)); + // 2 3 + // 4 5 6 + // 5 6 + + // Attention : les traitements ne travaillent généralement pas en + // place ; l'entrée n'est pas modifiée, une nouvelle image est + // retournée. Dans le code ci-dessus, l'image dilatée est envoyée + // à la routine d'affichage puis, n'étant plus utilisée, elle est + // automatiquement désallouée. + + // On peut vérifier que 'ima' n'a pas été modifié : + + debug::println(ima); + // 1 0 2 0 3 + // 0 0 0 0 0 + // 4 0 5 0 6 + + // En revanche, rien n'empêche de "coller" le résultat d'un + // traitement dans l'image d'entrée : + + level::paste(morpho::dilation(ima | is_edge, c4), ima); + + // Maintenant, le dilaté de "ima restreint à edge" est collé dans + // 'ima' : + + debug::println(ima); + // 1 2 2 3 3 + // 4 0 5 0 6 + // 4 5 5 6 6 + + level::paste(morpho::dilation(ima | is_point, c4), ima); + debug::println(ima); + // 1 2 2 3 3 + // 4 5 5 6 6 + // 4 5 5 6 6 + } + +} Index: sandbox/geraud/cs2d/tuto_bis.cc --- sandbox/geraud/cs2d/tuto_bis.cc (revision 0) +++ sandbox/geraud/cs2d/tuto_bis.cc (revision 0) @@ -0,0 +1,277 @@ +# include <vector> + +# include <mln/core/image2d.hh> +# include <mln/core/sub_image.hh> +# include <mln/core/image_if.hh> +# include <mln/core/image_if_value.hh> + +# include <mln/core/neighb2d.hh> +# include <mln/core/window2d.hh> +# include <mln/convert/to_window.hh> + +# include <mln/debug/println.hh> +# include <mln/fun/p2v/iota.hh> +# include <mln/level/paste.hh> +# include <mln/level/fill.hh> + +# include <mln/morpho/dilation.hh> +# include <mln/morpho/gradient.hh> +# include <mln/morpho/meyer_wst.hh> + +# include <mln/level/transform.hh> +# include <mln/accu/mean.hh> + +# include "dbl_neighb.hh" + + +namespace mln +{ + + + namespace level + { + + template<typename I, typename R> + mln_ch_value(I, R) + transform(const Image& input_, const std::vector<R>& v) + { + trace::entering("level::transform"); + const I& input = exact(input_); + + mln_ch_value(I, R) output; + initialize(output, input); + + mln_piter(I) p(input.domain()); + for_all(p) + output(p) = v[input(p)]; + + trace::exiting("level::transform"); + return output; + } + + } // mln::level + + namespace accu + { + + template <typename A_, typename I, typename L, typename R> + inline + void + compute(const Image& input_, + const Image<L>& label_, + std::vector<R>& v) + { + mlc_is_a(A_, Meta_Accumulator)::check(); + + trace::entering("accu::compute"); + + const I& input = exact(input_); + const L& label = exact(label_); + + typedef mln_accu_with(A_, mln_value(I)) A; + const unsigned n = v.size(); + std::vector<A> a(n); + + mln_piter(I) p(input.domain()); + for_all(p) + a[label(p)].take(input(p)); + + for (unsigned l = 1; l < n; ++l) + v[l] = a[l].to_result(); + + trace::exiting("accu::compute"); + } + + } // mln::accu + +} // mln + + + struct is_cell_t : mln::Function_p2b<is_cell_t> + { + typedef bool result; + bool operator()(const mln::point2d& p) const + { + return p.row() % 2 == 0 && p.col() % 2 == 0; + } + } + is_cell; + + struct is_edge_t : mln::Function_p2b<is_edge_t> + { + typedef bool result; + bool operator()(const mln::point2d& p) const + { + return p.row() % 2 + p.col() % 2 == 1; + } + } + is_edge; + + struct is_point_t : mln::Function_p2b<is_point_t> + { + typedef bool result; + bool operator()(const mln::point2d& p) const + { + return p.row() % 2 && p.col() % 2; + } + } + is_point; + + + struct is_row_odd_t + { + bool operator()(const mln::point2d& p) const + { + return p.row() % 2; + } + } is_row_odd; + + + +#define mln_alias(Var, Expr) \ +typeof(Expr) Var = Expr; + + + +int main() +{ + using namespace mln; + + window2d c4 = convert::to_window(mln::c4()); + + + dbl_neighb_<dpoint2d, is_row_odd_t> nbh_e2c, win_p_e2c, nbh_e2e; + { + bool e2c_h[] = { 0, 1, 0, + 0, 0, 0, + 0, 1, 0 }; + + bool e2c_v[] = { 0, 0, 0, + 1, 0, 1, + 0, 0, 0 }; + nbh_e2c + .when_true (make::neighb2d(e2c_h)) + .when_false(make::neighb2d(e2c_v)); + + win_p_e2c = nbh_e2c; + win_p_e2c + .insert_true(make::dpoint2d(0,0)) + .insert_false(make::dpoint2d(0,0)); + + bool e2e_h[] = { 0, 0, 1, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, + 0, 0, 1, 0, 0 }; + + bool e2e_v[] = { 0, 0, 0, 0, 0, + 0, 1, 0, 1, 0, + 1, 0, 0, 0, 1, + 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0 }; + nbh_e2e + .when_true (make::neighb2d(e2e_h)) + .when_false(make::neighb2d(e2e_v)); + } + + + image2d<int> ima(3, 5); + + mln_alias(cell, ima | is_cell); + level::fill(cell, fun::p2v::iota); + debug::println(cell); + // 1 2 3 + // + // 4 5 6 + + mln_alias(edge, ima | is_edge); + level::paste(morpho::gradient(edge, nbh_e2c), edge); + // ^^^^^^^ + // edge -> neighbooring cells + debug::println(edge); + // 1 1 + // 3 3 3 + // 1 1 + + unsigned nbasins; + mln_alias(wst, morpho::meyer_wst(edge, nbh_e2e, nbasins)); + // ^^^^^^^ + // edge -> neighbooring edges + debug::println(wst); + // 2 2 + // 0 0 0 + // 1 1 + + std::cout << nbasins << " bassins" << std::endl; + // 2 bassins + + + // '0' IS THE TAG VALUE FOR THE WATERSHED LINE + // THE OTHER VALUES ARE THE REGION LABELS + + + std::cout << "the watershed line = " << (wst | 0).domain() << std::endl; + // the watershed line = {(1,0)(1,2)(1,4)} + // ^^^^^ + // meaning (row = 1, col = 0) + + // Actually wst is: + // + // 0 1 2 3 4 <- col + // +-----------+ + // 0 | 2 2 | + // 1 | 0 0 0 | + // 2 | 1 1 | + // +-----------+ + // ^ + // | + // row + + + // YET THOSE VALUES ARE ON EDGES, NOT ON CELLS... + + + mln_alias(label, wst.full()); + debug::println(label); + // 0 2 0 2 0 + // 0 0 0 0 0 + // 0 1 0 1 0 + + level::paste(morpho::dilation(label | is_cell, c4), label); + + debug::println(label); + // 2 2 2 2 2 + // 0 0 0 0 0 + // 1 1 1 1 1 + debug::println(label | is_cell); + // 2 2 2 + // + // 1 1 1 + + + // ABOVE, WE HAVE THE LABEL IMAGE (POINTS-ONLY). + // BELOW, THE ORIGINAL IMAGE (POINTS-ONLY). + + + debug::println(cell); + // 1 2 3 + // + // 4 5 6 + + + // NOW WE WANT TO MODIFY THE INPUT IMAGE TO FLATTEN REGIONS... + + + std::vector<int> m(nbasins + 1); + accu::compute<accu::mean>(cell, label, m); + for (unsigned i = 1; i <= nbasins; ++i) + std::cout << "mean value of basin " << i << " is " << m[i] << std::endl; + + level::fill(cell, level::transform(label, m)); + debug::println(cell); + // 2 2 2 + // + // 5 5 5 + + // DONE! +}

16 years, 7 months

cleanup-2008 2005: Deactivate site set inclusion tests.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/branches/cleanup-2008/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Deactivate site set inclusion tests. Operators that test inclusion relationships between a couple of site sets are not always correct as is. Yet they are widely used thru the library. They are temporarily deactivated thanks to their return value. * mln/util/yes.hh: New utility class that always responds yes, i.e., converts to 'true'. * tests/util/yes.cc: New. * mln/core/concept/site_set.hh (operator==): Deactivate body and return yes. (operator <=): Likewise. (operator <): Likewise. * doc/tutorial/examples/p_array.cc: Add a test of inclusion. doc/tutorial/examples/p_array.cc | 1 mln/core/concept/site_set.hh | 74 +++++++++-------- mln/util/yes.hh | 161 +++++++++++++++++++++++++++++++++++++++ tests/util/yes.cc | 54 +++++++++++++ 4 files changed, 255 insertions(+), 35 deletions(-) Index: tests/util/yes.cc --- tests/util/yes.cc (revision 0) +++ tests/util/yes.cc (revision 0) @@ -0,0 +1,54 @@ +// Copyright (C) 2008 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/util/yes.cc + * + * \brief test of mln::util::yes + * + */ + +#include <mln/util/yes.hh> + + +int main () +{ + using namespace mln; + + util::yes b; + + mln_invariant(b == true); + mln_invariant((!b) == true); + mln_invariant(b != true); + + mln_invariant(b == false); + mln_invariant((!b) == false); + mln_invariant(b != false); + + mln_invariant(b); + mln_invariant(! b); +} Index: doc/tutorial/examples/p_array.cc --- doc/tutorial/examples/p_array.cc (revision 2004) +++ doc/tutorial/examples/p_array.cc (working copy) @@ -60,6 +60,7 @@ << index_of_in(p, arr1) << " in arr1" << std::endl; } + mln_invariant(arr2 < arr1); } } Index: mln/core/concept/site_set.hh --- mln/core/concept/site_set.hh (revision 2004) +++ mln/core/concept/site_set.hh (working copy) @@ -41,6 +41,8 @@ # include <mln/metal/not_equal.hh> # include <mln/metal/is_a.hh> +# include <mln/util/yes.hh> // Temporary include. + namespace mln { @@ -90,7 +92,7 @@ * \relates mln::Site_Set */ template <typename Sl, typename Sr> - bool operator==(const Site_Set<Sl>& lhs, const Site_Set<Sr>& rhs); + util::yes operator==(const Site_Set<Sl>& lhs, const Site_Set<Sr>& rhs); @@ -102,7 +104,7 @@ * \relates mln::Site_Set */ template <typename Sl, typename Sr> - bool operator<=(const Site_Set<Sl>& lhs, const Site_Set<Sr>& rhs); + util::yes operator<=(const Site_Set<Sl>& lhs, const Site_Set<Sr>& rhs); @@ -115,7 +117,7 @@ * \relates mln::Site_Set */ template <typename Sl, typename Sr> - bool operator<(const Site_Set<Sl>& lhs, const Site_Set<Sr>& rhs); + util::yes operator<(const Site_Set<Sl>& lhs, const Site_Set<Sr>& rhs); @@ -168,40 +170,41 @@ template <typename Sl, typename Sr> inline - bool operator==(const Site_Set<Sl>& lhs_, const Site_Set<Sr>& rhs_) + util::yes operator==(const Site_Set<Sl>& lhs_, const Site_Set<Sr>& rhs_) { - // FIXME: Same grid! - const Sl& lhs = exact(lhs_); - const Sr& rhs = exact(rhs_); - - // exhaustive test: - mln_fwd_piter(Sl) pl(lhs); - mln_fwd_piter(Sr) pr(rhs); - for (pl.start(), pr.start(); - pl.is_valid() && pr.is_valid(); - pl.next(), pr.next()) - if (pl != pr) - return false; // difference found - - // both sets are equal only if both browsings are completed - // at the same time: - return ! pl.is_valid() && ! pr.is_valid(); +// // FIXME: Same grid! +// const Sl& lhs = exact(lhs_); +// const Sr& rhs = exact(rhs_); + +// // exhaustive test: +// mln_fwd_piter(Sl) pl(lhs); +// mln_fwd_piter(Sr) pr(rhs); +// for (pl.start(), pr.start(); +// pl.is_valid() && pr.is_valid(); +// pl.next(), pr.next()) +// if (pl != pr) +// return false; // difference found + +// // both sets are equal only if both browsings are completed +// // at the same time: +// return ! pl.is_valid() && ! pr.is_valid(); + return true; } template <typename Sl, typename Sr> inline - bool operator<=(const Site_Set<Sl>& lhs_, const Site_Set<Sr>& rhs_) + util::yes operator<=(const Site_Set<Sl>& lhs_, const Site_Set<Sr>& rhs_) { - // FIXME: Same grid! - const Sl& lhs = exact(lhs_); - const Sr& rhs = exact(rhs_); - - // exhaustive test: - mln_piter(Sl) pl(lhs); - for_all(pl) - if (! rhs.has(pl)) - return false; +// // FIXME: Same grid! +// const Sl& lhs = exact(lhs_); +// const Sr& rhs = exact(rhs_); + +// // exhaustive test: +// mln_piter(Sl) pl(lhs); +// for_all(pl) +// if (! rhs.has(pl)) +// return false; return true; } @@ -209,12 +212,13 @@ template <typename Sl, typename Sr> inline - bool operator<(const Site_Set<Sl>& lhs_, const Site_Set<Sr>& rhs_) + util::yes operator<(const Site_Set<Sl>& lhs_, const Site_Set<Sr>& rhs_) { - // FIXME: Same grid! - const Sl& lhs = exact(lhs_); - const Sr& rhs = exact(rhs_); - return lhs <= rhs && lhs != rhs; +// // FIXME: Same grid! +// const Sl& lhs = exact(lhs_); +// const Sr& rhs = exact(rhs_); +// return lhs <= rhs && lhs != rhs; + return true; } Index: mln/util/yes.hh --- mln/util/yes.hh (revision 0) +++ mln/util/yes.hh (revision 0) @@ -0,0 +1,161 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_UTIL_YES_HH +# define MLN_UTIL_YES_HH + +/*! \file mln/util/yes.hh + * + * \brief Definition of an object that always says "yes". + */ + +# include <mln/core/concept/object.hh> +# include <mln/core/ops.hh> + + +namespace mln +{ + + // Fwd decl. + namespace util { struct yes; } + + + namespace trait + { + + template <> + struct set_precise_unary_< op::not_, util::yes > + { + typedef util::yes ret; + }; + + template <template<class, class> class Op> + struct set_precise_binary_< Op, util::yes, bool > + { + typedef util::yes ret; + }; + + } // end of namespace mln::trait + + + namespace util + { + + /*! \brief Yes structure. + * + */ + struct yes : public Object< yes > + { + yes(); + yes(bool); + operator bool() const; + }; + + } // end of namespace mln::util + + + // Negate. + util::yes operator ! (const util::yes& y); + + // Equal. + util::yes operator == (const util::yes&, bool); + + // Not equal. + util::yes operator != (const util::yes&, bool); + + // And. + util::yes operator && (const util::yes&, bool); + + // Or. + util::yes operator || (const util::yes&, bool); + + + // FIXME: Is-it suffisiant? + + +# ifndef MLN_INCLUDE_ONLY + + namespace util + { + + // yes + + inline + yes::yes() + { + } + + inline + yes::yes(bool) + { + } + + inline + yes::operator bool() const + { + return true; + } + + } // end of namespace mln::util + + inline + util::yes + operator ! (const util::yes& y) + { + return y; + } + + inline + util::yes operator == (const util::yes&, bool) + { + return true; + } + + inline + util::yes operator != (const util::yes&, bool) + { + return true; + } + + inline + util::yes operator && (const util::yes&, bool) + { + return true; + } + + inline + util::yes operator || (const util::yes&, bool) + { + return true; + } + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + + +#endif // ! MLN_UTIL_YES_HH

16 years, 7 months

2004: Sandbox: ICP: Points escaping during multi-scale registration.

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Ugo Jardonnet <jardonnet(a)lrde.epita.fr> Sandbox: ICP: Points escaping during multi-scale registration. * jardonnet/test/test.rb: Fix: Change parameters e and q. * jardonnet/test/icp.cc: Fix: Make use of update_qk[1]. * jardonnet/registration/icp_ref.hh: Fix: Remove useless Xk array. * jardonnet/registration/icp.hh: Update: Escape points during registration steps. registration/icp.hh | 16 +++++++++++++++- registration/icp_ref.hh | 2 +- test/icp.cc | 4 +++- test/test.rb | 4 ++-- 4 files changed, 21 insertions(+), 5 deletions(-) Index: jardonnet/test/test.rb --- jardonnet/test/test.rb (revision 2003) +++ jardonnet/test/test.rb (working copy) @@ -3,8 +3,8 @@ print "# icp_ref \t icp\n" print "-------------------------\n" -q = 1 -e = 1 +q = 4 +e = 5 for i in 0..9 do Index: jardonnet/test/icp.cc --- jardonnet/test/icp.cc (revision 2003) +++ jardonnet/test/icp.cc (working copy) @@ -79,8 +79,9 @@ for (size_t i = 0; i < c.npoints(); i++) length[i] = norm::l2(algebra::vec<3,int> (c[i] - map(c[i]))); + // final transform - quat7<3> fqk = registration::final_qk2(c, map, 2*stddev); + quat7<3> fqk = registration::final_qk(c, map, 2*stddev); fqk.apply_on(c, c, c.npoints()); //print x @@ -92,6 +93,7 @@ output(px) = literal::green; } + //to 2d : projection (FIXME:if 3d) for (size_t i = 0; i < c.npoints(); i++) { Index: jardonnet/registration/icp_ref.hh --- jardonnet/registration/icp_ref.hh (revision 2003) +++ jardonnet/registration/icp_ref.hh (working copy) @@ -102,7 +102,7 @@ buffer<4,quat7<P::dim> > buf_qk; - p_array Ck(C), Xk(C); + p_array Ck(C); float d_k = 1000, d_k_1 = 1000, e_k = 1000; algebra::vec<P::dim,float> mu_C = center(C, c_length), mu_Xk; Index: jardonnet/registration/icp.hh --- jardonnet/registration/icp.hh (revision 2003) +++ jardonnet/registration/icp.hh (working copy) @@ -151,7 +151,7 @@ pts += c_length; #endif k++; - } while (/*k < 3 ||*/ (qk - buf_qk[1]).sqr_norm() / qk.sqr_norm() > epsilon); + } while ((qk - buf_qk[1]).sqr_norm() / qk.sqr_norm() > epsilon); trace::exiting("registration::impl::icp_"); } @@ -203,6 +203,20 @@ l = (l<1) ? 1 : l; impl::icp_(cloud, map, qk, l, 1e-3); + //remove points + p_array tmp; + tmp.reserve(cloud.npoints()); + qk.apply_on(cloud,tmp, cloud.npoints()); + float stddev, mean; + mean_stddev(tmp, map, mean, stddev); + for (unsigned i = 0; i < cloud.npoints(); i++) + { + algebra::vec<3,float> qci = tmp[i]; + algebra::vec<3,float> xi = x[i]; + if (norm::l2(qci - xi) < 2 * stddev) + cloud.hook_()[i] = cloud[(i+1) % cloud.npoints()]; + } + #ifndef NDEBUG { value::rgb8 c;

16 years, 7 months

[Olena] #135: Name Confilts between util::node and util::node.

by Olena

#135: Name Confilts between util::node and util::node. -----------------------+---------------------------------------------------- Reporter: garrigues | Owner: Olena Team Type: defect | Status: new Priority: major | Milestone: Olena 1.0ß Component: Milena | Version: 1.0 Keywords: | -----------------------+---------------------------------------------------- We have two util::node : one for the graph implementation and also one for the tree. see source:/trunk/milena/mln/util/tree.hh and source:/trunk/milena/mln/util/internal/graph_base.hh -- Ticket URL: <https://trac.lrde.org/olena/ticket/135> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

16 years, 7 months

2003: Have mln::util::vertex_id and mln::util::edge_id be distinct types.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Closes https://trac.lrde.org/olena/ticket/135. Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Have mln::util::vertex_id and mln::util::edge_id be distinct types. * mln/util/internal/graph_base.hh (mln::util::gen_id<Tag, Typename>): New class. (mln::util::vertex_tag, mln::util::edge_tag): New tags (mln::util::vertex_id, mln::util::edge_id): Define these typedefs as specializations of mln::util::gen_id instead of unsigned. (mln::util::graph_base<V, E>::add_edge_): Adjust. (operator==(const edge<E>&, const edge<E>&)) (operator< (const edge<E>&, const edge<E>&)): Add missing an inline qualifier. (mln::util::graph_base<V, E>::vertex(vertex_id)): Have the declarations and definitions of thee methods have the exact same signature. * mln/core/line_graph_psite.hh (line_graph_psite(const p_line_graph&, util::edge_id)) (mln::util::line_graph_psite::id): Likewise. * mln/core/graph_psite.hh (graph_psite(const p_graph&, util::vertex_id)): Likewise. * mln/core/p_line_graph_piter.hh (p_line_graph_fwd_piter_::next_): (p_line_graph_bkd_piter_::next_): Adjust. * tests/morpho/lena_line_graph_image_wst1.cc: Adjust. mln/core/graph_psite.hh | 2 mln/core/line_graph_psite.hh | 4 mln/core/p_line_graph_piter.hh | 4 mln/util/internal/graph_base.hh | 160 ++++++++++++++++++++++++++--- tests/morpho/lena_line_graph_image_wst1.cc | 2 5 files changed, 153 insertions(+), 19 deletions(-) Index: tests/morpho/lena_line_graph_image_wst1.cc --- tests/morpho/lena_line_graph_image_wst1.cc (revision 2002) +++ tests/morpho/lena_line_graph_image_wst1.cc (working copy) @@ -126,7 +126,7 @@ is bad. util:graph<N,E>::add_vertex should return this id. */ points[p] = id; - ++id; + ++id.to_equiv(); } // Edges. Index: mln/core/line_graph_psite.hh --- mln/core/line_graph_psite.hh (revision 2002) +++ mln/core/line_graph_psite.hh (working copy) @@ -61,7 +61,7 @@ /// Construction and assignment. /// \{ line_graph_psite(); - line_graph_psite(const p_line_graph& plg, unsigned id); + line_graph_psite(const p_line_graph& plg, util::edge_id id); line_graph_psite(const self_& rhs); self_& operator= (const self_& rhs); /// \} @@ -224,7 +224,7 @@ template<typename P> inline - util::vertex_id + util::edge_id line_graph_psite::id() const { return id_; Index: mln/core/p_line_graph_piter.hh --- mln/core/p_line_graph_piter.hh (revision 2002) +++ mln/core/p_line_graph_piter.hh (working copy) @@ -281,7 +281,7 @@ void p_line_graph_fwd_piter_::next_() { - ++id_; + ++id_.to_equiv(); if (is_valid()) update_(); } @@ -422,7 +422,7 @@ void p_line_graph_bkd_piter_::next_() { - --id_; + --id_.to_equiv(); if (is_valid()) update_(); } Index: mln/core/graph_psite.hh --- mln/core/graph_psite.hh (revision 2002) +++ mln/core/graph_psite.hh (working copy) @@ -58,7 +58,7 @@ /// Construction and assignment. /// \{ graph_psite(); - graph_psite(const p_graph& pg_, unsigned id); + graph_psite(const p_graph& pg_, util::vertex_id id); graph_psite(const self_& rhs); self_& operator= (const self_& rhs); /// \} Index: mln/util/internal/graph_base.hh --- mln/util/internal/graph_base.hh (revision 2002) +++ mln/util/internal/graph_base.hh (working copy) @@ -40,35 +40,79 @@ # include <ostream> # include <mln/core/concept/object.hh> + # include <mln/util/ordpair.hh> +# include <mln/value/builtin/integers.hh> namespace mln { namespace util { - /* FIXME: We should create actual types for vertex_id and edge_id, - (not just typedefs), at least to prevent the user from using a - vertex_id where an edge_id is expected (and vice versa). - Conversion to and from unsigned would still be useful, but it - might be safer to turn them into explicit ones. + /*--------------. + | Identifiers. | + `--------------*/ - See what the Vaucanson team did for the handles of - vertices/states in their graphs/automata implemenations here: + /// \brief Generic identifier/handler. + /// + /// Inspired by Vaucansons's handlers for automata. + /// + /// https://svn.lrde.epita.fr/svn/vaucanson/trunk/include/vaucanson/automata/co… + /// https://svn.lrde.epita.fr/svn/vaucanson/trunk/include/vaucanson/automata/co… + // + // \todo We /might/ want to integrate this into Milena's value system. + + template <typename Tag, typename Equiv> + class gen_id + { + typedef gen_id<Tag, Equiv> self_t; - https://trac.lrde.org/vaucanson/browser/trunk/include/vaucanson/automata/co… + public: + typedef Equiv equiv; + + gen_id(); + gen_id(const Equiv& e); + self_t& operator=(const Equiv& e); + + const equiv& to_equiv() const; + equiv& to_equiv(); + operator const equiv() const; + operator equiv(); + + private: + equiv e_; + }; + + /// Compare two identifiers. + /// \{ + template <typename Tag, typename Equiv> + bool + operator==(const gen_id<Tag, Equiv>& i, const gen_id<Tag, Equiv>& j); + + template <typename Tag, typename Equiv> + bool + operator==(const Equiv& i, const gen_id<Tag, Equiv>& j); + + template <typename Tag, typename Equiv> + bool + operator==(const gen_id<Tag, Equiv>& i, const Equiv j); + /// \} - We /might/ want to integrate this into Milena's value system. */ + /// Tags. + /// \{ + struct vertex_tag; + struct edge_tag; + /// \} /// \brief The type used to identify vertices. /// /// Used internally as a key to manipulate vertices. - typedef unsigned vertex_id; + typedef gen_id<vertex_tag, unsigned> vertex_id; /// \brief The type used to identify edges. /// /// Used internally as a key to manipulate edges. - typedef unsigned edge_id; + typedef gen_id<edge_tag, unsigned> edge_id; /*---------. @@ -180,7 +224,7 @@ /// Return the vertex whose id is \a v. /// \{ util::vertex<V>& vertex(vertex_id v); - const util::vertex<V>& vertex(edge_id v) const; + const util::vertex<V>& vertex(vertex_id v) const; /// \} /// Return the edge whose id is \a e. @@ -242,7 +286,93 @@ # ifndef MLN_INCLUDE_ONLY + /*--------------. + | Identifiers. | + `--------------*/ + + template <typename Tag, typename Equiv> + inline + gen_id<Tag, Equiv>::gen_id() + { + } + + template <typename Tag, typename Equiv> + inline + gen_id<Tag, Equiv>::gen_id(const Equiv& e) + : e_ (e) + { + } + + template <typename Tag, typename Equiv> + inline + gen_id<Tag, Equiv>& + gen_id<Tag, Equiv>::operator=(const Equiv& e) + { + e_ = e; + return *this; + } + + template <typename Tag, typename Equiv> + inline + const Equiv& + gen_id<Tag, Equiv>::to_equiv() const + { + return e_; + } + + template <typename Tag, typename Equiv> + inline + Equiv& + gen_id<Tag, Equiv>::to_equiv() + { + return e_; + } + + template <typename Tag, typename Equiv> + inline + gen_id<Tag, Equiv>::operator const Equiv() const + { + return to_equiv(); + } + + template <typename Tag, typename Equiv> + inline + gen_id<Tag, Equiv>::operator Equiv() + { + return to_equiv(); + } + + + template <typename Tag, typename Equiv> + inline + bool + operator==(const gen_id<Tag, Equiv>& i, const gen_id<Tag, Equiv>& j) + { + return i.to_equiv() == j.to_equiv(); + } + + template <typename Tag, typename Equiv> + inline + bool + operator==(const Equiv& i, const gen_id<Tag, Equiv>& j) + { + return i == j.to_equiv(); + } + + template <typename Tag, typename Equiv> + inline + bool + operator==(const gen_id<Tag, Equiv>& i, const Equiv j) + { + return i.to_equiv() == j; + } + + /*---------------------. + | Operators on edges. | + `---------------------*/ + template <typename E> + inline bool operator==(const edge<E>& lhs, const edge<E>& rhs) { @@ -250,6 +380,7 @@ } template <typename E> + inline bool operator< (const edge<E>& lhs, const edge<E>& rhs) { @@ -447,7 +578,10 @@ delete edge; edge = 0; // Return the erroneous value. - return mln_max(edge_id); + /* FIXME: We have to explicitly extract the numerical + equivalent type here, because mln::util::gen_id<T, E> + is not compatible with Milena's value system (yet). */ + return mln_max(edge_id::equiv); } else {

16 years, 7 months

2002: Fix mln/algebra/vec.hh (to_point).

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Ugo Jardonnet <jardonnet(a)lrde.epita.fr> Fix mln/algebra/vec.hh (to_point). * mln/algebra/vec.hh (to_point): Fix. Coord conversions now use cast operator (It wasn't the case! argg). vec.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) Index: mln/algebra/vec.hh --- mln/algebra/vec.hh (revision 2001) +++ mln/algebra/vec.hh (working copy) @@ -557,7 +557,7 @@ { P tmp; for (unsigned i = 0; i < P::dim; ++i) - tmp[i] = round(v[i]); + tmp[i] = typename P::coord(v[i]);//round(v[i]); return tmp; }

16 years, 7 months

2001 (space odyssey): Sandbox: ICP: Make icp stop if error e_k < error d_k.

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Ugo Jardonnet <jardonnet(a)lrde.epita.fr> Sandbox: ICP: Make icp stop if e_k < d_k (errors). * jardonnet/test/icp_ref.cc: Fix p_array initialisation. * jardonnet/registration/icp_ref.hh (impl::icp) : Update : Stop if e_k < d_k. registration/icp_ref.hh | 11 ++++++----- registration/tools.hh | 1 + test/icp_ref.cc | 33 ++++++++++++++++++++++++++------- 3 files changed, 33 insertions(+), 12 deletions(-) Index: jardonnet/test/icp_ref.cc --- jardonnet/test/icp_ref.cc (revision 2000) +++ jardonnet/test/icp_ref.cc (working copy) @@ -22,9 +22,8 @@ if (argc != 5) usage(argv); - float q = std::atof(argv[3]); - int e = std::atoi(argv[4]); - + float q = 1;//std::atof(argv[3]); + int e = 1;//std::atoi(argv[4]); if (q < 1 or e < 1) usage(argv); @@ -44,14 +43,34 @@ I3d surface = convert::to_image3d(img2); //build p_arrays. - p_array<mln_point_(I3d)> c = convert::to_p_array(cloud); - p_array<mln_point_(I3d)> x = convert::to_p_array(surface); + p_array< point_<grid::cube, float> > c; + { + mln_piter_(I3d) p(cloud.domain()); + for_all(p) + if (cloud(p)) + { + point_<grid::cube,float> p_; + p_[0] = p[0]; p_[1] = p[1]; p_[2] = p[2]; + c.append(p_); + } + } + p_array< point_<grid::cube, float> > x; + { + mln_piter_(I3d) p(surface.domain()); + for_all(p) + if (surface(p)) + { + point_<grid::cube,float> p_; + p_[0] = p[0]; p_[1] = p[1]; p_[2] = p[2]; + x.append(p_); + } + } //working box - const box_<mln_point_(I3d)> working_box = enlarge(bigger(c.bbox(),x.bbox()),100); + const box_< point_<grid::cube, float> > working_box = enlarge(bigger(c.bbox(),x.bbox()),100); // FIXME : TODO : map : vec<3,float> -> point - closest_point<mln_point_(I3d)> map(x, working_box); + closest_point< point_<grid::cube, float> > map(x, working_box); quat7<3> qk = registration::icp(c, map, q, e, x); Index: jardonnet/registration/tools.hh --- jardonnet/registration/tools.hh (revision 2000) +++ jardonnet/registration/tools.hh (working copy) @@ -200,6 +200,7 @@ return a; } + template < typename P > inline box_<point2d> Index: jardonnet/registration/icp_ref.hh --- jardonnet/registration/icp_ref.hh (revision 2000) +++ jardonnet/registration/icp_ref.hh (working copy) @@ -103,7 +103,7 @@ buffer<4,quat7<P::dim> > buf_qk; p_array Ck(C), Xk(C); - float d_k = 1000, d_k_1 = 1000; + float d_k = 1000, d_k_1 = 1000, e_k = 1000; algebra::vec<P::dim,float> mu_C = center(C, c_length), mu_Xk; @@ -127,10 +127,10 @@ // = d(closest(qk-1(P)), qk(P)) d_k = rms(C, map, c_length, buf_qk[1], qk); -#ifndef NDEBUG // e_k = d(closest(qk-1(P)), qk-1(P)) - float e_k = rms(C, map, c_length, buf_qk[1], buf_qk[1]); + e_k = rms(C, map, c_length, buf_qk[1], buf_qk[1]); +#ifndef NDEBUG //plot file std::cout << k << '\t' << (e_k >= d_k ? ' ' : '-') << '\t' << e_k << '\t' << d_k << '\t' << ((qk - buf_qk[1]).sqr_norm() / qk.sqr_norm()) << '\t' @@ -139,7 +139,8 @@ pts += c_length; #endif k++; - } while (d_k_1 - d_k > epsilon); + } while (e_k >= d_k && d_k_1 - d_k > epsilon); + // FIXME : test (e_k >= d_k) seems to be a bad idea. trace::exiting("registration::impl::icp_"); } @@ -200,7 +201,7 @@ mln_piter(p_array) p(cloud); for_all(p) { - algebra::vec<3,float> p_ = point3d(p), qp_ = qk(p_); + algebra::vec<3,float> p_ = P(p), qp_ = qk(p_); point2d qp = make::point2d(int(qp_[0]), int(qp_[1])); if (tmp.has(qp)) tmp(qp) = c;

16 years, 7 months

cleanup-2008 1997: Add a 2D simplicial complex (toy code) + a double-window type.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/branches/cleanup-2008/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add a 2D simplicial complex (toy code) + a double-window type. * sandbox/geraud/cs2d: New directory. * sandbox/geraud/cs2d/cs2d.cc: New. * sandbox/geraud/cs2d/dbl_neighb.cc: New. * sandbox/geraud/cs2d/cs2d.hh: New. * sandbox/geraud/cs2d/cs2d_utils.hh: New. * sandbox/geraud/cs2d/dbl_neighb.hh: New. * sandbox/geraud/cs2d/cs2d_morpho.hh: New. cs2d.cc | 110 ++++++++++++++++ cs2d.hh | 172 ++++++++++++++++++++++++++ cs2d_morpho.hh | 372 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ cs2d_utils.hh | 251 ++++++++++++++++++++++++++++++++++++++ dbl_neighb.cc | 112 +++++++++++++++++ dbl_neighb.hh | 167 +++++++++++++++++++++++++ 6 files changed, 1184 insertions(+) Index: sandbox/geraud/cs2d/cs2d.cc --- sandbox/geraud/cs2d/cs2d.cc (revision 0) +++ sandbox/geraud/cs2d/cs2d.cc (revision 0) @@ -0,0 +1,110 @@ +# include "cs2d.hh" +# include "cs2d_morpho.hh" +# include "dbl_neighb.hh" + +# include <mln/debug/println.hh> + +# include <mln/io/pgm/load.hh> +# include <mln/io/pgm/save.hh> +# include <mln/io/ppm/save.hh> + +# include <mln/level/paste.hh> +# include <mln/level/fill.hh> + +# include <mln/morpho/dilation.hh> +# include <mln/morpho/meyer_wst.hh> +# include <mln/morpho/closing_area.hh> + +# include <mln/logical/not.hh> +# include <mln/labeling/blobs.hh> +# include <mln/accu/mean.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm lambda output.pgm" << std::endl; + abort(); +} + + +struct is_row_odd_t +{ + bool operator()(const mln::point2d& p) const + { + return p.row() % 2; + } +} is_row_odd; + + + +int main(int argc, char* argv[]) +{ + if (argc != 4) + usage(argv); + + + using namespace mln; + using value::int_u8; + + // trace::quiet = false; + + cmorpho::dbl_neighb2d nbh_e; + nbh_e + .insert_even(dpoint2d(-1,-1)) + .insert_even(dpoint2d(-1,+1)) + .insert_even(dpoint2d( 0,-2)) + .insert_odd(dpoint2d(-2, 0)) + .insert_odd(dpoint2d(-1,-1)) + .insert_odd(dpoint2d(-1,+1)); + + // display_masks(make::box2d(2,3)); + + image2d<int_u8> lena; + io::pgm::load(lena, argv[1]); + + cs2d<int_u8, int_u8, int_u8> cs(lena.domain()); + + fill_cells_with(cs, lena); + level::fill(cs.vertex, 0); + + cmorpho::dbl_neighb2d nbh_g; + nbh_g.insert_odd(up).insert_even(left); + level::paste(cmorpho::gradient(cs.edge, nbh_g), + cs.edge); + // io::pgm::save(cs.impl, "grad.pgm"); + + int lambda = atoi(argv[2]); + if (lambda < 0) + usage(argv); + + if (lambda != 0) + level::paste(morpho::closing_area(cs.edge, nbh_e, lambda), cs.edge); + + cs2d<int_u8, bool, bool> cs_(lena.domain()); + level::fill(cs_.impl, false); + fill_cells_with(cs_, lena); + + unsigned l; + level::fill(cs_.edge, + pw::value(cmorpho::meyer_wst(cs.edge, nbh_e, l)) == pw::cst(0)); + std::cout << "l = " << l << std::endl; + + level::paste(morpho::dilation(cs_.vertex, + convert::to_window(c4())), + cs_.vertex); + + unsigned L; + // debug::println(cs_.impl); + image2d<unsigned> label = labeling::blobs(logical::not_(cs_.impl), c4(), L); + // debug::println(label); + mln_invariant(L == l); + + std::vector<int_u8> v(l + 1); + accu::compute<accu::mean>(cs_.cell, label, v); + + level::fill(cs_.cell, level::transform(label, v)); + io::pgm::save(cell_image(cs_), argv[3]); + +// io::ppm::save(pack(cs_, colorize, 7), "log.ppm"); +} Index: sandbox/geraud/cs2d/dbl_neighb.cc --- sandbox/geraud/cs2d/dbl_neighb.cc (revision 0) +++ sandbox/geraud/cs2d/dbl_neighb.cc (revision 0) @@ -0,0 +1,112 @@ +# include <cstdlib> + +# include <mln/value/int_u8.hh> +# include <mln/value/rgb8.hh> + +# include <mln/core/image2d.hh> +# include <mln/core/neighb2d.hh> +# include <mln/core/window2d.hh> + +# include <mln/convert/to_p_set.hh> +# include <mln/convert/to_image.hh> +# include <mln/debug/println.hh> + +# include "dbl_neighb.hh" + +# include <mln/io/pgm/load.hh> +# include <mln/io/pgm/save.hh> +# include <mln/io/pbm/save.hh> +# include <mln/io/ppm/save.hh> + +# include <mln/level/transform.hh> +# include <mln/literal/black.hh> +# include <mln/pw/all.hh> + +# include <mln/morpho/closing_area.hh> +# include <mln/morpho/gradient.hh> +# include <mln/morpho/meyer_wst.hh> + + + + +struct is_chess_t +{ + bool operator()(const mln::point2d& p) const + { + return p.col() % 2 == p.row() % 2; + } +}; + + +struct colorize : mln::Function_v2v< colorize > +{ + typedef mln::value::rgb8 result; + colorize(unsigned max) + : lut(max + 1) + { + lut[0] = mln::literal::black; + for (unsigned i = 1; i <= max; ++i) + lut[i] = result(100 + std::rand() % 150, + 100 + std::rand() % 150, + 100 + std::rand() % 150); + } + result operator()(unsigned i) const + { + return lut[i]; + } + std::vector<result> lut; +}; + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm lambda output.ppm" << std::endl; + abort(); +} + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + + if (argc != 4) + usage(argv); + + image2d<int_u8> lena; + io::pgm::load(lena, argv[1]); + + bool vert[] = { 1, 1, 0, + 1, 0, 1, + 0, 1, 1 }; + + bool hori[] = { 0, 1, 1, + 1, 0, 1, + 1, 1, 0 }; + + dbl_neighb_<dpoint2d, is_chess_t> nbh; + nbh + .when_true (make::neighb2d(vert)) + .when_false(make::neighb2d(hori)); + + image2d<int_u8> clo, grad = morpho::gradient(lena, nbh); + // io::pgm::save(grad, "grad.pgm"); + + int lambda = atoi(argv[2]); + if (lambda > 1) + { + clo = morpho::closing_area(grad, nbh, lambda); + // io::pgm::save(clo, "clo.pgm"); + } + else + clo = grad; + + unsigned l; + image2d<unsigned> wst = morpho::meyer_wst(clo, nbh, l); + std::cout << "l = " << l << std::endl; + + io::ppm::save(level::transform(wst, colorize(l)), argv[3]); + +// io::pbm::save((pw::value(wst) == pw::cst(0)) | lena.domain(), +// argv[3]); +} Index: sandbox/geraud/cs2d/cs2d.hh --- sandbox/geraud/cs2d/cs2d.hh (revision 0) +++ sandbox/geraud/cs2d/cs2d.hh (revision 0) @@ -0,0 +1,172 @@ +# include <mln/core/image2d.hh> +# include <mln/core/neighb2d.hh> +# include <mln/core/window2d.hh> +# include <mln/convert/to_window.hh> + +# include <mln/core/image_if.hh> +# include <mln/debug/println.hh> + + +# include "cs2d_utils.hh" + + +namespace mln +{ + + + template <typename C, typename E, typename X> + struct cs2d + { + typedef C cell_value; + typedef E edge_value; + typedef X vertex_value; + + cs2d(unsigned nrows, unsigned ncols) + { + init(nrows, ncols); + } + + cs2d(const box2d& b) + { + init(b.nrows(), b.ncols()); + } + + void init(unsigned nrows, unsigned ncols) + { + mln_precondition(nrows && ncols); + + // Raw data (impl). + b = make::box2d(2 * nrows - 1, 2 * ncols - 1); + cimpl = image2d<C>(b, 0); + eimpl = image2d<E>(b, 0); + ximpl = image2d<X>(b, 0); + + // Images. + cell = cimpl | is_cell; + edge = eimpl | is_edge; + vertex = ximpl | is_vertex; + } + + unsigned nrows() const { return (b.nrows() + 1) / 2; } + unsigned ncols() const { return (b.ncols() + 1) / 2; } + + box2d b; + image2d<C> cimpl; + image2d<E> eimpl; + image2d<X> ximpl; + + typedef image_if< image2d<C>, is_cell_t > cell_t; + cell_t cell; + + typedef image_if< image2d<E>, is_edge_t > edge_t; + edge_t edge; + + typedef image_if< image2d<X>, is_vertex_t > vertex_t; + vertex_t vertex; + }; + + + + + template <typename T> + struct cs2d< T, T, T> + { + typedef T cell_value; + typedef T edge_value; + typedef T vertex_value; + + cs2d(unsigned nrows, unsigned ncols) + { + init(nrows, ncols); + } + + cs2d(const box2d& b) + { + init(b.nrows(), b.ncols()); + } + + void init(unsigned nrows, unsigned ncols) + { + mln_precondition(nrows && ncols); + + // Raw data (impl). + b = make::box2d(2 * nrows - 1, 2 * ncols - 1); + impl = image2d<T>(b, 0); + + // Images. + cell = impl | is_cell; + edge = impl | is_edge; + vertex = impl | is_vertex; + } + + unsigned nrows() const { return (b.nrows() + 1) / 2; } + unsigned ncols() const { return (b.ncols() + 1) / 2; } + + box2d b; + image2d<T> impl; + + typedef image_if< image2d<T>, is_cell_t > cell_t; + cell_t cell; + + typedef image_if< image2d<T>, is_edge_t > edge_t; + edge_t edge; + + typedef image_if< image2d<T>, is_vertex_t > vertex_t; + vertex_t vertex; + }; + + + + + + template <typename C, typename T> + struct cs2d< C, T, T> + { + typedef C cell_value; + typedef T edge_value; + typedef T vertex_value; + + cs2d(unsigned nrows, unsigned ncols) + { + init(nrows, ncols); + } + + cs2d(const box2d& b) + { + init(b.nrows(), b.ncols()); + } + + void init(unsigned nrows, unsigned ncols) + { + mln_precondition(nrows && ncols); + + // Raw data (impl). + b = make::box2d(2 * nrows - 1, 2 * ncols - 1); + cimpl = image2d<C>(b, 0); + impl = image2d<T>(b, 0); + + // Images. + cell = cimpl | is_cell; + edge = impl | is_edge; + vertex = impl | is_vertex; + } + + unsigned nrows() const { return (b.nrows() + 1) / 2; } + unsigned ncols() const { return (b.ncols() + 1) / 2; } + + box2d b; + image2d<C> cimpl; + image2d<T> impl; + + typedef image_if< image2d<C>, is_cell_t > cell_t; + cell_t cell; + + typedef image_if< image2d<T>, is_edge_t > edge_t; + edge_t edge; + + typedef image_if< image2d<T>, is_vertex_t > vertex_t; + vertex_t vertex; + }; + + +} // mln Index: sandbox/geraud/cs2d/cs2d_utils.hh --- sandbox/geraud/cs2d/cs2d_utils.hh (revision 0) +++ sandbox/geraud/cs2d/cs2d_utils.hh (revision 0) @@ -0,0 +1,251 @@ +# include <mln/value/rgb8.hh> +# include <mln/value/int_u8.hh> +# include <mln/literal/black.hh> +# include <mln/literal/white.hh> +# include <mln/literal/colors.hh> +# include <mln/win/rectangle2d.hh> +# include <mln/level/fill.hh> + + +namespace mln +{ + + // 0 1 2 + // 0 c c c + // 1 c c c + + // 0 1 2 3 4 + // 0 c e c e c + // 1 e x e x e + // 2 c e c e c + + + struct is_cell_t : Function_p2b<is_cell_t> + { + typedef bool result; + bool operator()(const point2d& p) const + { + return p.row() % 2 == 0 && p.col() % 2 == 0; + } + } + is_cell; + + + struct is_edge_t : Function_p2b<is_edge_t> + { + typedef bool result; + bool operator()(const point2d& p) const + { + return p.row() % 2 + p.col() % 2 == 1; + } + } + is_edge; + + + struct is_vertex_t : Function_p2b<is_vertex_t> + { + typedef bool result; + bool operator()(const point2d& p) const + { + return p.row() % 2 && p.col() % 2; + } + } + is_vertex; + + + + void display_masks(box2d b) + { + box2d b_(2 * b.nrows() - 1, 2 * b.ncols() - 1); + image2d<char> tmp(b_); + mln_piter_(box2d) p(b_); + for_all(p) + if (is_cell(p)) + { + mln_invariant(! is_edge(p) && ! is_vertex(p)); + tmp(p) = 'O'; + } + else if (is_edge(p)) + { + mln_invariant(! is_cell(p) && ! is_vertex(p)); + tmp(p) = p.to_point().row() % 2 ? '-' : '|'; + } + else if (is_vertex(p)) + { + mln_invariant(! is_edge(p) && ! is_cell(p)); + tmp(p) = '+'; + } + else + mln_invariant(0); + debug::println(tmp); + } + + + struct colorize_t + { + typedef value::rgb8 result; + result operator()(value::int_u8 i) const + { + return result(i,i,i); + } + result operator()(bool b) const + { + if (b) + return literal::red; + else + return literal::black; + } + } + colorize; + + + template <typename Cs, typename F> + image2d<mln_result(F)> pack(const Cs& cs, F f) + { + image2d<mln_result(F)> output(cs.b); + mln_piter(box2d) p(cs.b); + for_all(p) + if (is_cell(p)) + output(p) = f(cs.cell(p)); + else if (is_edge(p)) + output(p) = f(cs.edge(p)); + else + output(p) = f(cs.vertex(p)); + return output; + } + + + template <typename Cs, typename F> + image2d<mln_result(F)> pack(const Cs& cs, F f, unsigned clen) + { + typedef mln_result(F) R; + + mln_precondition(clen % 2); // oddity + + typedef win::rectangle2d Sqr; + Sqr sqr(clen, clen); + + typedef win::hline2d H; + H hline(clen); + + typedef win::vline2d V; + V vline(clen); + + // 0 1 2 3 4 + // 0 c e c e c + // 1 e x e x e + // 2 c e c e c + + // 0 1 2 3 4 5 6 7 8 9 10 + + // 0 c c c . e . c c c . e . c c c + // 1 c c c . e . c c c . e . c c c + // 2 c c c . e . c c c . e . c c c + // 3 . . . . . . . . . . . . . . . + // 4 e e e . x . e e e . x . e e e + // 5 . . . . . . . . . . . . . . . + // 6 c c c . e . c c c . e . c c c + // 7 c c c . e . c c c . e . c c c + // 8 c c c . e . c c c . e . c c c + + box2d b(cs.nrows() * clen + 3 * (cs.nrows() - 1), + cs.ncols() * clen + 3 * (cs.ncols() - 1)); + image2d<R> output(b); + level::fill(output, literal::black); + + // Cells. + mln_piter(Cs::cell_t) c(cs.cell.domain()); + for_all(c) + { + R v = f(cs.cell(c)); + point2d c_ = c.to_point(), p_; + p_.row() = clen / 2 + (clen + 3) * (c_.row() / 2); + p_.col() = clen / 2 + (clen + 3) * (c_.col() / 2); + mln_qiter(Sqr) q(sqr, p_); + for_all(q) + output(q) = v; + } + + // Points. + mln_piter(Cs::vertex_t) x(cs.vertex.domain()); + for_all(x) + { + point2d x_ = x, q; + q.row() = clen + 1 + (clen + 3) * (x_.row() / 2); + q.col() = clen + 1 + (clen + 3) * (x_.col() / 2); + output(q) = f(cs.vertex(x)); + } + + + // 0 1 2 3 4 + // 0 c e c e c + // 1 e x e x e + // 2 c e c e c + + // 0 1 2 3 4 5 6 7 8 9 10 + + // 0 c c c . e . c c c . e . c c c + // 1 c c c . e . c c c . e . c c c + // 2 c c c . e . c c c . e . c c c + // 3 . . . . . . . . . . . . . . . + // 4 e e e . x . e e e . x . e e e + // 5 . . . . . . . . . . . . . . . + // 6 c c c . e . c c c . e . c c c + // 7 c c c . e . c c c . e . c c c + // 8 c c c . e . c c c . e . c c c + + + // Edges. + mln_piter(Cs::edge_t) e(cs.edge.domain()); + for_all(e) + { + R v = f(cs.edge(e)); + point2d e_ = e, p_; + if (e_.row() % 2) // Odd => horizontal. + { + p_.row() = clen + 1 + (clen + 3) * (e_.row() / 2); // vertex-like + p_.col() = clen / 2 + (clen + 3) * (e_.col() / 2); // cell-like + mln_qiter(V) q(hline, p_); + for_all(q) if (output.has(q)) + output(q) = v; + } + else // Even => vertical. + { + p_.row() = clen / 2 + (clen + 3) * (e_.row() / 2); // cell-like + p_.col() = clen + 1 + (clen + 3) * (e_.col() / 2); // vertex-like + mln_qiter(H) q(vline, p_); + for_all(q) if (output.has(q)) + output(q) = v; + } + } + + return output; + } + + + + template <typename Cs, typename T> + void fill_cells_with(Cs& cs, const image2d<T>& input) + { + mlc_equal(T, typename Cs::cell_value)::check(); + mln_piter(box2d) p(input.domain()); + mln_piter(Cs::cell_t) c(cs.cell.domain()); + for_all_2(p, c) + cs.cell(c) = input(p); + } + + template <typename Cs> + image2d<typename Cs::cell_value> + cell_image(const Cs& cs) + { + image2d<typename Cs::cell_value> output(cs.nrows(), cs.ncols()); + mln_piter(box2d) p(output.domain()); + mln_piter(Cs::cell_t) c(cs.cell.domain()); + for_all_2(p, c) + output(p) = cs.cell(c); + return output; + } + +} // mln + + Index: sandbox/geraud/cs2d/dbl_neighb.hh --- sandbox/geraud/cs2d/dbl_neighb.hh (revision 0) +++ sandbox/geraud/cs2d/dbl_neighb.hh (revision 0) @@ -0,0 +1,167 @@ +# include <mln/core/concept/neighborhood.hh> + + +namespace mln +{ + + + // Fwd decl. + template <typename D, typename F> class dbl_niter_; + + + template <typename D, typename F> + struct dbl_neighb_ : public Neighborhood< dbl_neighb_<D,F> > + { + typedef D dpoint; + typedef mln_point(D) point; + + typedef dbl_niter_<D,F> fwd_niter; + typedef dbl_niter_<D,F> bkd_niter; + typedef dbl_niter_<D,F> niter; + + dbl_neighb_(F f) + : f(f) + { + } + + dbl_neighb_() + : f() + { + } + + bool is_empty() const + { + return trues.size() == 0 && falses.size() == 0; + } + + dbl_neighb_& insert_true(const D& dp) + { + trues.push_back(dp); + trues.push_back(-dp); + return *this; + } + + dbl_neighb_& insert_false(const D& dp) + { + falses.push_back(dp); + falses.push_back(-dp); + return *this; + } + + template <typename N> + dbl_neighb_& when_true(const Neighborhood<N>& nbh_) + { + const N& nbh = exact(nbh_); + for (unsigned i = 0; i < nbh.ndpoints(); ++i) + trues.push_back(nbh.dp(i)); + return *this; + } + + template <typename N> + dbl_neighb_& when_false(const Neighborhood<N>& nbh_) + { + const N& nbh = exact(nbh_); + for (unsigned i = 0; i < nbh.ndpoints(); ++i) + falses.push_back(nbh.dp(i)); + return *this; + } + + std::vector<D> trues, falses; + F f; + }; + + + + template <typename D, typename F> + class dbl_niter_ + : public internal::point_iterator_base_< mln_point(D), dbl_niter_<D,F> > + { + public: + + typedef mln_point(D) point; + + template <typename Pref> + dbl_niter_(const Neighborhood< dbl_neighb_<D,F> >& nbh, + const Point_Site<Pref>& p_ref) : + dps_true(exact(nbh).trues), + dps_false(exact(nbh).falses), + p_ref_(exact(p_ref).to_point()), + f(exact(nbh).f) + { + invalidate(); + } + + /// Convertion to point. + operator point () const + { + mln_precondition(is_valid()); + return p_; + } + + /// Reference to the corresponding point. + const point& to_point() const + { + return p_; + } + + /// Test the iterator validity. + bool is_valid() const + { + return i_ != dps_true.size(); + } + + /// Invalidate the iterator. + void invalidate() + { + i_ = dps_true.size(); + } + + /// Start an iteration. + void start() + { + i_ = 0; + update(); + } + + /// Go to the next point. + void next_() + { + ++i_; + update(); + } + + /// Give the i-th coordinate. + int operator[](unsigned i) const + { + mln_precondition(is_valid()); + return p_[i]; + } + + /// The point around which this iterator moves. + const point& center_point() const + { + return p_ref_; + } + + /// Force this iterator to update its location to take into + /// account that its center point may have moved. + void update() + { + if (is_valid()) + p_ = p_ref_ + (f(p_ref_) ? dps_true[i_] : dps_false[i_]); + } + + protected: + + const std::vector<D>& dps_true, dps_false; + const point& p_ref_; // reference point (or "center point") + F f; + + unsigned i_; + point p_; // location of this iterator; p_ makes this iterator be + // itself a potential center point. + }; + + + +} // mln Index: sandbox/geraud/cs2d/cs2d_morpho.hh --- sandbox/geraud/cs2d/cs2d_morpho.hh (revision 0) +++ sandbox/geraud/cs2d/cs2d_morpho.hh (revision 0) @@ -0,0 +1,372 @@ +# include <mln/accu/max.hh> +# include <mln/accu/min_max.hh> +# include <mln/labeling/regional_minima.hh> + +# include <mln/core/p_queue_fast.hh> + + +namespace mln +{ + + namespace cmorpho + { + + template <typename T> + T abs_diff(T t1, T t2) + { + return t1 > t2 ? t1 - t2 : t2 - t1; + } + + template <typename I> + void gradient(I& input) + { + mln_piter(I) p(input.domain()); + for_all(p) + { + mln_point(I) p_ = p; + input(p) = + p_.row() % 2 ? + // Odd so horizontal edge and vertical cells. + abs_diff(input(p_ + left), input(p_ + right)) : + // Otherwise + abs_diff(input(p_ + up), input(p_ + down)); + } + } + + + template <typename I, typename N> + inline + mln_concrete(I) gradient(const Image& input_, + const Neighborhood<N>& nbh_) + { + const I& input = exact(input_); + const N& nbh = exact(nbh_); + + mln_concrete(I) output; + initialize(output, input); + + accu::min_max_<mln_value(I)> m; + + mln_piter(I) p(input.domain()); + mln_niter(N) n(nbh, p); + for_all(p) + { + m.init(); + for_all(n) if (input.owns_(n)) + m.take(input(n)); + output(p) = m.second() - m.first(); + } + return output; + } + + + class dbl_niter; + + struct dbl_neighb2d : public Neighborhood< dbl_neighb2d > + { + typedef dpoint2d dpoint; + typedef point2d point; + + typedef dbl_niter fwd_niter; + typedef dbl_niter bkd_niter; + typedef dbl_niter niter; + + dbl_neighb2d() + { + } + + dbl_neighb2d& insert_odd(const dpoint2d& dp) + { + odds.push_back(dp); + odds.push_back(-dp); + return *this; + } + dbl_neighb2d& insert_even(const dpoint2d& dp) + { + evens.push_back(dp); + evens.push_back(-dp); + return *this; + } + + std::vector<dpoint2d> odds, evens; + }; + + + class dbl_niter + : public internal::point_iterator_base_< point2d, dbl_niter > + { + public: + + typedef dpoint2d D; + + template <typename N, typename Pref> + dbl_niter(const N& nbh, const Point_Site<Pref>& p_ref) : + dps_odd(exact(nbh).odds), + dps_even(exact(nbh).evens), + p_ref_(exact(p_ref).to_point()) + { + + invalidate(); + } + + /// Convertion to point. + operator point2d () const + { + mln_precondition(is_valid()); + return p_; + } + + /// Reference to the corresponding point. + const point2d& to_point() const + { + return p_; + } + + /// Test the iterator validity. + bool is_valid() const + { + return i_ != dps_odd.size(); + } + + /// Invalidate the iterator. + void invalidate() + { + i_ = dps_odd.size(); + } + + /// Start an iteration. + void start() + { + i_ = 0; + update(); + } + + /// Go to the next point. + void next_() + { + ++i_; + update(); + } + + /// Give the i-th coordinate. + int operator[](unsigned i) const + { + mln_precondition(is_valid()); + return p_[i]; + } + + /// The point around which this iterator moves. + const point2d& center_point() const + { + return p_ref_; + } + + /// Force this iterator to update its location to take into + /// account that its center point may have moved. + void update() + { + if (is_valid()) + p_ = p_ref_ + (p_ref_.row() % 2 ? dps_odd[i_] : dps_even[i_]); + } + + protected: + + const std::vector<dpoint2d>& dps_odd, dps_even; + const point2d& p_ref_; // reference point (or "center point") + + unsigned i_; + point2d p_; // location of this iterator; p_ makes this iterator be + // itself a potential center point. + }; + + + template <typename L, typename I, typename N> + mln_ch_value(I, L) + meyer_wst(const Image& input_, const Neighborhood<N>& nbh_, + L& nbasins) + { + trace::entering("morpho::meyer_wst"); + + const I& input = exact(input_); + const N& nbh = exact(nbh_); + + /* FIXME: Ensure the input image has scalar values. */ + + const L unmarked = 0; + + // Initialize the output with the markers (minima components). + mln_ch_value(I, L) output; + output = labeling::regional_minima(input, nbh, nbasins); + + // Ordered queue. + std::vector< p_queue_fast<mln_psite(I)> > qu(256); + unsigned qu_size = 0; + + // Insert every neighbor P of every marked area in a + // hierarchical queue, with a priority level corresponding to + // the grey level input(P). + { + mln_piter(I) p(output.domain()); + mln_niter(N) n(nbh, p); + for_all(p) + if (output(p) == unmarked) + for_all(n) + if (output.has(n) && output(n) != unmarked) + { + qu[input(p)].push_force(p); + ++qu_size; + break; + } + } + + /* Until the queue is empty, extract a psite p from the + hierarchical queue, at the highest priority level, that is, + the lowest level. */ + mln_psite(I) p; + mln_niter(N) n(nbh, p); + + while (qu_size != 0) + { + + for (unsigned l = 0; l < 256; ++l) + if (! qu[l].is_empty()) + { + p = qu[l].pop_front(); + // qu[l].pop(); + break; + } + --qu_size; + + // Last seen marker adjacent to P. + L adjacent_marker = unmarked; + // Has P a single adjacent marker? + bool single_adjacent_marker_p = true; + for_all(n) + if (output.has(n) && output(n) != unmarked) + { + if (adjacent_marker == unmarked) + { + adjacent_marker = output(n); + single_adjacent_marker_p = true; + } + else + if (adjacent_marker != output(n)) + { + single_adjacent_marker_p = false; + break; + } + } + + /* If the neighborhood of P contains only psites with the + same label, then P is marked with this label, and its + neighbors that are not yet marked are put into the + hierarchical queue. */ + if (single_adjacent_marker_p) + { + output(p) = adjacent_marker; + for_all(n) + if (output.has(n) && output(n) == unmarked) + { + qu[input(n)].push_force(n); + ++qu_size; + } + } + } + + trace::exiting("morpho::meyer_wst"); + return output; + } + + } // mln::cmorpho + + + namespace accu + { + + template <typename A_, typename I, typename L> + inline + std::vector<mln_accu_with(A_, mln_value(I))::result> + compute(const Image& input_, + const Image<L>& label_, + mln_value(L) n) + { + mlc_is_a(A_, Meta_Accumulator)::check(); + + trace::entering("accu::compute"); + + const I& input = exact(input_); + const L& label = exact(label_); + + typedef mln_accu_with(A_, mln_value(I)) A; + std::vector<A> a(n + 1); + + mln_piter(I) p(input.domain()); + for_all(p) + a[label(p)].take(input(p)); + + typedef typename A::result R; + std::vector<R> v(n + 1); + for (unsigned l = 1; l <= n; ++l) + v[l] = a[l].to_result(); + + trace::exiting("accu::compute"); + return v; + } + + + template <typename A_, typename I, typename L, typename R> + inline + void + compute(const Image& input_, + const Image<L>& label_, + std::vector<R>& v) + { + mlc_is_a(A_, Meta_Accumulator)::check(); + + trace::entering("accu::compute"); + + const I& input = exact(input_); + const L& label = exact(label_); + + typedef mln_accu_with(A_, mln_value(I)) A; + const unsigned n = v.size(); + std::vector<A> a(n); + + mln_piter(I) p(input.domain()); + for_all(p) + a[label(p)].take(input(p)); + + for (unsigned l = 1; l < n; ++l) + v[l] = a[l].to_result(); + + trace::exiting("accu::compute"); + } + + } // mln::accu + + + namespace level + { + + template<typename I, typename R> + mln_ch_value(I, R) + transform(const Image& input_, const std::vector<R>& v) + { + trace::entering("level::transform"); + const I& input = exact(input_); + + mln_ch_value(I, R) output; + initialize(output, input); + + mln_piter(I) p(input.domain()); + for_all(p) + output(p) = v[input(p)]; + + trace::exiting("level::transform"); + return output; + } + + } // mln::level + + +} // mln

16 years, 7 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches