Olena-patches January 2009

olena-patches@lrde.epita.fr

9 participants
152 discussions

[Olena] #143: Reorganize milena/mln/core/

by Olena

#143: Reorganize milena/mln/core/ ----------------------+----------------------------------------------------- Reporter: levill_r | Owner: Olena Team Type: task | Status: new Priority: minor | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Keywords: | ----------------------+----------------------------------------------------- (This ticket is just a proposal. We might close it even if no change occur in `milena/mln/core`.) There are many things in source:trunk/milena/mln/core/, that could be reorganized and/or split in several directories/subdirectories: * basic/classic images and entites (`mln::image2d`, etc.) * graph-based images and entities (`mln::graph_image`, etc.) * non classic images and associated tools (`mln::rle_image`, etc.) * morphers (`mln::cast_image`, etc.) * internal/core mechanisms (`initialize.hh` etc.) * general tools (`contract.hh`, `inplace.hh`, etc.) * concepts (though they are located in their own directory, `mln/core/concept/`) * implementation/factoring classes (thought most of them are in `mln/core/internal/`) * other entities, that should be moved elsewhere (`mln::h_vec`, etc.) * and so on. To my (Roland) mind, we should: 1. Identify the different kind of files present in `core/`. 2. Assign one (maybe two) kinds to each file of this directory. 3. Determine a new file layout, and perform the moves. -- Ticket URL: <https://trac.lrde.org/olena/ticket/143> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

15 years

[Olena] #167: Write iterators on complexes

by Olena

#167: Write iterators on complexes ----------------------+----------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Keywords: | ----------------------+----------------------------------------------------- Most of this task is described in [source:branches/cleanup-2008/milena/tests/topo/complex.cc tests/topo/complex.cc] (r2411) : {{{ /*------------------------------. | Iterators on adjacent faces. | `------------------------------*/ /* FIXME: Write and exercise more iterators (see milena/tests/core/complex_image.cc) and ticket #162 (https://trac.lrde.org/olena/ticket/162) */ /* Iterate on the the set of (n-1)-faces adjacent to AF. Note: this can be solved with iterators where the dimension can be either static or dynamic. Let's start with a dynamic one, as it would allow us to write something like this: mln_fwd_citer_(topo::complex<D>) f(c); mln_fwd_lower_nciter(topo::complex<D>) n(c); for_all(c) for_all(n) // ... (Note: we might want to get rid of the name `citer', and use `fiter' everywhere.). A static version might be useful (and more efficient) too. Likewise, our iterators on n-faces (both faces_piter and complex_faces_piter) use a static `n'. We should also have n-faces iterators where n could be dynamic. But first, we need to clarify (existing) names. ----------------------------------------------------------------- Current name New name Definition ----------------------------------------------------------------- complex<D> (n/a) General complex face<N, D> face_data<N, D> Face data face_handle<N, D> n_face<N, D> (Static) n-face handle faces_set<N, D> n_faces_set<N, D> Set of face handles any_face_handle<D> face<D> Dynamic face handle complex_fwd_iter_<D>(c) face_fwd_iter<D>(c) | Iterators on all complex_bkd_iter_<D>(c) face_bkd_iter<D>(c) | faces of c complex_iter_base_<F, E> complex_iter_base<F, E> | Factoring base | class. ----------------------------------------------------------------- (Note: get rid of trailing underscores, even for entities in mln::internal::.) Next, write these: ----------------------------------------------------------------- Name Definition ----------------------------------------------------------------- n_faces_fwd_iter<D>(c) | Iterators on n-faces, n_faces_bkd_iter<D>(c) | n being dynamic adj_lower_faces_fwd_iter<D>(c, f) | Iterators on the adjacent adj_lower_faces_bkd_iter<D>(c, f) | (lower) (n-1)-faces of the | n-face f of the complex c, | n being dynamic adj_higher_faces_fwd_iter<D>(c, f) | Iterators on the adjacent adj_higher_faces_bkd_iter<D>(c, f) | (higher) (n+1)-faces of the | n-face f of the complex c, | n being dynamic adj_lower_dim_connected_n_faces_fwd_iter<D>(c, f) adj_lower_dim_connected_n_faces_bkd_iter<D>(c, f) (FIXME: These names are admittedly too long.) | Iterators on the the set of | n-faces sharing an adjacent | (n-1)-face with f, n being | dynamic adj_higher_dim_connected_n_faces_fwd_iter<D>(c, f) adj_higher_dim_connected_n_faces_bkd_iter<D>(c, f) (FIXME: These names are admittedly too long.) | Iterators on the the set of | n-faces sharing an adjacent | (n+1)-face with f, n being | dynamic cell_fwd_iter<D>(c, f) | Iterators on the set of the cell_bkd_iter<D>(c, f) | faces in the « cell » | including p, i.e. the set of | all m-faces adjacent to p, | where m is in [0, n-1]; | this set is name « f-hat » cell_boundary_fwd_iter<D>(c, f) | Likewise, but excluding p; cell_boundary_bkd_iter<D>(c, f) | this set is named « p-hat* » ----------------------------------------------------------------- We could also have generic iterators based on predicated, and even use them to provide first (non efficient) implementations of the iterators from the previous list. ----------------------------------------------------------------- Name Definition ----------------------------------------------------------------- generic_face_fwd_iter<D>(c, pred) | Generic face iterators on c generic_face_bkd_iter<D>(c, pred) | using predicate pred to | define the iterated subset. ----------------------------------------------------------------- I'm unsure about the following existing iterators; should we keep them? What are they good for, except testing our code? ----------------------------------------------------------------- Current name Definition ----------------------------------------------------------------- complex_faces_fwd_iter_<N, D> Iterators on N-faces, N being complex_faces_fwd_iter_<N, D> static, acting as proxies of face_handle<N, D>'s. faces_fwd_iter_<N, D> Iterators on N-faces, N being faces_fwd_iter_<N, D> static, acting as proxies of any_face_handle<N, D>'s. ----------------------------------------------------------------- */ }}} (This should be turned into actual documentation, BTW.) See also #162 for applications of these iterators in windows/neighborhoods and images. -- Ticket URL: <https://trac.lrde.org/olena/ticket/167> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

15 years

[Olena] #161: Implement more complex psite iterators

by Olena

#161: Implement more complex psite iterators ----------------------+----------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: new Priority: major | Milestone: Component: Milena | Version: 1.0 Keywords: | ----------------------+----------------------------------------------------- As of r2148, we only have a single piter couple on complex : `mln::p_complex_fwd_piter_` and `mln::p_complex_bkd_piter_` (source:trunk/milena/mln/core/p_complex_piter.hh:2148). Comments (FIXMEs) at the end of source:trunk/milena/tests/core/complex_image.cc:2148 suggest to add these additional iterators: * iterators on ''n''-faces with ''n'' fixed in [0, ''d''] (using `mln::p_faces` and `mln::faces_psite`?) * iterators on ''n''-faces with ''n'' in a subset of [0, ''d'']; * etc. -- Ticket URL: <https://trac.lrde.org/olena/ticket/161> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

15 years

[Olena] #140: Add points having floating-point coordinates

by Olena

#140: Add points having floating-point coordinates ----------------------+----------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Keywords: | ----------------------+----------------------------------------------------- Name regular instances `point1df`, `point2df` and `point3df`. (N.B.: Aroune will need them so as to build the 3-d surface graph from a set of triangles.) -- Ticket URL: <https://trac.lrde.org/olena/ticket/140> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

15 years

[Olena] #162: Implement windows, neighborhoods, and corresponding iterators for complex-based images

by Olena

#162: Implement windows, neighborhoods, and corresponding iterators for complex- based images ----------------------+----------------------------------------------------- Reporter: levill_r | Owner: levill_r Type: task | Status: new Priority: major | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Keywords: | ----------------------+----------------------------------------------------- For a given (fixed) dimension ''n'' and a psite ''p'' on a ''n''-face, implement windows/neighborhoods (and corresponding iterators) returning * the set of (''n''-1)-faces adjacent to ''p'' (using ``mln::p_faces`` and ``mln::faces_psite``?); * the set of (''n''+1)-faces adjacent to ''p'' (using ``mln::p_faces`` and ``mln::faces_psite``?); * the set of ''n''-faces sharing a (''n''-1)-face with ''p''; * the set of ''n''-faces sharing a (''n''-1)-face or (''n''-2)-face (by transitivity) with ''p'' (is it useful?); * the set of the faces in the ``cell'' including ''p'' (named ``''p''-hat'' in couprie.08.pami), i.e., the set of all ''m''-faces adjacent to ''p'', where ''m'' is in [0, ''n''-1].[[BR]] In that definition, ''p'' is said adjacent to an ''m''-face ''q'' if there is a sequence (''m,,1,,'', ''m,,2,,'', ..., ''m,,k,,'') of faces so that * ''m,,1,,'' is an (''n''-1)-face adjacent to ''p'' ; * ''m,,2,,'' is an (''n''-2)-face adjacent to ''m,,1,,'' ; * ... (and so on) * ''m,,k,,'' is an (''m''+1)-face adjacent to ''q''. * what else? As in #139, we might want to factor things using implementation classes: * ``mln::internal::complex_vicinity`` * ``mln::internal::complex_vicinity_piter`` We might even be able to factor them with graph-based ones. -- Ticket URL: <https://trac.lrde.org/olena/ticket/162> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

15 years

[Olena] #130: Don not pass neighborhoods as argument to algorithms

by Olena

#130: Don not pass neighborhoods as argument to algorithms ----------------------+----------------------------------------------------- Reporter: levill_r | Owner: Olena Team Type: defect | Status: new Priority: major | Milestone: Olena 1.0ß Component: Milena | Version: 1.0 Keywords: | ----------------------+----------------------------------------------------- Neighborhoods shall be bound to images: they are a property of them. Hence an algorithm (at least a facade) shall not accept an image along with an ''external'' neighborhood. Most of the time, these algorithms are based on windows improperly called neighborhoods. Here is the list of files to revamp, as of revision 1663: * source:trunk/labeling/level.spe.hh * source:trunk/labeling/regional_maxima.hh * source:trunk/labeling/regional_minima.hh * source:trunk/make/voronoi.hh * source:trunk/milena/mln/geom/labeling/blobs.hh * source:trunk/milena/mln/geom/seeds2tiling_roundness.hh * source:trunk/milena/mln/labeling/background.hh * source:trunk/milena/mln/labeling/flat_zones.hh * source:trunk/milena/mln/labeling/foreground.hh * source:trunk/milena/mln/labeling/level.hh * source:trunk/morpho/Rd.hh * source:trunk/morpho/dilation.hh * source:trunk/morpho/opening_area.hh * source:trunk/morpho/opening_attribute.hh -- Ticket URL: <https://trac.lrde.org/olena/ticket/130> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image library.

15 years

[Olena] #159: Distribute SWIG wrappers

by Olena

#159: Distribute SWIG wrappers -------------------------+-------------------------------------------------- Reporter: levill_r | Owner: Olena Team Type: enhancement | Status: new Priority: minor | Milestone: Olena 1.0 Component: Milena | Version: 1.0 Keywords: | -------------------------+-------------------------------------------------- According to Alexandre Hamez, files generated by `swig` (e.g., `*.py` and `*-wrap.cc`) are portable. We should distribute them, as * it would save users wanting to use Swilena some time; * it would free them to have SWIG to compile Swilena. To do: * distribute these files (remove `nodist_` prefixes); * ensure they're available at distribution time (use `dist-hook` in `Makefile.am`); * add generated files to `MAINTAINERCLEANFILES`; * adjust `configure.ac`? (see what Alexandre uses). -- Ticket URL: <https://trac.lrde.org/olena/ticket/159> Olena <http://olena.lrde.epita.fr> Olena, a generic and efficient C++ image processing library.

15 years

3230: Make the fastest version for the algebraic morpho canvas work.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Make the fastest version for the algebraic morpho canvas work. * mln/level/sort_offsets.hh: New. * mln/level/all.hh: Update. * mln/morpho/closing_attribute.hh (closing_attribute_fastest_functor_t): Update. * mln/canvas/morpho/algebraic_union_find.hh (algebraic_union_find_fastest): Update. canvas/morpho/algebraic_union_find.hh | 71 +++---- level/all.hh | 1 level/sort_offsets.hh | 337 ++++++++++++++++++++++++++++++++++ morpho/closing_attribute.hh | 5 4 files changed, 377 insertions(+), 37 deletions(-) Index: mln/level/all.hh --- mln/level/all.hh (revision 3229) +++ mln/level/all.hh (working copy) @@ -66,6 +66,7 @@ # include <mln/level/replace.hh> # include <mln/level/saturate.hh> # include <mln/level/sort_psites.hh> +# include <mln/level/sort_offsets.hh> # include <mln/level/stretch.hh> # include <mln/level/to_enc.hh> # include <mln/level/transform.hh> Index: mln/level/sort_offsets.hh --- mln/level/sort_offsets.hh (revision 0) +++ mln/level/sort_offsets.hh (revision 0) @@ -0,0 +1,337 @@ +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// (LRDE) +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LEVEL_SORT_OFFSETS_HH +# define MLN_LEVEL_SORT_OFFSETS_HH + +/// \file mln/level/sort_offsets.hh +/// \brief Sort_Offsets the contents of an image into another one. +/// +/// \todo Factor code + optimize. + +# include <algorithm> + +# include <mln/core/concept/image.hh> +# include <mln/histo/compute.hh> +# include <mln/util/array.hh> +# include <mln/util/ord.hh> +# include <mln/geom/nsites.hh> + + +namespace mln +{ + + namespace level + { + + /// Sort pixel offsets of the image \p input wrt increasing pixel + /// values. + /// + template <typename I> + util::array<unsigned> + sort_offsets_increasing(const Image& input); + + + // /// Sort pixel offsets of the image \p input wrt decreasing pixel + // /// values. + // /// + // template <typename I> + // util::array<unsigned> + // sort_offsets_decreasing(const Image& input); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + namespace generic + { + + // increasing + + template <typename I> + struct value_offset_less_ + { + const I& ima_; + inline value_offset_less_(const I& ima) : ima_(ima) {} + inline bool operator()(unsigned lhs, unsigned rhs) const + { + return util::ord_strict(ima_.element(lhs), ima_.element(rhs)) + || (ima_.element(lhs) == ima_.element(rhs) + && + lhs < rhs); + } + }; + + template <typename I> + inline + util::array<unsigned> + sort_offsets_increasing(const Image& input_) + { + trace::entering("level::impl::generic::sort_offsets_increasing"); + + const I& input = exact(input_); + + util::array<unsigned> v; + v.reserve(input.nelements()); + mln_fwd_pixter(const I) pxl(input); + for_all(pxl) + v.append(pxl.offset()); + std::sort(v.hook_std_vector_().begin(), v.hook_std_vector_().end(), + value_offset_less_(input)); + + trace::exiting("level::impl::generic::sort_offsets_increasing"); + return v; + } + + + // decreasing + + template <typename I> + struct value_offset_greater_ + { + const I& ima_; + inline value_offset_greater_(const I& ima) : ima_(ima) {} + inline bool operator()(unsigned lhs, unsigned rhs) const + { + return util::ord_strict(ima_.element(rhs), ima_.element(lhs)) + || (ima_.element(lhs) == ima_.element(rhs) + && + lhs > rhs); + } + }; + + template <typename I> + inline + util::array<unsigned> + sort_offsets_decreasing(const Image& input_) + { + trace::entering("level::impl::generic::sort_offsets_decreasing"); + + const I& input = exact(input_); + + util::array<unsigned> v; + v.reserve(input.nelements()); + mln_fwd_pixter(const I) pxl(input); + for_all(pxl) + v.append(pxl.offset()); + std::sort(v.hook_std_vector_().begin(), v.hook_std_vector_().end(), + value_offset_greater_(input)); + + trace::exiting("level::impl::generic::sort_offsets_decreasing"); + return v; + } + + + } // end of namespace mln::level::impl::generic + + + + // increasing + + template <typename I> + inline + util::array<unsigned> + sort_offsets_increasing_radix(const Image& input_) + { + trace::entering("level::impl::sort_offsets_increasing_radix"); + + const I& input = exact(input_); + + typedef mln_vset(I) S; + const S& vset = input.values_eligible(); + const unsigned n = vset.nvalues(); + + // h + histo::array<mln_value(I)> h = histo::compute(input); + + // preparing output data + std::vector<unsigned> loc(vset.nvalues()); + loc[0] = 0; + for (unsigned i = 1; i != n; ++i) + loc[i] = loc[i-1] + h[i-1]; + + // computing output data + util::array<unsigned> vec(geom::nsites(input)); + mln_fwd_pixter(const I) pxl(input); + for_all(pxl) + vec[loc[vset.index_of(pxl.val())]++] = pxl.offset(); + + trace::exiting("level::impl::sort_offsets_increasing_radix"); + return vec; + } + + + // decreasing + + template <typename I> + inline + util::array<unsigned> + sort_offsets_decreasing_radix(const Image& input_) + { + trace::entering("level::impl::sort_offsets_decreasing_radix"); + + const I& input = exact(input_); + + typedef mln_vset(I) S; + const S& vset = input.values_eligible(); + const unsigned n = vset.nvalues(); + + // h + histo::array<mln_value(I)> h = histo::compute(input); + + // preparing output data + std::vector<unsigned> loc(vset.nvalues()); + loc[n-1] = 0; + for (int i = n - 2; i >= 0; --i) + loc[i] = loc[i+1] + h[i+1]; + + // computing output data + util::array<unsigned> vec(geom::nsites(input)); + mln_fwd_pixter(const I) pxl(input); + for_all(pxl) + vec[loc[vset.index_of(pxl.val())]++] = pxl.offset(); + + trace::exiting("level::impl::sort_offsets_decreasing_radix"); + return vec; + } + + + } // end of namespace mln::level::impl + + + + namespace internal + { + + // increasing + + template <typename I> + inline + util::array<unsigned> + sort_offsets_increasing_dispatch(trait::image::quant::any, + const Image& input) + { + return impl::generic::sort_offsets_increasing(input); + } + + template <typename I> + inline + util::array<unsigned> + sort_offsets_increasing_dispatch(trait::image::quant::low, + const Image& input) + { + return impl::sort_offsets_increasing_radix(input); + } + + template <typename I> + inline + util::array<unsigned> + sort_offsets_increasing_dispatch(const Image& input) + { + return sort_offsets_increasing_dispatch(mln_trait_image_quant(I)(), + input); + } + + // decreasing + + template <typename I> + inline + util::array<unsigned> + sort_offsets_decreasing_dispatch(trait::image::quant::any, + const Image& input) + { + return impl::generic::sort_offsets_decreasing(input); + } + + template <typename I> + inline + util::array<unsigned> + sort_offsets_decreasing_dispatch(trait::image::quant::low, + const Image& input) + { + return impl::sort_offsets_decreasing_radix(input); + } + + template <typename I> + inline + util::array<unsigned> + sort_offsets_decreasing_dispatch(const Image& input) + { + return sort_offsets_decreasing_dispatch(mln_trait_image_quant(I)(), + input); + } + + } // end of namespace mln::level::internal + + + + // Facades. + + template <typename I> + inline + util::array<unsigned> + sort_offsets_increasing(const Image& input) + { + trace::entering("level::sort_offsets_increasing"); + mlc_is(mln_trait_image_speed(I), + trait::image::speed::fastest)::check(); + + mln_precondition(exact(input).is_valid()); + util::array<unsigned> output = internal::sort_offsets_increasing_dispatch(input); + + trace::exiting("level::sort_offsets_increasing"); + return output; + } + + template <typename I> + inline + util::array<unsigned> + sort_offsets_decreasing(const Image& input) + { + trace::entering("level::sort_offsets_decreasing"); + mlc_is(mln_trait_image_speed(I), + trait::image::speed::fastest)::check(); + + mln_precondition(exact(input).is_valid()); + util::array<unsigned> output = internal::sort_offsets_decreasing_dispatch(input); + + trace::exiting("level::sort_offsets_decreasing"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::level + +} // end of namespace mln + + +#endif // ! MLN_LEVEL_SORT_OFFSETS_HH Index: mln/morpho/closing_attribute.hh --- mln/morpho/closing_attribute.hh (revision 3229) +++ mln/morpho/closing_attribute.hh (working copy) @@ -40,6 +40,7 @@ # include <mln/morpho/includes.hh> # include <mln/canvas/morpho/algebraic_union_find.hh> # include <mln/level/sort_psites.hh> +# include <mln/level/sort_offsets.hh> # include <mln/util/pix.hh> @@ -144,7 +145,7 @@ typedef A_ A; typedef mln_psite(I) P; - typedef p_array S; + typedef util::array<unsigned> S; mln_result(A) lambda; const S s; @@ -168,7 +169,7 @@ closing_attribute_fastest_functor_t(const Image& input, mln_result(A) lambda) : lambda(lambda), - s(level::sort_psites_increasing(exact(input))) + s(level::sort_offsets_increasing(exact(input))) { } Index: mln/canvas/morpho/algebraic_union_find.hh --- mln/canvas/morpho/algebraic_union_find.hh (revision 3229) +++ mln/canvas/morpho/algebraic_union_find.hh (working copy) @@ -214,7 +214,7 @@ if (parent.element(x) == x) return x; else - return parent.element(x) = find_root(parent, parent.element(x)); + return parent.element(x) = find_root_fastest(parent, parent.element(x)); } @@ -260,63 +260,64 @@ } util::array<int> dp = offsets_wrt(input, nbh); - for (unsigned i = 0; i < dp.nelements(); ++i) - std::cout << dp[i] << ' '; - std::cout << std::endl; + const unsigned n_nbhs = dp.nelements(); - /* + const util::array<unsigned>& s = f.s; + const unsigned n_points = s.nelements(); // First pass. { - for (unsigned p = 0; p < f.s.size(); ++p) - mln_niter(N) n(nbh, p); - for_all(p) + + for (unsigned i = 0; i < n_points; ++i) { + unsigned p = s[i]; // An offset. + // Make set. - { - parent(p) = p; - data(p).take_as_init(make::pix(input, p)); // FIXME: algebraic so p! - } + parent.element(p) = p; + data.element(p).take_as_init( input.element(p) ); // FIXME: Very bad!!! - for_all(n) - if (input.domain().has(n) && deja_vu(n)) + for (unsigned j = 0; j < n_nbhs; ++j) { - P r = find_root(parent, n); + unsigned n = p + dp[j]; + if (! deja_vu.element(n)) + continue; + + unsigned r = find_root_fastest(parent, n); if (r != p) { - if (input(r) == input(p) || (activity(r) && f.is_active(data(r)))) - { - data(p).take(data(r)); - parent(r) = p; - if (activity(r) == false) - activity(p) = false; + if (input.element(r) == input.element(p) + || (activity.element(r) + && f.is_active(data.element(r)))) + { + data.element(p).take(data.element(r)); + parent.element(r) = p; + if (activity.element(r) == false) + activity.element(p) = false; } else { - activity(p) = false; - f.inactivate(data(p)); - } + activity.element(p) = false; + f.inactivate(data.element(p)); } } - deja_vu(p) = true; - } } - */ + deja_vu.element(p) = true; + } - /* + } // Second pass. { - mln_bkd_piter(S) p(f.s); - for_all(p) - if (parent(p) == p) // p is root. - output(p) = input(p); + for (int i = n_points - 1; i >= 0 ; --i) + { + unsigned p = s[i]; + if (parent.element(p) == p) // p is root. + output.element(p) = input.element(p); else - output(p) = output(parent(p)); + output.element(p) = output.element(parent.element(p)); + } } - - */ trace::exiting("canvas::morpho::impl::algebraic_union_find_fastest"); return output;

15 years, 3 months

3229: Fix repeated loops with pixel iterators.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Fix repeated loops with pixel iterators. * mln/core/image/image2d.hh (todo): New. * mln/core/pixter2d.hh (start_): New. Upgrade file doc style. Layout. * mln/core/pixter3d.hh: Likewise. * mln/core/dpoints_pixter.hh (todo): New. * mln/core/internal/pixel_iterator_base.hh: Upgrade file doc style. (start_): New; default impl is no-op. (start): Call start_. * mln/core/internal/pixel_impl.hh (todo): New. (pixel_impl_base_): New. (image_, value_ptr_): Move from pixel_impl_ to pixel_impl_base_. * mln/core/pixel.hh: Upgrade file doc style. (todo): New. * mln/util/pix.hh (todo): New. Misc. * mln/core/concept/window.hh (offsets_wrt): New. * mln/core/concept/neighborhood.hh: Likewise. * mln/morpho/closing_attribute.hh: Update. * mln/morpho/opening_attribute.hh: Update. * mln/canvas/morpho/algebraic_union_find.hh: Update. canvas/morpho/algebraic_union_find.hh | 159 ++++++++++++++++++++++++++++++++-- core/concept/neighborhood.hh | 32 ++++++ core/concept/window.hh | 32 ++++++ core/dpoints_pixter.hh | 2 core/image/image2d.hh | 3 core/internal/pixel_impl.hh | 115 +++++++++++++++++++++--- core/internal/pixel_iterator_base.hh | 24 ++++- core/pixel.hh | 14 +- core/pixter2d.hh | 40 +++++++- core/pixter3d.hh | 73 ++++++++++++--- morpho/closing_attribute.hh | 149 ++++++++++++++++++++++++++++++- morpho/opening_attribute.hh | 2 util/pix.hh | 7 + 13 files changed, 598 insertions(+), 54 deletions(-) Index: mln/core/image/image2d.hh --- mln/core/image/image2d.hh (revision 3228) +++ mln/core/image/image2d.hh (working copy) @@ -33,6 +33,9 @@ /// Definition of the basic mln::image2d class. /// /// \todo Re-activate include at EOF when make::image2d is up again. +/// +/// \todo Rename delta_index and point_at_index as offset and +/// point_at_offset. # include <mln/core/internal/image_primary.hh> # include <mln/core/internal/fixme.hh> Index: mln/core/pixter2d.hh --- mln/core/pixter2d.hh (revision 3228) +++ mln/core/pixter2d.hh (working copy) @@ -30,7 +30,8 @@ # define MLN_CORE_PIXTER2D_HH /// \file mln/core/pixter2d.hh -/// \brief Pixel iterators on a 2-D image with border. +/// +/// Pixel iterators on a 2D image with border. # include <mln/core/internal/pixel_iterator_base.hh> # include <mln/core/alias/point2d.hh> @@ -62,13 +63,21 @@ /// Go to the next pixel. void next_(); + /// Extra code for start(). + void start_(); + private: + /// Twice the size of the image border. unsigned border_x2_; + /// Row offset. unsigned row_offset_; + /// End of the current row. mln_qlf_value(I)* eor_; + + using super_::image_; }; @@ -94,14 +103,21 @@ /// Go to the next pixel. void next_(); + /// Extra code for start(). + void start_(); + private: /// Twice the size of the image border. unsigned border_x2_; + /// Row offset. unsigned row_offset_; + /// Beginning of the current row. mln_qlf_value(I)* bor_; + + using super_::image_; }; @@ -117,8 +133,7 @@ fwd_pixter2d::fwd_pixter2d(I& image) : super_(image), border_x2_(2 * image.border()), - row_offset_(image.bbox().ncols() + border_x2_), - eor_(& opt::at(image, geom::min_row(image), geom::max_col(image)) + 1) + row_offset_(image.bbox().ncols() + border_x2_) { mln_precondition(image.is_valid()); } @@ -136,6 +151,14 @@ } } + template <typename I> + inline + void + fwd_pixter2d::start_() + { + eor_ = & opt::at(image_, geom::min_row(image_), geom::max_col(image_)) + 1; + } + /*------------------. | fwd_pixter2d. | @@ -146,8 +169,7 @@ bkd_pixter2d::bkd_pixter2d(I& image) : super_(image), border_x2_(2 * image.border()), - row_offset_(image.bbox().ncols() + border_x2_), - bor_(& opt::at(image, geom::max_row(image), geom::min_col(image)) - 1) + row_offset_(image.bbox().ncols() + border_x2_) { mln_precondition(image.is_valid()); } @@ -165,6 +187,14 @@ } } + template <typename I> + inline + void + bkd_pixter2d::start_() + { + bor_ = & opt::at(image_, geom::max_row(image_), geom::min_col(image_)) - 1; + } + #endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/core/pixter3d.hh --- mln/core/pixter3d.hh (revision 3228) +++ mln/core/pixter3d.hh (working copy) @@ -30,13 +30,15 @@ # define MLN_CORE_PIXTER3D_HH /// \file mln/core/pixter3d.hh -/// \brief Pixel iterators on a 3-D image with border. +/// +/// Pixel iterators on a 3D image with border. # include <mln/core/internal/pixel_iterator_base.hh> # include <mln/core/alias/point3d.hh> # include <mln/geom/size3d.hh> # include <mln/opt/at.hh> + namespace mln { @@ -62,22 +64,33 @@ /// Go to the next pixel. void next_(); + /// Extra code for start(). + void start_(); + private: + /// Twice the size of the image border. const unsigned border_x2_; + /// Row offset. const unsigned row_offset_; + /// End of the current row. mln_qlf_value(I)* eor_; /// Next slice offset. const unsigned next_sli_offset_; + /// Next slice offset for row. const unsigned next_srow_offset_; + /// Slice offset. const unsigned sli_offset_; + /// End of the current slice. mln_qlf_value(I)* eos_; + + using super_::image_; }; @@ -103,22 +116,33 @@ /// Go to the next pixel. void next_(); + /// Extra code for start(). + void start_(); + private: + /// Twice the size of the image border. const unsigned border_x2_; + /// Row offset. const unsigned row_offset_; + /// Beginning of the current row. mln_qlf_value(I)* bor_; /// Next slice offset. const unsigned next_sli_offset_; + /// Next slice offset for row. const unsigned next_srow_offset_; + /// Slice offset. const unsigned sli_offset_; + /// Beginning of the current slice. mln_qlf_value(I)* bos_; + + using super_::image_; }; @@ -134,16 +158,10 @@ : super_(image), border_x2_(2 * image.border()), row_offset_(image.bbox().ncols() + border_x2_), - eor_(& opt::at(image, geom::min_sli(image), - geom::min_row(image), - geom::max_col(image)) + 1), next_sli_offset_(row_offset_ * border_x2_ + border_x2_), next_srow_offset_(next_sli_offset_ + image.bbox().ncols()), sli_offset_((image.bbox().ncols() + border_x2_) * - (image.bbox().nrows() + border_x2_)), - eos_(& opt::at(image, geom::min_sli(image), - geom::max_row(image), - geom::max_col(image)) + 1) + (image.bbox().nrows() + border_x2_)) { mln_precondition(image.is_valid()); } @@ -151,6 +169,21 @@ template <typename I> inline void + fwd_pixter3d::start_() + { + eor_ = & opt::at(image_, + geom::min_sli(image_), + geom::min_row(image_), + geom::max_col(image_)) + 1; + eos_ = & opt::at(image_, + geom::min_sli(image_), + geom::max_row(image_), + geom::max_col(image_)) + 1; + } + + template <typename I> + inline + void fwd_pixter3d::next_() { ++this->value_ptr_; @@ -178,16 +211,10 @@ : super_(image), border_x2_(2 * image.border()), row_offset_(image.bbox().ncols() + border_x2_), - bor_(& opt::at(image, geom::max_sli(image), - geom::max_row(image), - geom::min_col(image)) - 1), next_sli_offset_(row_offset_ * border_x2_ + border_x2_), next_srow_offset_(next_sli_offset_ + image.bbox().ncols()), sli_offset_((image.bbox().ncols() + border_x2_) * - (image.bbox().nrows() + border_x2_)), - bos_(& opt::at(image, geom::max_sli(image), - geom::min_row(image), - geom::min_col(image)) - 1) + (image.bbox().nrows() + border_x2_)) { mln_precondition(image.is_valid()); } @@ -195,6 +222,21 @@ template <typename I> inline void + bkd_pixter3d::start_() + { + bor_ = & opt::at(image_, + geom::max_sli(image_), + geom::max_row(image_), + geom::min_col(image_)) - 1; + bos_ = & opt::at(image_, + geom::max_sli(image_), + geom::min_row(image_), + geom::min_col(image_)) - 1; + } + + template <typename I> + inline + void bkd_pixter3d::next_() { --this->value_ptr_; @@ -215,4 +257,5 @@ } // end of namespace mln + #endif // ! MLN_CORE_PIXTER3D_HH Index: mln/core/dpoints_pixter.hh --- mln/core/dpoints_pixter.hh (revision 3228) +++ mln/core/dpoints_pixter.hh (working copy) @@ -33,6 +33,8 @@ /// /// \brief Definition of forward and backward mln::dpoint-based /// iterators for pixels iterations. +/// +/// \todo In ::init_ use offsets_wrt (defined in concept/window.hh). # include <cassert> # include <vector> Index: mln/core/internal/pixel_iterator_base.hh --- mln/core/internal/pixel_iterator_base.hh (revision 3228) +++ mln/core/internal/pixel_iterator_base.hh (working copy) @@ -30,12 +30,14 @@ # define MLN_CORE_INTERNAL_PIXEL_ITERATOR_BASE_HH /// \file mln/core/internal/pixel_iterator_base.hh -/// \brief Base classes factoring code for pixel iterator classes. +/// +/// Base classes factoring code for pixel iterator classes. # include <mln/core/concept/pixel_iterator.hh> # include <mln/core/internal/pixel_impl.hh> # include <mln/core/trait/qlf_value.hh> + namespace mln { @@ -58,10 +60,15 @@ pixel_iterator_base_(I& image); protected: + /// Beginning of the image. mln_qlf_value(I)* boi_; + /// End of the image (past-the-end). mln_qlf_value(I)* eoi_; + + /// Default impl is no-op. + void start_(); }; @@ -76,6 +83,7 @@ typedef pixel_iterator_base_<I, E> super_; public: + /// Manipulation /// \{ /// Start an iteration. @@ -87,6 +95,7 @@ /// \} protected: + /// Constructor. forward_pixel_iterator_base_(I& image); }; @@ -114,13 +123,16 @@ /// \} protected: + /// Constructor. backward_pixel_iterator_base_(I& image); }; + #ifndef MLN_INCLUDE_ONLY + /*---------------------------------------. | internal::pixel_iterator_base_<I, E>. | `---------------------------------------*/ @@ -137,6 +149,14 @@ exact(*this).invalidate(); } + template <typename I, typename E> + inline + void + pixel_iterator_base_<I, E>::start_() + { + // Default impl is no-op. + } + /*-----------------------------------------------. | internal::forward_pixel_iterator_base_<I, E>. | @@ -155,6 +175,7 @@ forward_pixel_iterator_base_<I, E>::start() { this->value_ptr_ = this->boi_ + 1; + exact(this)->start_(); } template <typename I, typename E> @@ -191,6 +212,7 @@ backward_pixel_iterator_base_<I, E>::start() { this->value_ptr_ = this->eoi_ - 1; + exact(this)->start_(); } template <typename I, typename E> Index: mln/core/internal/pixel_impl.hh --- mln/core/internal/pixel_impl.hh (revision 3228) +++ mln/core/internal/pixel_impl.hh (working copy) @@ -1,4 +1,5 @@ -// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory (LRDE) +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// (LRDE) // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -32,9 +33,13 @@ /// /// Define a couple of implementation classes to provide methods /// to classes of generalized pixels. +/// +/// \todo Clean-up code. # include <mln/core/concept/image.hh> # include <mln/core/internal/force_exact.hh> +# include <mln/util/pix.hh> + namespace mln @@ -43,11 +48,83 @@ namespace internal { + // We indeed have to handle the couple of cases when I is fastest + // or is not. Justification: mln::pixel derives from pixel_impl_ + // and is a general purpose pixel class; it can be used on any + // image whatever it is a fastest one or not. + + template <bool is_fastest, typename I, typename E> + class pixel_impl_base_; + + + template <typename I, typename E> + struct pixel_impl_base_< false, I, E > // I is not fastest. + { + typedef mlc_if(mlc_is_const(I), const mln_value(I), mln_value(I)) value_ptr_t; + + pixel_impl_base_(I& image, value_ptr_t* value_ptr) + : image_(image), + value_ptr_(value_ptr) + { + } + + protected: + + /// Image associated to the iterator + I& image_; + + /// Current pixel / value + value_ptr_t* value_ptr_; + }; + + + template <typename I, typename E> + struct pixel_impl_base_< true, I, E > // I is fastest => extra interface. + { + typedef mlc_if(mlc_is_const(I), const mln_value(I), mln_value(I)) value_ptr_t; + typedef mlc_unconst(I) unconst_image_t; + + pixel_impl_base_(I& image, value_ptr_t* value_ptr) + : image_(image), + value_ptr_(value_ptr) + { + } + + unsigned offset() const + { + return value_ptr_ - image_.buffer(); + } + + operator util::pix<unconst_image_t>() const + { + util::pix<unconst_image_t> tmp(image_, image_.point_at_index(offset())); + return tmp; + } + + protected: + + /// Image associated to the iterator. + I& image_; + + /// Current pixel / value. + value_ptr_t* value_ptr_; + }; + + /// Implementation class to equip generalized pixel /// classes based on mutable images. + /// template <typename I, typename E> class pixel_impl_ - { + + : public pixel_impl_base_< mlc_is(mln_trait_image_speed(I), + trait::image::speed::fastest)::value, + I, E > + { + typedef pixel_impl_base_< mlc_is(mln_trait_image_speed(I), + trait::image::speed::fastest)::value, + I, E > super_; + public: /// Image type. @@ -79,11 +156,11 @@ protected: - /// Image associated to the iterator - I& image_; + /// Image associated to the iterator. + using super_::image_; - /// Current pixel / value - value* value_ptr_; + /// Current pixel / value. + using super_::value_ptr_; /// Constructor pixel_impl_(I& image); @@ -95,9 +172,18 @@ /// Implementation class to equip generalized pixel /// classes based on constant images. + /// template <typename I, typename E> class pixel_impl_< const I, E > - { + + : public pixel_impl_base_< mlc_is(mln_trait_image_speed(I), + trait::image::speed::fastest)::value, + const I, E > + { + typedef pixel_impl_base_< mlc_is(mln_trait_image_speed(I), + trait::image::speed::fastest)::value, + const I, E > super_; + public: /// Image type. @@ -121,13 +207,14 @@ /// Address of the current iterator value/pixel. const value** address_() const; + protected: - /// Image associated to the iterator - const I& image_; + /// Image associated to the iterator. + using super_::image_; - /// Current pixel / value - const value* value_ptr_; + /// Current pixel / value. + using super_::value_ptr_; /// Constructor pixel_impl_(const I& image); @@ -152,8 +239,7 @@ template <typename I, typename E> inline pixel_impl_<I, E>::pixel_impl_(I& image) : - image_(image), - value_ptr_(0) + super_(image, 0) { } @@ -206,8 +292,7 @@ template <typename I, typename E> inline pixel_impl_<const I, E>::pixel_impl_(const I& image) : - image_(image), - value_ptr_(0) + super_(image, 0) { } Index: mln/core/pixel.hh --- mln/core/pixel.hh (revision 3228) +++ mln/core/pixel.hh (working copy) @@ -1,4 +1,5 @@ -// Copyright (C) 2007 EPITA Research and Development Laboratory +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory +// (LRDE) // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -28,10 +29,13 @@ #ifndef MLN_CORE_PIXEL_HH # define MLN_CORE_PIXEL_HH -/*! \file mln/core/pixel.hh - * - * \brief Definition of the generic pixel class mln::pixel. - */ +/// \file mln/core/pixel.hh +/// +/// Definition of the generic pixel class mln::pixel. +/// +/// \todo Answer these questions: +/// - why do we have 2 classes (mln::pixel and mln::util::pix)? +/// - what about keeping only one of both? # include <mln/core/concept/generalized_pixel.hh> # include <mln/core/internal/pixel_impl.hh> Index: mln/core/concept/window.hh --- mln/core/concept/window.hh (revision 3228) +++ mln/core/concept/window.hh (working copy) @@ -46,6 +46,7 @@ # include <mln/core/site_set/p_array.hh> # include <mln/core/internal/geom_bbox.hh> // For use in convert::from_to. # include <mln/convert/from_to.hxx> +# include <mln/util/array.hh> @@ -70,8 +71,9 @@ namespace mln { - // Forward declaration. + // Forward declarations. template <typename E> struct Window; + template <typename E> struct Image; // Window category flag type. @@ -114,6 +116,12 @@ std::ostream& operator<<(std::ostream& ostr, const Window<W>& win); + // FIXME: Move as a method of Image? + template <typename I, typename W> + util::array<int> + offsets_wrt(const Image& ima, const Window<W>& win); + + namespace convert { @@ -309,6 +317,28 @@ } + template <typename I, typename W> + inline + util::array<int> + offsets_wrt(const Image& ima_, const Window<W>& win_) + { + mln_is_simple_window(W)::check(); + + const I& ima = exact(ima_); + const W& win = exact(win_); + mln_precondition(ima.is_valid()); + // mln_precondition(win.is_valid()); + + util::array<int> arr; + unsigned n = win.size(); + + for (unsigned i = 0; i < n; ++i) + arr.append(ima.delta_index(win.dp(i))); + + return arr; + } + + namespace convert { Index: mln/core/concept/neighborhood.hh --- mln/core/concept/neighborhood.hh (revision 3228) +++ mln/core/concept/neighborhood.hh (working copy) @@ -33,14 +33,21 @@ /// /// Definition of the concept of mln::Neighborhood. -# include <mln/core/concept/object.hh> +# include <mln/core/concept/window.hh> # include <mln/trait/windows.hh> + +# define mln_is_simple_neighborhood(N) mln_is_simple_window(mln_window(N)) + + + + namespace mln { - // Fwd decl. + + // Forward declaration. template <typename E> struct Neighborhood; @@ -90,6 +97,12 @@ operator<<(std::ostream&ostr, const Neighborhood<N>& nbh); + // FIXME: Move as a method of Image? + template <typename I, typename N> + util::array<int> + offsets_wrt(const Image& ima, const Neighborhood<N>& nbh); + + # ifndef MLN_INCLUDE_ONLY @@ -129,6 +142,21 @@ return ostr << exact(nbh).win(); } + template <typename I, typename N> + inline + util::array<int> + offsets_wrt(const Image& ima_, const Neighborhood<N>& nbh_) + { + mln_is_simple_neighborhood(N)::check(); + + const I& ima = exact(ima_); + const N& nbh = exact(nbh_); + mln_precondition(ima.is_valid()); + // mln_precondition(nbh.is_valid()); + + return offsets_wrt(ima, nbh.win()); + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/morpho/closing_attribute.hh --- mln/morpho/closing_attribute.hh (revision 3228) +++ mln/morpho/closing_attribute.hh (working copy) @@ -34,6 +34,8 @@ /// Morphological attribute closing. /// /// \todo How to pass dynamic data (e.g., k of accu::rank) to the routine? +/// +/// \todo Add extension::adjust_fill. # include <mln/morpho/includes.hh> # include <mln/canvas/morpho/algebraic_union_find.hh> @@ -57,11 +59,20 @@ # ifndef MLN_INCLUDE_ONLY + + // Implementations. + namespace impl { + + // Generic version. + + namespace generic + { + template <typename I, typename A_> - struct closing_attribute_t + struct closing_attribute_functor_t { // requirements from mln::canvas::morpho::algebraic_union_find @@ -89,7 +100,7 @@ // end of requirements - closing_attribute_t(const Image& input, mln_result(A) lambda) + closing_attribute_functor_t(const Image& input, mln_result(A) lambda) : lambda(lambda), s(level::sort_psites_increasing(exact(input))) { @@ -97,10 +108,137 @@ }; + + template <typename A, typename I, typename N> + inline + mln_concrete(I) + closing_attribute(const Image& input, const Neighborhood<N>& nbh, + mln_result(A) lambda) + { + trace::entering("morpho::impl::generic::closing_attribute"); + + mln_precondition(exact(input).is_valid()); + + typedef closing_attribute_functor_t<I, A> F; + F f(input, lambda); + mln_concrete(I) output = canvas::morpho::impl::generic::algebraic_union_find(input, nbh, f); + + mln_postcondition(output >= input); + + trace::exiting("morpho::impl::generic::closing_attribute"); + return output; + } + + + } // end of namespace mln::morpho::impl::generic + + + + // "Fastest" version. + + + template <typename I, typename A_> + struct closing_attribute_fastest_functor_t + { + // requirements from mln::canvas::morpho::algebraic_union_find + + typedef A_ A; + typedef mln_psite(I) P; + typedef p_array S; + + mln_result(A) lambda; + const S s; + + void init() + { + // FIXME: border::fill(input, mln_max(mln_value(I))); + } + + bool is_active(const A& attr) const + { + return attr.to_result() < lambda; + } + + void inactivate(A& attr) + { + attr.set_value(lambda); + } + + // end of requirements + + closing_attribute_fastest_functor_t(const Image& input, mln_result(A) lambda) + : lambda(lambda), + s(level::sort_psites_increasing(exact(input))) + { + } + + }; + + + template <typename A, typename I, typename N> + inline + mln_concrete(I) + closing_attribute_fastest(const Image& input, const Neighborhood<N>& nbh, + mln_result(A) lambda) + { + trace::entering("morpho::impl::closing_attribute_fastest"); + + mln_precondition(exact(input).is_valid()); + + typedef impl::closing_attribute_fastest_functor_t<I, A> F; + F f(input, lambda); + mln_concrete(I) output = canvas::morpho::impl::algebraic_union_find_fastest(input, nbh, f); + + mln_postcondition(output >= input); + + trace::exiting("morpho::impl::closing_attribute_fastest"); + return output; + } + + } // end of namespace mln::morpho::impl + // Dispatch. + + namespace internal + { + + template <typename A, typename I, typename N> + inline + mln_concrete(I) + closing_attribute_dispatch(trait::image::speed::any, + const Image& input, const Neighborhood<N>& nbh, + mln_result(A) lambda) + { + return impl::generic::closing_attribute<A>(input, nbh, lambda); + } + +// template <typename A, typename I, typename N> +// inline +// mln_concrete(I) +// closing_attribute_dispatch(trait::image::speed::fastest, +// const Image& input, const Neighborhood<N>& nbh, +// mln_result(A) lambda) +// { +// return impl::closing_attribute_fastest<A>(input, nbh, lambda); +// } + + template <typename A, typename I, typename N> + inline + mln_concrete(I) + closing_attribute_dispatch(const Image& input, const Neighborhood<N>& nbh, + mln_result(A) lambda) + { + return closing_attribute_dispatch<A>(mln_trait_image_speed(I)(), + input, nbh, lambda); + } + + } // end of namespace internal + + + // Facade. template <typename A, typename I, typename N> @@ -113,9 +251,7 @@ mln_precondition(exact(input).is_valid()); - typedef impl::closing_attribute_t<I, A> F; - F f(input, lambda); - mln_concrete(I) output = canvas::morpho::algebraic_union_find(input, nbh, f); + mln_concrete(I) output = internal::closing_attribute_dispatch<A>(input, nbh, lambda); mln_postcondition(output >= input); @@ -124,6 +260,9 @@ } + // Facade. + + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::morpho Index: mln/morpho/opening_attribute.hh --- mln/morpho/opening_attribute.hh (revision 3228) +++ mln/morpho/opening_attribute.hh (working copy) @@ -32,6 +32,8 @@ /// \file mln/morpho/opening_attribute.hh /// /// Morphological attribute opening. +/// +/// \todo Add extension::adjust_fill. # include <mln/morpho/includes.hh> # include <mln/canvas/morpho/algebraic_union_find.hh> Index: mln/canvas/morpho/algebraic_union_find.hh --- mln/canvas/morpho/algebraic_union_find.hh (revision 3228) +++ mln/canvas/morpho/algebraic_union_find.hh (working copy) @@ -51,6 +51,11 @@ namespace impl { + // Generic version. + + namespace generic + { + template <typename I> inline mln_psite(I) @@ -69,7 +74,7 @@ const Neighborhood<N>& nbh_, F& f) { - trace::entering("canvas::morpho::algebraic_union_find"); + trace::entering("canvas::morpho::impl::generic::algebraic_union_find"); // FIXME: Tests? @@ -190,11 +195,134 @@ and add in init: mln::data::fill(output, input); */ - trace::exiting("canvas::morpho::algebraic_union_find"); + trace::exiting("canvas::morpho::impl::generic::algebraic_union_find"); + + return output; + } + + } // end of namespace mln::canvas::morpho::impl::generic + + + + // Fastest version. + + template <typename I> + inline + unsigned + find_root_fastest(I& parent, unsigned x) + { + if (parent.element(x) == x) + return x; + else + return parent.element(x) = find_root(parent, parent.element(x)); + } + + + template <typename I, typename N, typename F> + inline + mln_concrete(I) + algebraic_union_find_fastest(const Image& input_, + const Neighborhood<N>& nbh_, + F& f) + { + trace::entering("canvas::morpho::impl::algebraic_union_find_fastest"); + + // FIXME: Tests? + + typedef typename F::S S; + typedef typename F::A A; + + const I& input = exact(input_); + const N& nbh = exact(nbh_); + + mln_concrete(I) output; + initialize(output, input); + + // Local type. + typedef mln_psite(I) P; + + // Auxiliary data. + mln_ch_value(I, bool) deja_vu; + mln_ch_value(I, bool) activity; + mln_ch_value(I, unsigned) parent; + mln_ch_value(I, A) data; + + // Initialization. + { + initialize(deja_vu, input); + mln::data::fill(deja_vu, false); + initialize(activity, input); + mln::data::fill(activity, true); + initialize(parent, input); + mln::data::fill(parent, 0); + initialize(data, input); + f.init(); // init required. + } + + util::array<int> dp = offsets_wrt(input, nbh); + for (unsigned i = 0; i < dp.nelements(); ++i) + std::cout << dp[i] << ' '; + std::cout << std::endl; + + /* + + // First pass. + { + for (unsigned p = 0; p < f.s.size(); ++p) + mln_niter(N) n(nbh, p); + for_all(p) + { + // Make set. + { + parent(p) = p; + data(p).take_as_init(make::pix(input, p)); // FIXME: algebraic so p! + } + + for_all(n) + if (input.domain().has(n) && deja_vu(n)) + { + P r = find_root(parent, n); + if (r != p) + { + if (input(r) == input(p) || (activity(r) && f.is_active(data(r)))) + { + data(p).take(data(r)); + parent(r) = p; + if (activity(r) == false) + activity(p) = false; + } + else + { + activity(p) = false; + f.inactivate(data(p)); + } + } + } + deja_vu(p) = true; + } + } + + */ + + /* + + // Second pass. + { + mln_bkd_piter(S) p(f.s); + for_all(p) + if (parent(p) == p) // p is root. + output(p) = input(p); + else + output(p) = output(parent(p)); + } + + */ + trace::exiting("canvas::morpho::impl::algebraic_union_find_fastest"); return output; } + } // end of namespace mln::canvas::morpho::impl @@ -212,7 +340,29 @@ const Neighborhood<N>& nbh, F& f) { - return impl::algebraic_union_find(input, nbh, f); + return impl::generic::algebraic_union_find(input, nbh, f); + } + +// template <typename I, typename N, typename F> +// inline +// mln_concrete(I) +// algebraic_union_find_dispatch(trait::image::speed::fastest, +// const Image& input, +// const Neighborhood<N>& nbh, +// F& f) +// { +// return impl::algebraic_union_find_fastest(input, nbh, f); +// } + + template <typename I, typename N, typename F> + inline + mln_concrete(I) + algebraic_union_find_dispatch(const Image& input, + const Neighborhood<N>& nbh, + F& f) + { + return algebraic_union_find_dispatch(mln_trait_image_speed(I)(), + input, nbh, f); } } // end of namespace mln::canvas::morpho::internal @@ -228,8 +378,7 @@ const Neighborhood<N>& nbh, F& f) { - return internal::algebraic_union_find_dispatch(mln_trait_image_speed(I)(), - input, nbh, f); + return internal::algebraic_union_find_dispatch(input, nbh, f); } Index: mln/util/pix.hh --- mln/util/pix.hh (revision 3228) +++ mln/util/pix.hh (working copy) @@ -32,6 +32,13 @@ /// \file mln/util/pix.hh /// /// Definition of an instant pix. +/// +/// \todo Rename as util::pixel. +/// +/// \todo Think about separating this class between +/// util::pixel<"mutable" I> and util::pixel<const I>. +/// +/// \todo Look at the todo entry of mln/core/pixel.hh. # include <mln/core/concept/image.hh>

15 years, 3 months

3228: Fix delta_index in image3d.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Fix delta_index in image3d. * mln/core/image/image3d.hh (delta_index): Fix. * mln/morpho/elementary/gradient.hh (gradient_on_function): Handle extension. (todo): Remove; done. core/image/image3d.hh | 3 ++- morpho/elementary/gradient.hh | 12 +++++++----- 2 files changed, 9 insertions(+), 6 deletions(-) Index: mln/core/image/image3d.hh --- mln/core/image/image3d.hh (revision 3227) +++ mln/core/image/image3d.hh (working copy) @@ -560,7 +560,8 @@ image3d<T>::delta_index(const dpoint3d& dp) const { mln_precondition(this->is_valid()); - int o = dp[0]; + int o = (dp[0] * this->data_->vb_.len(1) + + dp[1]) * this->data_->vb_.len(2) + dp[2]; return o; } Index: mln/morpho/elementary/gradient.hh --- mln/morpho/elementary/gradient.hh (revision 3227) +++ mln/morpho/elementary/gradient.hh (working copy) @@ -32,8 +32,6 @@ /// \file mln/morpho/elementary/gradient.hh /// /// \todo Add fastest version for sets. -/// -/// \todo Replace .domain().has() by .has()! # include <mln/morpho/includes.hh> # include <mln/accu/min_max.hh> @@ -87,6 +85,8 @@ accu::min_max<mln_value(I)> a; + extension::adjust_duplicate(input, nbh); + mln_concrete(I) output; initialize(output, input); @@ -95,7 +95,7 @@ for_all(p) { a.take_as_init(input(p)); - for_all(n) if (input.domain().has(n)) + for_all(n) if (input.has(n)) a.take(input(n)); output(p) = a.second() - a.first(); } @@ -114,6 +114,8 @@ const N& nbh = exact(nbh_); internal::gradient_tests(input, nbh); + extension::adjust_duplicate(input, nbh); + mln_concrete(I) output; initialize(output, input); data::fill(output, false); @@ -123,7 +125,7 @@ for_all(p) if (input(p) == true) { - for_all(n) if (input.domain().has(n)) + for_all(n) if (input.has(n)) if (input(n) == false) { output(p) = true; @@ -132,7 +134,7 @@ } else // input(p) == false { - for_all(n) if (input.domain().has(n)) + for_all(n) if (input.has(n)) if (input(n) == true) { output(p) = true;

15 years, 3 months

← Newer
1
2
3
4
5
6
7
8
...
16
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches January 2009