Olena-patches May 2005

olena-patches@lrde.epita.fr

8 participants
22 discussions

proto-1.0 198: Add shortest path watershed transform

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 23 +++ oln/core/abstract/niter.hh | 5 oln/core/gen/image_with_nbh.hh | 8 + oln/core/gen/internal/value_box.hh | 14 + oln/level/extrema_components.hh | 35 +++- oln/level/level_components.hh | 9 - oln/makefile.src | 3 oln/morpho/lower_completion.hh | 9 - oln/morpho/shortest_path_watershed.hh | 207 +++++++++++++++++++++++++++++ tests/core/tests/niter2d | 41 +++++ tests/morpho/tests/shortest_path_watershed | 30 ++++ 11 files changed, 365 insertions(+), 19 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add shortest path watershed transform. * oln/morpho/shortest_path_watershed.hh: New file. * tests/morpho/tests/shortest_path_watershed: New test. * oln/core/gen/image_with_nbh.hh (image_with_nbh(const oln_type_of(I, size)&, const abstract::neighborhood<N>&)): New ctor. * oln/level/level_components.hh (level_components), * oln/morpho/lower_completion.hh (lower_completion): Use it. * oln/core/abstract/niter.hh (nbh): New method. * tests/core/tests/niter2d: New test. * oln/level/extrema_components.hh (extrema_components): Use unsigned to compute the level components. * oln/core/gen/internal/value_box.hh (operator>(const value_box<II>&), operator>(const V&)): New operators. * oln/makefile.src (OLN_DEP): Add level/extrema_components.hh, level/level_components.hh and morpho/shortest_path_watershed.hh. Index: olena/tests/morpho/tests/shortest_path_watershed --- olena/tests/morpho/tests/shortest_path_watershed (revision 0) +++ olena/tests/morpho/tests/shortest_path_watershed (revision 0) @@ -0,0 +1,30 @@ + // -*- C++ -*- +#include "data.hh" + +#include <ntg/int.hh> +#include <oln/core/2d/image2d.hh> +#include <oln/core/gen/image_with_nbh.hh> +#include <oln/io/read_image.hh> +#include <oln/morpho/shortest_path_watershed.hh> +#include <oln/utils/md5.hh> + +using namespace oln; + +bool check() +{ + // MD5 sum of object.pbm's watershed transform result. + utils::key::value_type data_key[16] = + { 0x47, 0x69, 0xe9, 0x5c, 0x82, 0xe6, 0x2e, 0xc4, + 0x0, 0x72, 0x4a, 0xf5, 0x5f, 0x69, 0xf, 0x2b }; + utils::key key(data_key); + + image2d<ntg::int_u8> raw_input; + raw_input = io::read(rdata("squares.pgm")); + typedef image_with_nbh<image2d<ntg::int_u8>, neighborhood2d> image_type; + image_type input = join(raw_input, neighb_c4()); + + if (utils::md5(morpho::shortest_path_watershed<ntg::int_u8>(input)) != key) + return true; + + return false; +} Index: olena/tests/core/tests/niter2d --- olena/tests/core/tests/niter2d (revision 0) +++ olena/tests/core/tests/niter2d (revision 0) @@ -0,0 +1,41 @@ + // -*- C++ -*- +#include <iostream> + +#include "ntg/all.hh" +#include "oln/basics2d.hh" +#include "oln/core/gen/image_with_nbh.hh" + +#include "check.hh" +#include "data.hh" + +bool check() +{ + oln::image2d<int> ima_without_nbh(10, 10); + oln::image_with_nbh<oln::image2d<int>, oln::neighborhood2d> ima = + oln::join(ima_without_nbh, oln::neighb_c4()); + int cpt = 0; + + oln::fwd_piter2d fwd_it(ima.size()); + for_all_p (fwd_it) + { + oln::fwd_niter2d fwd_nit(ima); + for_all_n_of_p (fwd_nit, fwd_it) + cpt++; + } + + if (cpt != 400) + return true; + + cpt = 0; + for_all_p (fwd_it) + { + oln::bkd_niter2d bkd_nit(ima); + for_all_n_of_p (bkd_nit, fwd_it) + cpt++; + } + + if (cpt != 400) + return true; + + return false; +} Index: olena/oln/core/abstract/niter.hh --- olena/oln/core/abstract/niter.hh (revision 197) +++ olena/oln/core/abstract/niter.hh (working copy) @@ -119,6 +119,11 @@ this->invalidate(); } + neighb_type nbh() + { + return nbh_; + } + protected: const neighb_type nbh_; // copy is safe Index: olena/oln/core/gen/image_with_nbh.hh --- olena/oln/core/gen/image_with_nbh.hh (revision 197) +++ olena/oln/core/gen/image_with_nbh.hh (working copy) @@ -80,6 +80,14 @@ this->image_ = tmp; } + image_with_nbh(const oln_type_of(I, size)& size, + const abstract::neighborhood<N>& nbh) : + nbh_(nbh.exact()) + { + I tmp(size); // FIXME: hack + this->image_ = tmp; + } + image_with_nbh(abstract::image& image, const abstract::neighborhood<N>& nbh) : super_type(image), Index: olena/oln/core/gen/internal/value_box.hh --- olena/oln/core/gen/internal/value_box.hh (revision 197) +++ olena/oln/core/gen/internal/value_box.hh (working copy) @@ -114,6 +114,20 @@ return this->value() < rhs; } + /// Operator > (rhs is a value_box). + template <typename II> + bool operator>(const value_box<II>& rhs) const + { + return this->value() > rhs.value(); + } + + /// Operator > (rhs is a value). + template <typename V> + bool operator>(const V& rhs) const + { + return this->value() > rhs; + } + /*! \brief op= ** FIXME:... Index: olena/oln/makefile.src --- olena/oln/makefile.src (revision 197) +++ olena/oln/makefile.src (working copy) @@ -150,7 +150,9 @@ \ level/arith.hh \ level/compare.hh \ + level/extrema_components.hh \ level/fill.hh \ + level/level_components.hh \ level/logic.hh \ \ morpho/closing.hh \ @@ -166,6 +168,7 @@ morpho/reconstruction_by_erosion.hh \ morpho/reconstruction_selfdual.hh \ morpho/reconstruction.hh \ + morpho/shortest_path_watershed.hh \ morpho/stat.hh \ morpho/tags.hh \ \ Index: olena/oln/morpho/lower_completion.hh --- olena/oln/morpho/lower_completion.hh (revision 197) +++ olena/oln/morpho/lower_completion.hh (working copy) @@ -50,10 +50,12 @@ typedef std::queue<point_type> queue_type; queue_type q; - typename ch_value_type<I, bool>::ret processed(input.size()); + typename ch_value_type<I, bool>::ret processed(input.size(), + input.nbh_get ()); level::fill (processed, false); - typename ch_value_type<I, unsigned>::ret distance(input.size()); + typename ch_value_type<I, unsigned>::ret distance(input.size(), + input.nbh_get()); unsigned cur_dist = 1; oln_type_of(I, piter) p(input.size()); @@ -108,7 +110,8 @@ | Lower completion. | `-------------------*/ - typename ch_value_type<I, DestValue>::ret output(input.size()); + typename ch_value_type<I, DestValue>::ret output(input.size(), + input.nbh_get()); for_all_p (p) if (distance[p] == ntg_zero_val(DestValue)) output[p] = cur_dist * input[p].value(); Index: olena/oln/morpho/shortest_path_watershed.hh --- olena/oln/morpho/shortest_path_watershed.hh (revision 0) +++ olena/oln/morpho/shortest_path_watershed.hh (revision 0) @@ -0,0 +1,207 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_SHORTEST_PATH_WATERSHED_HH +# define OLENA_MORPHO_SHORTEST_PATH_WATERSHED_HH + +# include <queue> + +# include "oln/level/fill.hh" +# include "oln/level/extrema_components.hh" +# include "oln/morpho/lower_completion.hh" + +namespace oln { + + namespace morpho { + + namespace internal { + + /// Functor used in ordered queues of points. + template <typename I> + class greater_point_type + { + public: + typedef oln_type_of(I, point) point_type; + + greater_point_type(const abstract::image& im) : + im_ (im) + { + } + + /// Is \a x greater than \a y? + bool operator()(const point_type& x, const point_type& y) + { + return im_[x] > im_[y]; + } + + private: + const abstract::image& im_; + }; + + /// Facade to build a oln::level::greater_point_type. + template <typename I> + greater_point_type + greater_point(const abstract::image& im) + { + return greater_point_type(im); + } + + + // FIXME: To be rewritten. Moreover, the distance d(p, q) is not + // taken into account in this version of cost (but it should not + // bother us as long as we are using first-order neighborhoods). + template <typename I> + int + cost (const abstract::image_with_nbh& im, + const oln_type_of(I, point)& p, const oln_type_of(I, point)& q) + { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + + oln_type_of(I, niter) n(im); + + int ls_p = 0; + for_all_n_of_p (n, p) + if (im.hold(n) and int(im[p] - im[n]) > ls_p) + ls_p = im[p] - im[n]; + + int ls_q = 0; + for_all_n_of_p (n, q) + if (im.hold(n) and int(im[q] - im[n]) > ls_q) + ls_q = im[q] - im[n]; + + if (im[p] > im[q]) + return ls_p; + else if (im[q] > im[p]) + return ls_q; + else + return (ls_p + ls_q) / 2; + } + + } // End of namespace internal. + + + template <typename DestValue, typename I> + typename ch_value_type<I, DestValue>::ret + shortest_path_watershed(const abstract::image_with_nbh& input) + { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + + const DestValue wshed = ntg_min_val(DestValue); + + // Get a lower complete image of the input. + typename ch_value_type<I, unsigned>::ret lc = + lower_completion<unsigned>(input); + + // We keep a track of already processed points. + typename ch_value_type<I, bool>::ret processed (lc.size(), + lc.nbh_get()); + level::fill (processed, false); + + // Initialise output with the minima components. + typename ch_value_type<I, DestValue>::ret output = + level::minima_components<DestValue>(lc); + + // Distance. + typedef typename ch_value_type<I, unsigned>::ret dist_type; + dist_type dist (lc.size(), lc.nbh_get()); + level::fill(dist, ntg_max_val(DestValue)); + // Initialize distance with values of minima, and mark these + // points as processed (remember that points of LC who have a + // value greater than ntg_min_val(DestValue) belongs to a + // minimum). + oln_type_of(I, piter) p(lc.size()); + for_all_p (p) + if (output[p].value() > ntg_min_val(DestValue)) + dist[p] = lc[p]; + + // Ordered queue. + typedef oln_type_of(I, point) point_type; + typedef + std::priority_queue<point_type, + std::vector<point_type>, + internal::greater_point_type<dist_type> > + ordered_queue_type; + ordered_queue_type q(internal::greater_point(dist)); + // Fill the ordered queue with the points of the border of the + // minima of the (lower complete) input. + for_all_p (p) + if (output[p].value() > ntg_min_val(DestValue)) + { + bool border_p = false; + oln_type_of(I, niter) n(lc); + for_all_n_of_p (n, p) + if (lc.hold(n) and output[n].value() == ntg_min_val(DestValue)) + { + // P is both in a minima and adjacent to a non minima: + // it's on the border of a minima. + border_p = true; + break; + }; + if (border_p) + q.push(p); + else + // Inner points of minima have already been processed. + processed[p] = true; + } + + while (!q.empty()) + { + point_type p = q.top(); + q.pop(); + if (processed[p]) + continue; + processed[p] = true; + + oln_type_of(I, niter) n(lc); + for_all_n_of_p (n, p) + { + if (lc.hold(n)) + if (dist[p] + internal::cost(lc, p, n) < dist[n]) + { + dist[n] = dist[p] + internal::cost(lc, p, n); + output[n] = output[p]; + q.push(n); + + } + else if (output[n] != wshed and + dist[p] + internal::cost(lc, p, n) == dist[n] and + output[n] != output[p]) + { + output[n] = wshed; + q.push(n); + } + } + } + + return output; + } + + } // end of namespace oln::morpho + +} // end of namespace oln + +#endif // ! OLENA_MORPHO_SHORTEST_PATH_WATERSHED_HH Index: olena/oln/level/extrema_components.hh --- olena/oln/level/extrema_components.hh (revision 197) +++ olena/oln/level/extrema_components.hh (working copy) @@ -50,16 +50,17 @@ Cmp cmp; // Compute level components. - typename ch_value_type<I, DestValue>::ret comps = - level_components<DestValue>(input); - std::set<DestValue> extrema; - std::set<DestValue> non_extrema; + typedef unsigned comp_type; + typename ch_value_type<I, comp_type>::ret comps = + level_components<comp_type>(input); + std::set<comp_type> extrema; + std::set<comp_type> non_extrema; // Search extrema components. oln_type_of(I, piter) p(input.size()); for_all_p (p) { - DestValue comp = comps[p]; + comp_type comp = comps[p]; if (non_extrema.find(comp) == non_extrema.end ()) { // A new level is a (potential) extrema by default. @@ -71,23 +72,27 @@ { extrema.erase(comp); non_extrema.insert(comp); + break; } } } // Re-label the extrema. label_map hold the assigned labels. - std::map<DestValue, DestValue> label_map; + std::map<comp_type, DestValue> label_map; { DestValue cur_label = ntg_min_val(DestValue) + 1; - for (typename std::set<DestValue>::const_iterator i = + for (typename std::set<comp_type>::const_iterator i = extrema.begin(); i != extrema.end(); ++i, ++cur_label) + { label_map[*i] = cur_label; } - typename ch_value_type<I, DestValue>::ret output (input.size()); + } + typename ch_value_type<I, DestValue>::ret output (input.size(), + input.nbh_get()); level::fill (output, ntg_min_val(DestValue)); for_all_p (p) { - DestValue comp = comps[p]; + comp_type comp = comps[p]; if (label_map.find(comp) != label_map.end()) output[p] = label_map[comp]; } @@ -103,8 +108,10 @@ minima_components(const abstract::image_with_nbh& input) { mlc_is_a(I, abstract::scalar_valued_image)::ensure(); - return internal::extrema_components< DestValue, - std::less<DestValue> >(input); + typedef oln_type_of(I, value) input_value_type; + return + internal::extrema_components< DestValue, + std::less<input_value_type> >(input); } /// Find the maxima level components of \a input. @@ -113,8 +120,10 @@ maxima_components(const abstract::image_with_nbh& input) { mlc_is_a(I, abstract::scalar_valued_image)::ensure(); - return internal::extrema_components< DestValue, - std::greater<DestValue> >(input); + typedef oln_type_of(I, value) input_value_type; + return + internal::extrema_components< DestValue, + std::greater<input_value_type> >(input); } } // end of namespace oln::level. Index: olena/oln/level/level_components.hh --- olena/oln/level/level_components.hh (revision 197) +++ olena/oln/level/level_components.hh (working copy) @@ -43,8 +43,10 @@ { mlc_is_a(I, abstract::scalar_valued_image)::ensure(); - typename ch_value_type<I, DestValue>::ret labels(input.size()); - typename ch_value_type<I, bool>::ret processed(input.size()); + typename ch_value_type<I, DestValue>::ret labels(input.size(), + input.nbh_get()); + typename ch_value_type<I, bool>::ret processed(input.size(), + input.nbh_get()); level::fill (processed, false); DestValue cur_label = ntg_min_val(DestValue); @@ -57,6 +59,7 @@ if (!processed[p]) { labels[p] = cur_label; + processed[p] = true; q.push(p); while (!q.empty()) { @@ -64,7 +67,7 @@ q.pop(); oln_type_of(I, niter) n(input); for_all_n_of_p (n, s) - if (input.hold(n) && input[n] == input[s] && !processed[n]) + if (input.hold(n) && !processed[n] && input[n] == input[s]) { labels[n] = cur_label; processed[n] = true;

19 years, 6 months

Gradients morphologiques et conversions forcées

by Roland Levillain

¡Hola! J'ai voulu ajouter les gradients morphologiques à Olena, mais comme ceux-ci sont basés sur une différence entre deux images, on a des problèmes de conversion dès que l'on utilise des types d'Integre : une différence entre deux image2d<int_u8> donne une image2d<int_s9> (normal). Dans Olena 0.10, ce problème était réglé en utilisant des foncteurs de conversion (convert::force<>), mais cela a un impact sur les opérateurs arithmétiques sur les images. En clair, il faudrait équiper oln/level/arith.hh pour qu'il sache utiliser convert::abstract::conversion<>. Je peux intégrer ces outils de oln::convert depuis Olena 0.10 et modifier oln/level/arith.hh, ou bien y a-t-il une meilleure façon de faire ?

19 years, 7 months

proto-1.0 197: Fix morphological dilation and closing

by Roland Levillain

Hum. :) https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 20 ++++++++++++++++ oln/morpho/closing.hh | 43 +++++++++++++++++++++++------------ oln/morpho/dilation.hh | 4 +-- oln/morpho/erosion.hh | 2 - oln/morpho/opening.hh | 2 - tests/level/tests/extrema_components | 15 +++++------- tests/morpho/tests/closing | 5 +--- tests/morpho/tests/dilation | 5 +--- tests/morpho/tests/erosion | 5 +--- tests/morpho/tests/lower_completion | 13 +++++----- tests/morpho/tests/opening | 5 +--- 11 files changed, 75 insertions(+), 44 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix morphological dilation and closing. * oln/morpho/dilation.hh (impl::dilation_): Fix dilation. Adjust copyright dates. * oln/morpho/closing.hh (impl::closing_): Fix closing. Handle morpho kinds. Adjust copyright dates. * oln/morpho/erosion.hh, oln/morpho/opening.hh: Adjust copyright dates. * tests/morpho/tests/closing (check), * tests/morpho/tests/dilation (check), * tests/morpho/tests/erosion (check), * tests/morpho/tests/opening (check): Fix checksums. * tests/morpho/tests/lower_completion, * tests/level/tests/extrema_components: Include Olena headers using angle bracket syntax. Index: olena/tests/morpho/tests/opening --- olena/tests/morpho/tests/opening (revision 196) +++ olena/tests/morpho/tests/opening (working copy) @@ -13,10 +13,9 @@ bool check() { // MD5 sum of object.pbm's opening result. - // FIXME: Replace this fake with the actual result. utils::key::value_type data_key[16] = - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + { 0x21, 0x52, 0x1b, 0x70, 0x84, 0x7f, 0xed, 0x96, + 0xa9, 0x83, 0x80, 0x57, 0x48, 0xa4, 0x26, 0x80 }; utils::key key(data_key); typedef image2d<ntg::bin> im_type; Index: olena/tests/morpho/tests/lower_completion --- olena/tests/morpho/tests/lower_completion (revision 196) +++ olena/tests/morpho/tests/lower_completion (working copy) @@ -1,11 +1,12 @@ // -*- C++ -*- #include "data.hh" -#include "ntg/int.hh" -#include "oln/core/2d/image2d.hh" -#include "oln/core/gen/image_with_nbh.hh" -#include "oln/io/read_image.hh" -#include "oln/morpho/lower_completion.hh" -#include "oln/ops/cmp.hh" + +#include <ntg/int.hh> +#include <oln/core/2d/image2d.hh> +#include <oln/core/gen/image_with_nbh.hh> +#include <oln/io/read_image.hh> +#include <oln/morpho/lower_completion.hh> +#include <oln/ops/cmp.hh> using namespace oln; Index: olena/tests/morpho/tests/dilation --- olena/tests/morpho/tests/dilation (revision 196) +++ olena/tests/morpho/tests/dilation (working copy) @@ -13,10 +13,9 @@ bool check() { // MD5 sum of object.pbm's erosion result. - // FIXME: Update this sum. utils::key::value_type data_key[16] = - {0xbf, 0x67, 0x3, 0xa1, 0x2d, 0x6c, 0xac, 0xe9, - 0xf3, 0x7c, 0x19, 0x4c, 0x3a, 0x3b, 0x4d, 0xaa}; + { 0x38, 0x56, 0x92, 0x53, 0xca, 0xd1, 0x32, 0x3e, + 0x99, 0xf4, 0xe7, 0x59, 0x3, 0x54, 0x2c, 0x54 }; utils::key key(data_key); typedef image2d<ntg::bin> im_type; Index: olena/tests/morpho/tests/erosion --- olena/tests/morpho/tests/erosion (revision 196) +++ olena/tests/morpho/tests/erosion (working copy) @@ -13,10 +13,9 @@ bool check() { // MD5 sum of object.pbm's erosion result. - // FIXME: Replace this fake with the actual result. utils::key::value_type data_key[16] = - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + { 0x30, 0x23, 0x4d, 0xe5, 0xd6, 0x28, 0xeb, 0x8b, + 0x18, 0x82, 0x43, 0x4b, 0xfc, 0x3f, 0x21, 0xc2 }; utils::key key(data_key); typedef image2d<ntg::bin> im_type; Index: olena/tests/morpho/tests/closing --- olena/tests/morpho/tests/closing (revision 196) +++ olena/tests/morpho/tests/closing (working copy) @@ -13,10 +13,9 @@ bool check() { // MD5 sum of object.pbm's closing result. - // FIXME: Replace this fake with the actual result. utils::key::value_type data_key[16] = - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + { 0xb, 0xec, 0x55, 0x93, 0x1c, 0x3, 0xee, 0xed, + 0x1e, 0xc5, 0x6a, 0x45, 0xa2, 0x95, 0xe3, 0xad }; utils::key key(data_key); typedef image2d<ntg::bin> im_type; Index: olena/oln/morpho/closing.hh --- olena/oln/morpho/closing.hh (revision 196) +++ olena/oln/morpho/closing.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001-2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,34 +41,47 @@ - // fwd decl of facade + // Fwd decl of closing's facade. + + template<typename K, typename I, typename W> + oln_type_of(I, concrete) closing(const tag::kind<K>& kind, + const abstract::image& input, + const abstract::window<W>& win); + + // Facade for classical closing. template<typename I, typename W> oln_type_of(I, concrete) closing(const abstract::image& input, - const abstract::window<W>& win); + const abstract::window<W>& win) + { + return closing(tag::classical, input, win); + } namespace impl { - // generic - template<typename I, typename W> - oln_type_of(I, concrete) closing_(const abstract::image& input, + template<typename K, typename I, typename W> + oln_type_of(I, concrete) closing_(const tag::kind<K>& kind, + const abstract::image& input, const abstract::window<W>& win) { - entering("generic"); - oln_type_of(I, concrete) output; + entering("->generic"); + registering(input, "input"); - output = dilation(erosion(input, win), -win); + oln_type_of(I, concrete) output("output"); + output = erosion(kind, dilation(kind, input, win), -win); - exiting("generic"); + exiting("->generic"); return output; } + // add some other impls here... + } // end of namespace oln::morpho::impl @@ -77,16 +90,18 @@ /// Generic closing (facade). - template<typename I, typename W> - oln_type_of(I, concrete) closing(const abstract::image& input, + template<typename K, typename I, typename W> + oln_type_of(I, concrete) closing(const tag::kind<K>& kind, + const abstract::image& input, const abstract::window<W>& win) { mlc::eq<oln_type_of(I, grid), oln_wn_type_of(W, grid)>::ensure(); entering("morpho::closing"); - oln_type_of(I, concrete) output; + registering(input, "input"); - output = impl::closing_(input.exact(), win.exact()); + oln_type_of(I, concrete) output("output"); + output = impl::closing_(kind, input.exact(), win.exact()); exiting("morpho::closing"); return output; Index: olena/oln/morpho/opening.hh --- olena/oln/morpho/opening.hh (revision 196) +++ olena/oln/morpho/opening.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001-2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms Index: olena/oln/morpho/dilation.hh --- olena/oln/morpho/dilation.hh (revision 196) +++ olena/oln/morpho/dilation.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001-2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2004, 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -77,7 +77,7 @@ oln_type_of(I, fwd_piter) p(input.size()); for_all_p (p) - output[p] = kind.min(input, p, win); + output[p] = kind.max(input, p, win); exiting("->generic"); return output; Index: olena/oln/morpho/erosion.hh --- olena/oln/morpho/erosion.hh (revision 196) +++ olena/oln/morpho/erosion.hh (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2001-2005 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms Index: olena/tests/level/tests/extrema_components --- olena/tests/level/tests/extrema_components (revision 196) +++ olena/tests/level/tests/extrema_components (working copy) @@ -1,13 +1,12 @@ // -*- C++ -*- #include "data.hh" -#include "ntg/int.hh" -#include "oln/core/2d/image2d.hh" -#include "oln/core/gen/image_with_nbh.hh" -#include "oln/io/read_image.hh" -#include "oln/io/write_image.hh" -#include "oln/level/extrema_components.hh" -#include "oln/ops/cmp.hh" -#include "oln/utils/md5.hh" +#include <oln/utils/md5.hh> + +#include <ntg/int.hh> +#include <oln/core/2d/image2d.hh> +#include <oln/core/gen/image_with_nbh.hh> +#include <oln/io/read_image.hh> +#include <oln/level/extrema_components.hh> using namespace oln;

19 years, 7 months

Re: [Olena-patches] Propale: inverser les valeurs de retour des tests

by Christophe Berger

Roland Levillain wrote: > Je propose donc d'inverser les valeurs de retour de tous les > tests. Qu'en dites-vous ? Completement d'accord -- Christophe Berger

19 years, 7 months

Propale: inverser les valeurs de retour des tests

by Roland Levillain

Ça fait longtemps que je le dis (sans rien faire pour que ça change, mea culpa), mais comme je suis en plein dedans, je pense qu'il est grand temps de le dire : les tests d'Olena sont contre-intuitifs (si, si !). Actuellement, il s'agit de bouts de code contenant une fonction check() renvoyant `false' si le test est correct, `true' sinon (sic). Bien sûr, tous les gens qui développent Olena sont habituées à cette bizarrerie, mais des gens extérieures risquent d'être déroutées, comme l'est toute personne qui ouvre un test olénoïde pour la première fois. Je propose donc d'inverser les valeurs de retour de tous les tests. Qu'en dites-vous ?

19 years, 7 months

196: Add (queue-based) level and extrema components computation

by Roland Levillain

Ce code est sans doute redondant avec ce qu'offriront les canevas sur l'Union-Find, mais : 1. je vais en avoir besoin pour écrire des variantes du watershed ; 2. je ne voulais pas marcher sur les plates-bandes de Christophe et Nicolas ; d'où l'idée d'écrire les calculs des extrema locaux avec une variante à base de FIFO. (C'est très certainement (très) sub-optimal.) https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 13 +++ oln/level/extrema_components.hh | 124 +++++++++++++++++++++++++++++++++++ oln/level/level_components.hh | 83 +++++++++++++++++++++++ oln/morpho/lower_completion.hh | 5 - tests/level/tests/extrema_components | 42 +++++++++++ tests/morpho/tests/lower_completion | 1 6 files changed, 265 insertions(+), 3 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add (queue-based) level and extrema components computation. * oln/level/level_components.hh, oln/level/extrema_components.hh: New files. * tests/level/tests/extrema_components: New test. * oln/morpho/lower_completion.hh: Check that the input is a scalar image. * tests/morpho/tests/lower_completion: Don't include useless headers. Index: olena/tests/morpho/tests/lower_completion --- olena/tests/morpho/tests/lower_completion (revision 195) +++ olena/tests/morpho/tests/lower_completion (working copy) @@ -4,7 +4,6 @@ #include "oln/core/2d/image2d.hh" #include "oln/core/gen/image_with_nbh.hh" #include "oln/io/read_image.hh" -#include "oln/io/write_image.hh" #include "oln/morpho/lower_completion.hh" #include "oln/ops/cmp.hh" Index: olena/tests/level/tests/extrema_components --- olena/tests/level/tests/extrema_components (revision 0) +++ olena/tests/level/tests/extrema_components (revision 0) @@ -0,0 +1,42 @@ + // -*- C++ -*- +#include "data.hh" +#include "ntg/int.hh" +#include "oln/core/2d/image2d.hh" +#include "oln/core/gen/image_with_nbh.hh" +#include "oln/io/read_image.hh" +#include "oln/io/write_image.hh" +#include "oln/level/extrema_components.hh" +#include "oln/ops/cmp.hh" +#include "oln/utils/md5.hh" + +using namespace oln; + +bool check() +{ + image2d<ntg::int_u8> raw_input; + raw_input = io::read(rdata("16x16.pgm")); + typedef image_with_nbh<image2d<ntg::int_u8>, neighborhood2d> image_type; + image_type input = join(raw_input, neighb_c4()); + + // MD5 sum of the minima. + utils::key::value_type minima_data_key[16] = + { 0x72, 0xad, 0x21, 0xcc, 0xd9, 0x6a, 0x6a, 0x82, + 0xb8, 0xea, 0x60, 0x1f, 0xcf, 0x76, 0x45, 0x13 }; + utils::key minima_key(minima_data_key); + + image_type minima = level::minima_components<ntg::int_u8>(input); + if (utils::md5(minima) != minima_key) + return true; + + // MD5 sum of the maxima. + utils::key::value_type maxima_data_key[16] = + { 0x6e, 0x71, 0x74, 0x7c, 0xf8, 0xb, 0xfe, 0xa, + 0xa9, 0xd2, 0x84, 0x26, 0xa5, 0x3e, 0xfd, 0xba }; + utils::key maxima_key(maxima_data_key); + + image_type maxima = level::maxima_components<ntg::int_u8>(input); + if (utils::md5(maxima) != maxima_key) + return true; + + return false; +} Index: olena/oln/morpho/lower_completion.hh --- olena/oln/morpho/lower_completion.hh (revision 195) +++ olena/oln/morpho/lower_completion.hh (working copy) @@ -36,11 +36,12 @@ namespace morpho { - // FIXME: INPUT should be a scalar image. template <typename DestValue, typename I> typename ch_value_type<I, DestValue>::ret lower_completion(const abstract::image_with_nbh& input) { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + typedef oln_type_of(I, point) point_type; /*------------------------------------------. @@ -55,7 +56,7 @@ typename ch_value_type<I, unsigned>::ret distance(input.size()); unsigned cur_dist = 1; - oln_type_of(I, fwd_piter) p(input.size()); + oln_type_of(I, piter) p(input.size()); for_all_p (p) { distance[p] = 0; Index: olena/oln/level/extrema_components.hh --- olena/oln/level/extrema_components.hh (revision 0) +++ olena/oln/level/extrema_components.hh (revision 0) @@ -0,0 +1,124 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_EXTREMA_COMPONENTS_HH +# define OLENA_MORPHO_EXTREMA_COMPONENTS_HH + +# include <map> +# include <queue> +# include <functional> + +# include "oln/level/level_components.hh" + +namespace oln { + + namespace level { + + namespace internal { + + /// Find the extrema level components of \a input, using \param + /// Cmp as comparison function. + template <typename DestValue, typename Cmp, typename I> + typename ch_value_type<I, DestValue>::ret + extrema_components(const abstract::image_with_nbh& input) + { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + Cmp cmp; + + // Compute level components. + typename ch_value_type<I, DestValue>::ret comps = + level_components<DestValue>(input); + std::set<DestValue> extrema; + std::set<DestValue> non_extrema; + + // Search extrema components. + oln_type_of(I, piter) p(input.size()); + for_all_p (p) + { + DestValue comp = comps[p]; + if (non_extrema.find(comp) == non_extrema.end ()) + { + // A new level is a (potential) extrema by default. + extrema.insert(comp); + + oln_type_of(I, niter) n(input); + for_all_n_of_p (n, p) + if (input.hold(n) && cmp(input[n], input[p])) + { + extrema.erase(comp); + non_extrema.insert(comp); + } + } + } + + // Re-label the extrema. label_map hold the assigned labels. + std::map<DestValue, DestValue> label_map; + { + DestValue cur_label = ntg_min_val(DestValue) + 1; + for (typename std::set<DestValue>::const_iterator i = + extrema.begin(); i != extrema.end(); ++i, ++cur_label) + label_map[*i] = cur_label; + } + typename ch_value_type<I, DestValue>::ret output (input.size()); + level::fill (output, ntg_min_val(DestValue)); + for_all_p (p) + { + DestValue comp = comps[p]; + if (label_map.find(comp) != label_map.end()) + output[p] = label_map[comp]; + } + return output; + } + + } // end of namespace oln::level::internal. + + + /// Find the minima level components of \a input. + template <typename DestValue, typename I> + typename ch_value_type<I, DestValue>::ret + minima_components(const abstract::image_with_nbh& input) + { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + return internal::extrema_components< DestValue, + std::less<DestValue> >(input); + } + + /// Find the maxima level components of \a input. + template <typename DestValue, typename I> + typename ch_value_type<I, DestValue>::ret + maxima_components(const abstract::image_with_nbh& input) + { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + return internal::extrema_components< DestValue, + std::greater<DestValue> >(input); + } + + } // end of namespace oln::level. + +} // end of namespace oln. + +#endif // ! OLENA_MORPHO_EXTREMA_COMPONENTS_HH Index: olena/oln/level/level_components.hh --- olena/oln/level/level_components.hh (revision 0) +++ olena/oln/level/level_components.hh (revision 0) @@ -0,0 +1,83 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_LEVEL_COMPONENTS_HH +# define OLENA_MORPHO_LEVEL_COMPONENTS_HH + +# include <queue> + +# include "oln/level/fill.hh" + +namespace oln { + + namespace level { + + /// Compute the level components of \a input. + template <typename DestValue, typename I> + typename ch_value_type<I, DestValue>::ret + level_components(const abstract::image_with_nbh& input) + { + mlc_is_a(I, abstract::scalar_valued_image)::ensure(); + + typename ch_value_type<I, DestValue>::ret labels(input.size()); + typename ch_value_type<I, bool>::ret processed(input.size()); + level::fill (processed, false); + + DestValue cur_label = ntg_min_val(DestValue); + + typedef oln_type_of(I, point) point_type; + std::queue<point_type> q; + + oln_type_of(I, piter) p(input.size()); + for_all_p (p) + if (!processed[p]) + { + labels[p] = cur_label; + q.push(p); + while (!q.empty()) + { + point_type s = q.front(); + q.pop(); + oln_type_of(I, niter) n(input); + for_all_n_of_p (n, s) + if (input.hold(n) && input[n] == input[s] && !processed[n]) + { + labels[n] = cur_label; + processed[n] = true; + q.push(n); + } + } + ++cur_label; + } + return labels; + } + + } // end of namespace oln::level + +} // end of namespace oln + +#endif // ! OLENA_MORPHO_LEVEL_COMPONENTS_HH

19 years, 7 months

proto-1.0 194: Add method call to image

by Nicolas Widynski

Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> * olena/oln/core/abstract/image_constness.hh: Add call to readwrite_image and read_only_image. * olena/oln/core/abstract/image_with_data.hh: Dispatch impl_call. * olena/oln/core/2d/array2d.hh: Real impl_call. Same thing must be done in 1d and 3d. * olena/oln/core/box.hh: Add call to box. * olena/oln/core/gen/internal/value_box.hh: Add call to value_box. 2d/array2d.hh | 12 +++++++++++ abstract/image_constness.hh | 47 ++++++++++++++++++++++++++++++++++++++++++++ abstract/image_with_data.hh | 18 ++++++++++++++++ box.hh | 30 +++++++++++++++++++++++++++- gen/internal/value_box.hh | 30 ++++++++++++++++++++++------ 5 files changed, 130 insertions(+), 7 deletions(-) Index: olena/oln/core/abstract/image_constness.hh --- olena/oln/core/abstract/image_constness.hh (revision 193) +++ olena/oln/core/abstract/image_constness.hh (working copy) @@ -66,6 +66,11 @@ struct readonly_image : public virtual image<E>, public internal::get_image_impl < readonly_image<E>, E > { + template <typename R, typename T> + R call(const oln_type_of(E, point)& p, + R (T::*method)() const) const; + + protected: /*! \brief Constructor (protected, empty). @@ -74,7 +79,35 @@ }; + namespace internal { + template <typename E> + struct set_image_impl < readonly_image<E>, E> : public virtual image_impl<E> + { + /// typedefs + typedef typename image_impl<E>::D D; + typedef oln_type_of(D, point) point_type; + typedef oln_type_of(D, value) value_type; + + template <typename R, typename T> + R impl_call(const oln_type_of(E, point)& p, + R (T::*method)() const) const + { + return this->delegate().call(p, method); + } + + + // extra code; default is 'do nothing': + + void impl_set_ante(const point_type&, const value_type&) {} + void impl_set_post(const point_type&, const value_type&) {} + }; + + } // end of namespace oln::abstract::internal + + + + /*! \class abstract::readonly_image<E> ** ** Class of images whose data are mutable (both readable and writable). @@ -125,6 +158,11 @@ // return *this; // } + template <typename T, typename A, typename V> + void call(const point_type& p, + void (T::*method)(A), + V arg); + protected: /*! \brief Constructor (protected, empty). @@ -155,6 +193,15 @@ this->exact().impl_set_post(p, v); } + template <typename T, typename A, typename V> + void impl_call(const point_type& p, + void (T::*method)(A), + V arg) + { + this->delegate().impl_call(p, method, arg); + } + + // extra code; default is 'do nothing': void impl_set_ante(const point_type&, const value_type&) {} Index: olena/oln/core/abstract/image_with_data.hh --- olena/oln/core/abstract/image_with_data.hh (revision 193) +++ olena/oln/core/abstract/image_with_data.hh (working copy) @@ -151,6 +151,24 @@ } + template <typename R, typename T> + R impl_call(const point_type& p, + R (T::*method)() const) const + { + return (this->data_->get(p).*method)(); + //this->data_->call(p, method); + } + + template <typename T, typename A, typename V> + void impl_call(const point_type& p, + void (T::*method)(A), + V arg) + { + // std::cout << "yes!" << std::endl; + this->data_->call(p, method, arg); + } + + /*! \brief Implement abstract::readwrite_image<E>::set(p, v) so ** write the value \a v at \a p in the current image. */ Index: olena/oln/core/2d/array2d.hh --- olena/oln/core/2d/array2d.hh (revision 193) +++ olena/oln/core/2d/array2d.hh (working copy) @@ -213,6 +213,18 @@ array_[p.row()][p.col()] = v; } + // FIXME: should be impl_ here; and call should be defined in storage_type + template <typename T2, typename A, typename V> + void call(const point2d& p, + void (T2::*method)(A), + V arg) + { + T& value = array_[p.row()][p.col()]; + (value.*method)(arg); + } + + + void impl_set_data(const T& v) { invariant_(); Index: olena/oln/core/box.hh --- olena/oln/core/box.hh (revision 193) +++ olena/oln/core/box.hh (working copy) @@ -267,7 +267,7 @@ } - /// Implementation of abstract::image<E>::get(p). + /// Implementation of abstract::image<E>::get(p) const. template <typename E> const oln_type_of(E, value) @@ -279,7 +279,35 @@ return this->exact().impl_get(p); } + /// Implementation of abstract::image<E>::call(p, method) const. + template <typename E> + template <typename R, typename T> + R + readonly_image<E>::call(const oln_type_of(E, point)& p, + R (T::*method)() const) const + { +# ifdef OLNTRACE + inc_ncalls("call", *this); +# endif // ! OLNTRACE + return this->exact().impl_call(p, method); + } + + /// Implementation of abstract::readwrite_image<E>::call(p, method, value). + template <typename E> + template <typename T, typename A, typename V> + void + readwrite_image<E>::call(const oln_type_of(E, point)& p, + void (T::*method)(A), + V arg) + { +# ifdef OLNTRACE + inc_ncalls("call", *this); +# endif // ! OLNTRACE + this->exact().impl_call(p, method, arg); + } + + /// Implementation of abstract::readwrite_image<E>::set(p, v). template <typename E> Index: olena/oln/core/gen/internal/value_box.hh --- olena/oln/core/gen/internal/value_box.hh (revision 193) +++ olena/oln/core/gen/internal/value_box.hh (working copy) @@ -157,12 +157,12 @@ ** FIXME:... */ - template <typename A, typename V> - value_box& set(void (I::*method)(A), const V& value) - { - ima_->set(p_, method, value); - return *this; - } +// template <typename A, typename V> +// value_box& set(void (I::*method)(A), const V& value) +// { +// ima_->set(p_, method, value); +// return *this; +// } @@ -201,7 +201,19 @@ return ima_->get(p_); } + template <typename R, typename T> + R call(R (T::*method)() const) const + { + return ima_->call(p_, method); + } + template <typename T, typename A, typename V> + void call(void (T::*method)(A), + V arg) + { + ima_->call(p_, method, arg); + } + /// Cpy ctor. value_box(const value_box& rhs) : @@ -340,7 +352,13 @@ // IDEA: provide op-> + template <typename R, typename T> + R call(R (T::*method)() const) const + { + return ima_->call(p_, method); + } + /// Cpy ctor. value_box(const value_box& rhs) :

19 years, 7 months

proto-1.0 195: Add lower completion

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 15 ++++ img/Makefile.am | 14 +++- img/squares-lc.pgm | 5 + oln/makefile.src | 1 oln/morpho/lower_completion.hh | 124 ++++++++++++++++++++++++++++++++++++ tests/morpho/tests/lower_completion | 25 +++++++ 6 files changed, 182 insertions(+), 2 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add lower completion. * oln/morpho/lower_completion.hh: New file * oln/makefile.src (OLN_DEP): Add morpho/lower_completion.hh. * olena/img/squares.pgm, olena/img/squares-lc.pgm: New images. * img/Makefile.am (SOURCE_IMGS): Add $(srcdir)/16x16.pbm, $(srcdir)/16x16.pbm.gz, $(srcdir)/16x16.pgm, $(srcdir)/16x16.pgm.gz, $(srcdir)/16x16.ppm, $(srcdir)/16x16.ppm.gz, $(srcdir)/marker.pbm, $(srcdir)/mask.pbm, $(srcdir)/object.pbm, $(srcdir)/squares-lc.pgm, $(srcdir)/squares.pgm: * tests/morpho/tests/lower_completion: New test. Index: olena/tests/morpho/tests/lower_completion --- olena/tests/morpho/tests/lower_completion (revision 0) +++ olena/tests/morpho/tests/lower_completion (revision 0) @@ -0,0 +1,25 @@ + // -*- C++ -*- +#include "data.hh" +#include "ntg/int.hh" +#include "oln/core/2d/image2d.hh" +#include "oln/core/gen/image_with_nbh.hh" +#include "oln/io/read_image.hh" +#include "oln/io/write_image.hh" +#include "oln/morpho/lower_completion.hh" +#include "oln/ops/cmp.hh" + +using namespace oln; + +bool check() +{ + image2d<ntg::int_u8> raw_input; + raw_input = io::read(rdata("squares.pgm")); + + typedef image_with_nbh<image2d<ntg::int_u8>, neighborhood2d> image_type; + image_type input = join(raw_input, neighb_c4()); + image_type output = morpho::lower_completion<ntg::int_u8>(input); + + image2d<ntg::int_u8> ref_output; + ref_output = io::read(rdata("squares-lc.pgm")); + return !(output == ref_output); +} Index: olena/oln/makefile.src --- olena/oln/makefile.src (revision 194) +++ olena/oln/makefile.src (working copy) @@ -160,6 +160,7 @@ morpho/erosion.hh \ morpho/geodesic_dilation.hh \ morpho/geodesic_erosion.hh \ + morpho/lower_completion.hh \ morpho/opening.hh \ morpho/reconstruction_by_dilation.hh \ morpho/reconstruction_by_erosion.hh \ Index: olena/oln/morpho/lower_completion.hh --- olena/oln/morpho/lower_completion.hh (revision 0) +++ olena/oln/morpho/lower_completion.hh (revision 0) @@ -0,0 +1,124 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_LOWER_COMPLETION_HH +# define OLENA_MORPHO_LOWER_COMPLETION_HH + +# include <queue> + +# include "oln/level/fill.hh" + +namespace oln { + + namespace morpho { + + // FIXME: INPUT should be a scalar image. + template <typename DestValue, typename I> + typename ch_value_type<I, DestValue>::ret + lower_completion(const abstract::image_with_nbh& input) + { + typedef oln_type_of(I, point) point_type; + + /*------------------------------------------. + | Distance map to the closest lower point. | + `------------------------------------------*/ + + typedef std::queue<point_type> queue_type; + queue_type q; + typename ch_value_type<I, bool>::ret processed(input.size()); + level::fill (processed, false); + + typename ch_value_type<I, unsigned>::ret distance(input.size()); + unsigned cur_dist = 1; + + oln_type_of(I, fwd_piter) p(input.size()); + for_all_p (p) + { + distance[p] = 0; + oln_type_of(I, niter) n(input); + for_all_n_of_p (n, p) + if (input.hold(n) && input[n] < input[p]) + { + q.push(p); + processed[p] = true; + } + } + + typedef oln_pt_type_of(point_type, grid) grid_type; + typedef oln_grd_type_of(grid_type, dimvalue) dimvalue_type; + const unsigned dim = dimvalue_type::val; + // Fictitious point, used as a separator between ranges of + // points in the queue. + point_type fictitious; + for (unsigned i = 0; i < dim; ++i) + fictitious.nth (i) = -1; + q.push(fictitious); + + while (!q.empty()) + { + point_type p = q.front(); + q.pop(); + if (p == fictitious) + { + if (!q.empty()) + { + q.push(fictitious); + ++cur_dist; + } + } + else + { + distance[p] = cur_dist; + oln_type_of(I, niter) n(input); + for_all_n_of_p (n, p) + if (input.hold(n) && input[n] == input[p] && !processed[n]) + { + q.push(n); + processed[n] = true; + } + } + } + + /*-------------------. + | Lower completion. | + `-------------------*/ + + typename ch_value_type<I, DestValue>::ret output(input.size()); + for_all_p (p) + if (distance[p] == ntg_zero_val(DestValue)) + output[p] = cur_dist * input[p].value(); + else + output[p] = cur_dist * input[p].value() + distance[p].value() - 1; + + return output; + } + + } // end of namespace oln::morpho + +} // end of namespace oln + +#endif // ! OLENA_MORPHO_LOWER_COMPLETION_HH Index: olena/img/Makefile.am --- olena/img/Makefile.am (revision 194) +++ olena/img/Makefile.am (working copy) @@ -1,4 +1,10 @@ SOURCE_IMGS = \ + $(srcdir)/16x16.pbm \ + $(srcdir)/16x16.pbm.gz \ + $(srcdir)/16x16.pgm \ + $(srcdir)/16x16.pgm.gz \ + $(srcdir)/16x16.ppm \ + $(srcdir)/16x16.ppm.gz \ $(srcdir)/chien.pbm \ $(srcdir)/chien.pbm.gz \ $(srcdir)/lena.pbm \ @@ -6,7 +12,11 @@ $(srcdir)/lena.pgm \ $(srcdir)/lena.pgm.gz \ $(srcdir)/lena.ppm \ - $(srcdir)/lena.ppm.gz + $(srcdir)/lena.ppm.gz \ + $(srcdir)/marker.pbm \ + $(srcdir)/mask.pbm \ + $(srcdir)/object.pbm \ + $(srcdir)/squares-lc.pgm \ + $(srcdir)/squares.pgm dist_pkgdata_DATA = $(SOURCE_IMGS) -

19 years, 7 months

proto-1.0 193: Update oln/makefile.src

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/makefile.src: Update. makefile.src | 25 +++++++++++++++++++------ 1 files changed, 19 insertions(+), 6 deletions(-) Index: oln/makefile.src --- oln/makefile.src (revision 192) +++ oln/makefile.src (working copy) @@ -11,6 +11,10 @@ basics3d.hh \ basics.hh \ \ + canvas/backandforth.hh \ + canvas/io.hh \ + canvas/reconstruction.hh \ + \ config/pconf.hh \ config/system.hh \ \ @@ -41,6 +45,7 @@ core/2d/qiter2d.hh \ core/2d/size2d.hh \ core/2d/window2d.hh \ + \ core/3d/array3d.hh \ core/3d/bkd_piter3d.hh \ core/3d/dpoint3d.hh \ @@ -133,10 +138,14 @@ funobj/logic.hh \ \ io/gz_stream.hh \ - io/read_image_2d_pnm.hh \ + io/read_image_pnm_2d.hh \ + io/read_image_pnm_decl.hh \ + io/read_image_pnm.hh \ io/read_image.hh \ io/utils.hh \ - io/write_image_2d_pnm.hh \ + io/write_image_pnm_2d.hh \ + io/write_image_pnm_decl.hh \ + io/write_image_pnm.hh \ io/write_image.hh \ \ level/arith.hh \ @@ -144,10 +153,6 @@ level/fill.hh \ level/logic.hh \ \ - ops/arith.hh \ - ops/cmp.hh \ - ops/logic.hh \ - \ morpho/closing.hh \ morpho/dilation.hh \ morpho/elementary_dilation.hh \ @@ -156,9 +161,17 @@ morpho/geodesic_dilation.hh \ morpho/geodesic_erosion.hh \ morpho/opening.hh \ + morpho/reconstruction_by_dilation.hh \ + morpho/reconstruction_by_erosion.hh \ + morpho/reconstruction_selfdual.hh \ + morpho/reconstruction.hh \ morpho/stat.hh \ morpho/tags.hh \ \ + ops/arith.hh \ + ops/cmp.hh \ + ops/logic.hh \ + \ utils/buffer.hh \ utils/clone.hh \ utils/invert.hh \

19 years, 7 months

proto-1.0 192: Remove arith from configure.ac

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Remove oln/arith from the OLN collection. configure.ac | 1 - 1 files changed, 1 deletion(-) Index: configure.ac --- configure.ac (revision 191) +++ configure.ac (working copy) @@ -100,7 +100,6 @@ # OLN_TESTS defined in oln-local.m4 OLN_TESTS([sanity]) - OLN_TESTS([arith]) OLN_TESTS([convert]) OLN_TESTS([core]) OLN_TESTS([io])

19 years, 7 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches May 2005