Index: ChangeLog
from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr>
* oln/core/abstract/image.hh: patch for adding method call.
* oln/core/abstract/image_constness.hh: add method call for
readwrite images.
* oln/core/abstract/image_with_data.hh: likewise.
* oln/core/2d/array2d.hh: likewise.
* oln/core/box.hh: likewise.
* oln/makefile.src: add files.
appli/astro/clean.hh | 420 +++++++++++++++++++++++++++++++++++++++
canvas/maxtree.hh | 346 ++++++++++++++++++++++++++++++++
canvas/tree.hh | 215 +++++++++++++++++++
core/2d/array2d.hh | 2
core/abstract/image.hh | 2
core/abstract/image_constness.hh | 16 +
core/abstract/image_with_data.hh | 2
core/box.hh | 17 +
makefile.src | 4
morpho/clean_astro_images.hh | 269 ------------------------
morpho/maxtree.hh | 313 -----------------------------
morpho/tree.hh | 194 ------------------
12 files changed, 1016 insertions(+), 784 deletions(-)
Index: oln/core/abstract/image_constness.hh
--- oln/core/abstract/image_constness.hh (revision 209)
+++ oln/core/abstract/image_constness.hh (working copy)
@@ -34,7 +34,7 @@
// image
//
// ^
-// |
+// |
// ---------------
// | |
//
@@ -158,11 +158,19 @@
// return *this;
// }
+ typedef internal::get_image_impl < readwrite_image<E>, E > super_rw_impl;
+ typedef internal::get_image_impl < image<E>, E > super_impl;
+
template <typename T, typename A, typename V>
void call(const point_type& p,
void (T::*method)(A),
V arg);
+ template <typename R, typename T>
+ R call(const oln_type_of(E, point)& p,
+ R (T::*method)() const) const;
+
+
protected:
/*! \brief Constructor (protected, empty).
@@ -201,6 +209,12 @@
this->delegate().impl_call(p, method, arg);
}
+ 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':
Index: oln/core/abstract/image.hh
--- oln/core/abstract/image.hh (revision 209)
+++ oln/core/abstract/image.hh (working copy)
@@ -371,7 +371,6 @@
const value_type get(const point_type& p) const; // impl is in box.hh
-
// FIXME: patch!
void resize_border(size_t new_border, bool copy_border = false) const
@@ -414,7 +413,6 @@
typedef oln_type_of(D, point) point_type;
typedef oln_type_of(D, value) value_type;
-
// delegations are "template methods" (Cf. the GOF's book)
const size_type& impl_size() const
Index: oln/core/abstract/image_with_data.hh
--- oln/core/abstract/image_with_data.hh (revision 209)
+++ oln/core/abstract/image_with_data.hh (working copy)
@@ -156,7 +156,6 @@
R (T::*method)() const) const
{
return (this->data_->get(p).*method)();
- //this->data_->call(p, method);
}
template <typename T, typename A, typename V>
@@ -164,7 +163,6 @@
void (T::*method)(A),
V arg)
{
- // std::cout << "yes!" << std::endl;
this->data_->call(p, method, arg);
}
Index: oln/core/2d/array2d.hh
--- oln/core/2d/array2d.hh (revision 209)
+++ oln/core/2d/array2d.hh (working copy)
@@ -223,8 +223,6 @@
(value.*method)(arg);
}
-
-
void impl_set_data(const T& v)
{
invariant_();
Index: oln/core/box.hh
--- oln/core/box.hh (revision 209)
+++ oln/core/box.hh (working copy)
@@ -279,8 +279,9 @@
return this->exact().impl_get(p);
}
- /// Implementation of abstract::image<E>::call(p, method) const.
+ /// Implementation of abstract::readonly_image<E>::call(p, method) const.
+
template <typename E>
template <typename R, typename T>
R
@@ -293,6 +294,20 @@
return this->exact().impl_call(p, method);
}
+ /// Implementation of abstract::readwrite_image<E>::call(p, method) const.
+
+ template <typename E>
+ template <typename R, typename T>
+ R
+ readwrite_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>
Index: oln/makefile.src
--- oln/makefile.src (revision 209)
+++ oln/makefile.src (working copy)
@@ -6,6 +6,8 @@
OLN_DEP = \
all.hh \
\
+ appli/astro/clean.hh \
+ \
basics1d.hh \
basics2d.hh \
basics3d.hh \
@@ -14,6 +16,8 @@
canvas/backandforth.hh \
canvas/io.hh \
canvas/reconstruction.hh \
+ canvas/tree.hh \
+ canvas/maxtree.hh \
\
config/pconf.hh \
config/system.hh \
Index: oln/morpho/tree.hh
--- oln/morpho/tree.hh (revision 209)
+++ oln/morpho/tree.hh (working copy)
@@ -1,194 +0,0 @@
-// 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_CANVAS_TREE_HH
-# define OLENA_MORPHO_CANVAS_TREE_HH
-
-# include <mlc/any.hh>
-
-# include <oln/core/box.hh>
-# include <oln/utils/record.hh>
-# include <oln/core/abstract/image_entry.hh>
-# include <oln/core/ch_value_type.hh>
-# include <oln/level/fill.hh>
-# include <oln/basics.hh>
-
-# include <vector>
-
-
-namespace oln {
-
- namespace morpho {
-
- namespace canvas {
-
-
- template <typename I, typename E>
- struct tree : public mlc::any<E>
- {
- typedef oln_type_of(I, point) point_type;
-
- // Attribute.
- box<const I> input;
- oln_type_of(I, concrete) output;
- std::vector<std::vector<point_type> > S;
- point_type root_point;
-
- void run_compute_tree()
- {
- first_pass();
- compute_tree();
- }
-
- void run_compute_output()
- {
- init_processing();
- processing();
- }
-
- // Concrete method.
- void first_pass()
- {
- oln_type_of(I, niter) n(input);
-
- // init
- compute_S();
- set_is_processed_to_false();
- set_default_output();
-
- typename std::vector<std::vector<point_type> >::reverse_iterator i;
- typename std::vector<point_type>::const_iterator j;
- for (i = S.rbegin(); i != S.rend(); i++)
- {
- for (j = i->begin(); j != i->end(); j++)
- {
- make_set(*j);
- for_all_n_of_p (n, *j)
- if (input.hold(n) and is_processed(n))
- do_union(n, *j);
- set_is_processed(*j);
- }
- }
- root_point = *j;
- }
-
- void do_union(const point_type& n, const point_type& p)
- {
- point_type r = find_root(n);
- if (r != p)
- set_father(r, p);
- }
-
- // Abstract methods.
- // ---------------------------
-
- // init
-
- void init_processing()
- {
- this->exact().impl_init_processing();
- }
-
- void compute_S()
- {
- this->exact().impl_compute_S();
- }
- void set_default_output()
- {
- this->exact().impl_set_default_output();
- }
-
- // about is_processed
- void set_is_processed_to_false()
- {
- this->exact().impl_set_is_processed_to_false();
- }
- void set_is_processed(const point_type& p)
- {
- this->exact().impl_set_is_processed(p);
- }
- bool is_processed(const point_type& n) const
- {
- return this->exact().impl_is_processed(n);
- }
-
- const point_type get_father(const point_type& p) const
- {
- return this->exact().impl_get_father(p);
- }
-
- // core
-
- void compute_tree()
- {
- this->exact().impl_compute_tree();
- }
-
- void processing()
- {
- this->exact().impl_processing();
- }
-
- void make_set(const point_type& p)
- {
- this->exact().impl_make_set(p);
- }
- point_type find_root(const point_type& x)
- {
- return this->exact().impl_find_root(x);
- }
- void set_father(const point_type& r, const point_type& p)
- {
- this->exact().impl_set_father(r, p);
- }
-
- protected:
-
- // Ctor.
- tree(const abstract::image_with_nbh<I>& input) :
- input(input),
- S()
- {
- }
-
- // Check for impls..
- ~tree()
- {
- // FIXME... mlc_check_method_impl(E, void, init, , );
- }
-
- };
-
-
- } // end of namespace oln::morpho::canvas
-
- } // end of namespace oln::morpho
-
-} // end of namespace oln
-
-
-#endif // ! OLENA_MORPHO_CANVAS_TREE_HH
Index: oln/morpho/maxtree.hh
--- oln/morpho/maxtree.hh (revision 209)
+++ oln/morpho/maxtree.hh (working copy)
@@ -1,313 +0,0 @@
-// 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_MAX_TREE_HH
-# define OLENA_MORPHO_MAX_TREE_HH
-
-# include <mlc/any.hh>
-
-# include <oln/core/box.hh>
-# include <oln/utils/record.hh>
-# include <oln/core/abstract/image_entry.hh>
-# include <oln/core/ch_value_type.hh>
-# include <oln/level/fill.hh>
-
-# include <oln/morpho/tree.hh>
-# include <oln/basics.hh>
-
-# include <cassert>
-# include <vector>
-# include <functional>
-# include <set>
-
-
-namespace oln {
-
- namespace morpho {
-
- namespace misc {
-
- struct pair_cmp
- {
- template<typename L, typename P>
- bool operator()(const std::pair<L,P>& lhs,
- const std::pair<L,P>& rhs) const
- {
- return lhs.first < rhs.first
- or (lhs.first == rhs.first
- and lhs.second.fwd_less(rhs.second));
- }
- };
-
- template<typename I, typename II, typename O, typename V>
- void set_children(abstract::image_with_nbh<I>& marked,
- const abstract::image_with_nbh<II>& children,
- abstract::image_with_nbh<O>& out,
- const oln_type_of(I, point)& p,
- const V v)
- {
- typedef oln_type_of(I, point) point_type;
- std::vector<point_type> f = children[p].value();
- typename std::vector<point_type>::const_iterator pt;
- for (pt = f.begin(); pt != f.end(); pt++)
- {
- out[*pt] = v;
- marked[*pt] = true;
- set_children(marked, children, out, *pt, v);
- }
- }
-
-
- template <class I>
- std::vector<std::vector<oln_type_of(I, point)> >
- sort(const abstract::image_with_nbh<I>& input)
- {
- typedef oln_type_of(I, point) point_type;
- std::vector<std::vector<point_type> > S(256);
- oln_type_of(I, fwd_piter) p(input.size());
-
-#ifdef DEBUG
- typedef std::pair<oln_type_of(I, value), point_type> pair_t;
- std::set<pair_t,pair_cmp> sc;
-#endif // ! DEBUG
-
- for_all_p (p)
- {
- S[input[p]].push_back(p);
-#ifdef DEBUG
- sc.insert(pair_t(input[p], p));
-#endif // ! DEBUG
- }
-
-#ifdef DEBUG
- {
- unsigned l;
-
- typename std::set<pair_t,pair_cmp>::const_iterator i = sc.begin();
- typename std::vector<std::vector<point_type> >::const_iterator v;
-
- for (l = 0, v = S.begin();
- v != S.end(); v++, ++l)
- {
- for (typename std::vector<point_type>::const_iterator p = v->begin();
- p != v->end(); p++, ++i)
- {
- assert(input[*p] == l);
- assert(i->first == l);
- assert(i->second == *p);
- }
- }
- }
-#endif // ! DEBUG
-
- return S;
- }
-
- } // end of oln::morpho::misc
-
-
- template <typename I, typename E>
- struct max_tree : public canvas::tree<I, E>
- {
- typedef canvas::tree<I, E> super_type;
- typedef oln_type_of(I, point) point_type;
-
- // Attributes.
- oln_ch_concrete_type(I, bool) is_proc;
- oln_ch_concrete_type(I, bool) marked;
- oln_ch_concrete_type(I, bool) is_deleted;
- oln_ch_concrete_type(I, point_type) father;
- oln_ch_concrete_type(I, std::vector<point_type>) children;
- std::vector<std::vector<point_type> > v_root_point;
- oln_type_of(I, concrete) new_value;
-
- void impl_compute_S()
- {
- this->S = misc::sort(this->input);
- }
-
- bool condition_add_root_point(const point_type& f, const point_type& p)
- {
- if (this->input[f] == this->input[p])
- return false;
- return true;
- }
-
- void left_hand_walk(const point_type& p)
- {
- if (condition_add_root_point(p, father[p]))
- v_root_point[this->input[p]].push_back(p);
-
- std::vector<point_type> f = children[p].value();
- typename std::vector<point_type>::const_iterator pt;
- for (pt = f.begin(); pt != f.end(); pt++)
- {
- left_hand_walk(*pt);
- }
- }
-
- void impl_compute_tree()
- {
- v_root_point[this->input[this->root_point]].push_back(this->root_point);
- left_hand_walk(this->root_point);
- }
-
- void impl_set_default_output()
- {
- }
-
- void impl_set_is_processed_to_false()
- {
- oln_type_of(I, fwd_piter) p(is_proc.size());
- for_all_p (p)
- is_proc[p] = false;
- }
-
- void impl_set_is_processed(const point_type& p)
- {
- is_proc[p] = true;
- }
-
- bool impl_is_processed(const point_type& n) const
- {
- return is_proc[n];
- }
-
- void init_aux_data(const point_type& p)
- {
- this->exact().impl_init_aux_data(p);
- }
-
- const point_type impl_get_father(const point_type& p) const
- {
- return father[p].value();
- }
-
- void merge_aux_data(const point_type& r , const point_type& p)
- {
- children[p].call(&std::vector<point_type>::push_back, r);
- this->exact().impl_merge_aux_data(r,p);
- }
-
- void impl_make_set(const point_type& p)
- {
- father[p] = p;
- init_aux_data(p);
- }
-
- point_type impl_find_root(const point_type& x)
- {
- if (is_root(x))
- return x;
- return find_root(father[x]);
- }
-
- bool is_root(const point_type& x) const
- {
- return father[x] == x;
- }
-
- void impl_set_father(const point_type& r, const point_type& p)
- {
- father[r] = p;
- merge_aux_data(r,p);
- }
-
- void eligible_component(const point_type& p)
- {
- this->exact().impl_eligible_component(p);
- }
-
- void compute_image_is_deleted()
- {
- for (int i = 0; i <= 255 ;i++)
- for (typename std::vector<point_type>::const_iterator p = v_root_point[i].begin();
- p != v_root_point[i].end(); p++)
- eligible_component(*p);
- }
-
- void impl_init_processing()
- {
- level::fill(this->marked, false);
- level::fill(this->is_deleted, false);
- this->exact().impl_init_aux_processing();
- }
-
- void impl_processing()
- {
- compute_image_is_deleted();
-
- oln_type_of(I, fwd_piter) p(this->input.size());
- for_all_p (p)
- {
- if (is_deleted[p])
- this->output[p] = this->new_value[p];
- else
- this->output[p] = this->input[p];
- }
- }
-
- protected:
-
- // Ctor.
- // FIXME : will be changed
- max_tree(const abstract::image_with_nbh<I>& input) :
- super_type(input)
- {
- oln_ch_concrete_type(I, bool) tmp1(input.size());
- is_proc = tmp1;
-
- oln_ch_concrete_type(I, point_type) tmp2(input.size());
- father = tmp2;
-
- oln_ch_concrete_type(I, std::vector<point_type>) tmp3(input.size());
- children = tmp3;
-
- oln_type_of(I, concrete) tmp4(input.size());
- this->output = tmp4;
-
- std::vector<std::vector<point_type> > tmp5(256);
- v_root_point = tmp5;
-
- oln_ch_concrete_type(I, bool) tmp6(input.size());
- marked = tmp6;
-
- oln_ch_concrete_type(I, bool) tmp7(input.size());
- is_deleted = tmp7;
-
- oln_type_of(I, concrete) tmp8(input.size());
- new_value = tmp8;
- }
-
- };
-
- } // end of namespace oln::morpho
-
-} // end of namespace oln
-
-
-#endif // ! OLENA_MORPHO_MAX_TREE_HH
Index: oln/morpho/clean_astro_images.hh
--- oln/morpho/clean_astro_images.hh (revision 209)
+++ oln/morpho/clean_astro_images.hh (working copy)
@@ -1,269 +0,0 @@
-// 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_CLEAN_ASTRO_IMAGES_HH
-# define OLENA_MORPHO_CLEAN_ASTRO_IMAGES_HH
-
-# include <mlc/any.hh>
-
-# include <oln/core/box.hh>
-# include <oln/utils/record.hh>
-# include <oln/core/abstract/image_entry.hh>
-# include <oln/core/ch_value_type.hh>
-# include <oln/level/fill.hh>
-
-# include <oln/morpho/maxtree.hh>
-# include <oln/basics.hh>
-
-# include <vector>
-
-
-namespace oln {
-
- namespace morpho {
-
- namespace misc {
-
- template<typename I>
- bool have_the_center_point(const abstract::image_with_nbh<I>& children,
- const oln_type_of(I, point)& p,
- int row,
- int col)
- {
- typedef oln_type_of(I, point) point_type;
- if (((p.row() == (row / 2)) or
- (p.row() == (row - 1) / 2) or
- (p.row() == (row + 1) / 2))
- and ((p.col() == (col / 2)) or
- (p.col() == (col - 1) / 2) or
- (p.col() == (col + 1) / 2)))
- return true;
- std::vector<point_type> f = children[p].value();
- typename std::vector<point_type>::const_iterator pt;
- for (pt = f.begin(); pt != f.end(); pt++)
- {
- return have_the_center_point(children, *pt, row, col);
- }
- return false;
- }
-
-
- template <typename I, typename II>
- const oln_type_of(I, value) min_nbh(const abstract::image_with_nbh<I>& input,
- const abstract::image_with_nbh<II>& children,
- const oln_type_of(II, point)& p)
- {
- typedef oln_type_of(I, point) point_type;
- std::vector<point_type> f = children[p].value();
- oln_type_of(I, niter) n(input.exact());
- oln_type_of(I, value) min;
- typename std::vector<point_type>::const_iterator pt;
- for (pt = f.begin(); pt != f.end(); pt++)
- {
- min = input[*pt].value();
- for_all_n_of_p (n, *pt)
- {
- min = ntg::min(min, input[n].value());
- }
-
- return ntg::min(min, min_nbh(input, children, *pt));
- }
- return input[p];
- }
-
- template <typename I>
- struct find_box
- {
- typedef oln_type_of(I, point) point_type;
-
- find_box(const point_type& p) { row_min_ = p.row(); row_max_ = p.row(); col_min_ = p.col(); col_max_ = p.col(); }
- int row_min_, row_max_, col_min_, col_max_;
-
-
- void box(const abstract::image_with_nbh<I>& children,
- const oln_type_of(I, point)& p)
- {
- std::vector<point_type> f = children[p].value();
- typename std::vector<point_type>::const_iterator pt;
- for (pt = f.begin(); pt != f.end(); pt++)
- {
- if (row_min_ > pt->row())
- row_min_ = pt->row();
- if (row_max_ < pt->row())
- row_max_ = pt->row();
- if (col_min_ > pt->col())
- col_min_ = pt->col();
- if (col_max_ < pt->col())
- col_max_ = pt->col();
- box(children, *pt);
- }
- }
- };
-
-
- template <typename I>
- bool is_a_circle(const abstract::image_with_nbh<I>& children,
- const oln_type_of(I, point)& p,
- float c_a)
- {
- find_box<I> fb(p);
- fb.box(children,p);
- int w = fb.col_max_ - fb.col_min_ + 1;
- int h = fb.row_max_ - fb.row_min_ + 1;
- float theoric_area = 3.14f * ((h + w) / 4.0) * ((h + w) / 4.0);
-
-#ifdef DEBUG
- std::cout << "POINT : " << p << std::endl;
- std::cout << "col_min : " << fb.col_min_ << std::endl;
- std::cout << "col_max : " << fb.col_max_ << std::endl;
- std::cout << "row_min : " << fb.row_min_ << std::endl;
- std::cout << "row_max : " << fb.row_max_ << std::endl;
- std::cout << "theoric area : " << theoric_area << std::endl;
- std::cout << "computed area : " << c_a << std::endl;
- std::cout << "t - sqrt(c) : " << theoric_area - sqrt(c_a) << std::endl;
- std::cout << "t + sqrt(c) : " << theoric_area + sqrt(c_a) << std::endl;
- std::cout << "w : " << w << std::endl << "h : " << h << std::endl;
-#endif // ! DEBUG
- if (((theoric_area - sqrt(c_a) < c_a) &&
- (theoric_area + sqrt(c_a) > c_a)) &&
- (c_a > (0.9 * 0.75 * w * h)) &&
- (c_a < (1.1 * 0.75 * w * h)))
- return true;
- return false;
- }
-
- } // end of oln::morpho::misc
-
-
- template <typename I>
- struct clean_astro : public max_tree<I, clean_astro<I> >
- {
- typedef max_tree<I, clean_astro<I> > super_type;
- typedef oln_type_of(I, point) point_type;
-
- // Attributes.
- oln_ch_concrete_type(I, unsigned) area;
- oln_type_of(I, value) level_;
- unsigned area_;
-
-
- // specific methods
-
- void set_area(unsigned nb)
- {
- area_ = nb;
- }
-
- void set_level(unsigned nb)
- {
- level_ = nb;
- }
-
- void remove_star(const point_type& p)
- {
- this->is_deleted[p] = true;
- misc::set_children(this->marked, this->children, this->is_deleted, p, true);
- this->new_value[p] = this->input[this->father[p]].value();
- misc::set_children(this->marked,
- this->children, this->new_value, p, this->input[this->father[p]].value());
- }
-
- void remove_little_surface(const point_type& p)
- {
- this->is_deleted[p] = true;
- misc::set_children(this->marked, this->children, this->is_deleted, p, true);
- this->new_value[p] = this->input[this->father[p]].value();
- misc::set_children(this->marked,
- this->children, this->new_value, p, this->input[this->father[p]].value());
- }
-
- bool is_a_star(const point_type& p)
- {
- if (not (this->marked[p]))
- {
- if (this->area[p] >= area_)
- if (not (misc::have_the_center_point(this->children, p, this->input.size().nrows(),
- this->input.size().ncols())))
- if (misc::is_a_circle(this->children, p, this->area[p]))
- return true;
- }
- return false;
- }
-
- bool is_a_little_surface(const point_type& p)
- {
- if (this->area[p] <= 20 && this->input[p] < 150)
- return true;
- return false;
- }
-
- // fill the holes
-
- void impl_init_aux_data(const point_type& p)
- {
- this->area[p] = 1;
- }
-
- void impl_merge_aux_data(const point_type& r , const point_type& p)
- {
- this->area[p] = this->area[r].value() + this->area[p].value();
- }
-
- void impl_eligible_component(const point_type& p)
- {
- if (this->input[p].value() > this->level_)
- {
- // if (is_a_little_surface(p))
- // remove_little_surface(p);
- if (is_a_star(p))
- remove_star(p);
- }
- }
-
- void impl_init_aux_processing()
- {
- }
-
- // Ctor.
- clean_astro(const abstract::image_with_nbh<I>& input) :
- super_type(input)
- {
- oln_ch_concrete_type(I, unsigned) tmp(input.size());
- this->area = tmp;
-
- this->area_ = 0;
- this->level_ = 0;
- }
-
- };
-
- } // end of namespace oln::morpho
-
-} // end of namespace oln
-
-
-#endif // ! OLENA_MORPHO_CLEAN_ASTRO_IMAGES_HH
Index: oln/appli/astro/clean.hh
--- oln/appli/astro/clean.hh (revision 0)
+++ oln/appli/astro/clean.hh (revision 0)
@@ -0,0 +1,420 @@
+// 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_APPLI_ASTRO_CLEAN_HH
+# define OLENA_APPLI_ASTRO_CLEAN_HH
+
+# include <mlc/any.hh>
+
+# include <oln/core/box.hh>
+# include <oln/utils/record.hh>
+# include <oln/core/abstract/image_entry.hh>
+# include <oln/core/ch_value_type.hh>
+# include <oln/level/fill.hh>
+
+# include <oln/canvas/maxtree.hh>
+# include <oln/basics.hh>
+
+# include <vector>
+
+
+
+#define get_aux_data(IT1ER, AT1T1R) this->aux_data_[IT1ER].call(&T1::AT1T1R##_get)
+#define set_aux_data(IT1ER, AT1T1R, VAL) this->aux_data_[IT1ER].call(&T1::AT1T1R##_set, VAL)
+
+
+
+namespace oln {
+
+ namespace appli {
+
+ namespace astro {
+
+ namespace misc {
+
+ template<typename I>
+ bool have_the_center_point(const abstract::image_with_nbh<I>& children,
+ const oln_type_of(I, point)& p,
+ int row,
+ int col)
+ {
+ typedef oln_type_of(I, point) point_type;
+ if (((p.row() == (row / 2)) or
+ (p.row() == (row - 1) / 2) or
+ (p.row() == (row + 1) / 2))
+ and ((p.col() == (col / 2)) or
+ (p.col() == (col - 1) / 2) or
+ (p.col() == (col + 1) / 2)))
+ return true;
+ std::vector<point_type> f = children[p].value();
+ typename std::vector<point_type>::const_iterator pt;
+
+ bool ret = false;
+ for (pt = f.begin(); pt != f.end(); pt++)
+ ret |= have_the_center_point(children, *pt, row, col);
+ return ret;
+ }
+
+
+ template <typename I, typename II>
+ const oln_type_of(I, value) min_nbh(const abstract::image_with_nbh<I>& input,
+ const abstract::image_with_nbh<II>& children,
+ const oln_type_of(II, point)& p)
+ {
+ typedef oln_type_of(I, point) point_type;
+ std::vector<point_type> f = children[p].value();
+ oln_type_of(I, niter) n(input.exact());
+ oln_type_of(I, value) min;
+ typename std::vector<point_type>::const_iterator pt;
+ for (pt = f.begin(); pt != f.end(); pt++)
+ {
+ min = input[*pt].value();
+ for_all_n_of_p (n, *pt)
+ {
+ min = ntg::min(min, input[n].value());
+ }
+
+ return ntg::min(min, min_nbh(input, children, *pt));
+ }
+ return input[p];
+ }
+
+ template <typename I>
+ struct is_a_circle_recu
+ {
+ typedef oln_type_of(I, point) point_type;
+
+ is_a_circle_recu(const point_type& p) { row_min_ = p.row(); row_max_ = p.row(); col_min_ = p.col(); col_max_ = p.col(); }
+ int row_min_, row_max_, col_min_, col_max_;
+
+
+ void box(const abstract::image_with_nbh<I>& children,
+ const oln_type_of(I, point)& p)
+ {
+ std::vector<point_type> f = children[p].value();
+ typename std::vector<point_type>::const_iterator pt;
+ for (pt = f.begin(); pt != f.end(); pt++)
+ {
+ if (row_min_ > pt->row())
+ row_min_ = pt->row();
+ if (row_max_ < pt->row())
+ row_max_ = pt->row();
+ if (col_min_ > pt->col())
+ col_min_ = pt->col();
+ if (col_max_ < pt->col())
+ col_max_ = pt->col();
+ box(children, *pt);
+ }
+ }
+ };
+
+ // by checking the geometry of the image
+ template <typename I>
+ bool is_a_circle(const abstract::image_with_nbh<I>& children,
+ const oln_type_of(I, point)& p,
+ float c_a)
+ {
+ is_a_circle_recu<I> fb(p);
+ fb.box(children,p);
+ int w = fb.col_max_ - fb.col_min_ + 1;
+ int h = fb.row_max_ - fb.row_min_ + 1;
+ float theoretic_area = 3.14f * ((h + w) / 4.0) * ((h + w) / 4.0);
+
+#ifdef DEBUG
+ std::cout << "POINT1 : " << p << std::endl;
+ std::cout << "col_min : " << fb.col_min_ << std::endl;
+ std::cout << "col_max : " << fb.col_max_ << std::endl;
+ std::cout << "row_min : " << fb.row_min_ << std::endl;
+ std::cout << "row_max : " << fb.row_max_ << std::endl;
+ std::cout << "theoretic area : " << theoretic_area << std::endl;
+ std::cout << "computed area : " << c_a << std::endl;
+ std::cout << "t - sqrt(c) : " << theoretic_area - sqrt(c_a) << std::endl;
+ std::cout << "t + sqrt(c) : " << theoretic_area + sqrt(c_a) << std::endl;
+ std::cout << "w : " << w << std::endl << "h : " << h << std::endl;
+#endif // ! DEBUG
+ // 0.75
+ if (((theoretic_area - sqrt(c_a) < c_a) &&
+ (theoretic_area + sqrt(c_a) > c_a)) &&
+ (c_a > (0.9 * 0.9 * w * h)) &&
+ (c_a < (1.1 * 0.9 * w * h)))
+ return true;
+ return false;
+ }
+
+ // by checking the geometry of the component.
+// void is_a_rectangle(const abstract::image_with_nbh<I>& children,
+// const oln_type_of(I, point)& p,
+// float min, float max)
+// {
+
+
+
+// }
+
+
+ } // end of oln::appli::astro::misc
+
+ struct my_type
+ {
+ my_type() { area_ = 0; height_ = 0; area2_= 0; int_volume_ = 0; ext_volume_ = 0;}
+
+ unsigned area_get() const { return area_; }
+ void area_set(unsigned a) { area_ = a; }
+ unsigned area_;
+
+ unsigned area2_get() const { return area2_; }
+ void area2_set(unsigned a) { area2_ = a; }
+ unsigned area2_;
+
+ unsigned height_get() const { return height_; }
+ void height_set(unsigned a) { height_ = a; }
+ unsigned height_;
+
+ unsigned ext_volume_get() const { return ext_volume_; }
+ void ext_volume_set(unsigned a) { ext_volume_ = a; }
+ unsigned ext_volume_;
+
+ unsigned int_volume_get() const { return int_volume_; }
+ void int_volume_set(unsigned a) { int_volume_ = a; }
+ unsigned int_volume_;
+ };
+
+ struct my_type2
+ {
+ my_type2() {}
+ };
+
+
+ template <typename I, typename T1 = my_type, typename T2 = my_type2>
+ struct clean : public canvas::max_tree<I, T1, T2, clean<I, T1, T2> >
+ {
+ typedef canvas::max_tree<I, T1, T2, clean<I, T1, T2> > super_type;
+ typedef oln_type_of(I, point) point_type;
+
+ // specific methods
+ void set_area(unsigned nb)
+ {
+ area_ = nb;
+ }
+
+ void set_level(unsigned nb)
+ {
+ level_ = nb;
+ }
+
+ void set_height(unsigned nb)
+ {
+ height_ = nb;
+ }
+
+ void remove_star(const point_type& p)
+ {
+ this->is_deleted[p] = true;
+ canvas::misc::set_children(this->marked, this->children, this->is_deleted, p, true);
+ this->new_value[p] = this->input[this->parent[p]].value();
+ canvas::misc::set_children(this->marked,
+ this->children, this->new_value, p, this->input[this->parent[p]].value());
+ }
+
+ // attributes to compute the output
+
+ bool level_attr(const point_type& p)
+ {
+ if (level_tag_)
+ if (not (this->input[p].value() > this->level_))
+ return false;
+ return true;
+ }
+
+ bool area_attr(const point_type& p)
+ {
+ if (area_tag_)
+ if (not (this->aux_data_[p].call(&T1::area_get) >= area_))
+ return false;
+ return true;
+ }
+
+ bool circle_attr(const point_type& p)
+ {
+ if (circle_tag_)
+ if (not (misc::is_a_circle(this->children,
+ p,
+ this->aux_data_[p].call(&T1::area_get))))
+ return false;
+ return true;
+ }
+
+ bool tour_attr(const point_type& p)
+ {
+ if (tour_tag_)
+ if (not (get_aux_data(p, int_volume) <=
+ get_aux_data(p, ext_volume) / 2))
+ return false;
+ return true;
+ }
+
+ bool center_p_attr(const point_type& p)
+ {
+ if (center_p_tag_)
+ if (misc::have_the_center_point(this->children,
+ p,
+ this->input.size().nrows(),
+ this->input.size().ncols()))
+ return false;
+ return true;
+ }
+
+ bool height_attr(const point_type& p)
+ {
+ if (height_tag_)
+ if (not (get_aux_data(p, height) > height_))
+ return false;
+ return true;
+ }
+
+ // fill the holes
+
+ void impl_init_aux_data(const point_type& p)
+ {
+ this->aux_data_[p].call(&T1::area2_set, 1);
+ }
+
+ void impl_merge_aux_data(const point_type& r , const point_type& p)
+ {
+ this->aux_data_[p].call(&T1::area2_set,
+ this->aux_data_[r].call(&T1::area2_get) +
+ this->aux_data_[p].call(&T1::area2_get));
+ }
+
+ void impl_eligible_component(const point_type& p)
+ {
+ if (not (this->marked[p]))
+ if (level_attr(p))
+ if (area_attr(p))
+ if (circle_attr(p))
+ if (tour_attr(p))
+ if (center_p_attr(p))
+ remove_star(p);
+ }
+
+
+ void impl_init_compute_attributes()
+ {
+ oln_type_of(I, fwd_piter) p(this->input.size());
+ for_all_p(p)
+ {
+ this->aux_data_[p].call(&T1::area_set, 1);
+ this->aux_data_[p].call(&T1::height_set, 0);
+ this->aux_data_[p].call(&T1::int_volume_set, 0);
+ this->aux_data_[p].call(&T1::ext_volume_set, 0);
+ }
+ }
+
+
+ // FIXME S: structure a la olena, avec iterateurs d olena
+ void impl_compute_attributes()
+ {
+ typename std::vector<std::vector<point_type> >::reverse_iterator s;
+ typename std::vector<point_type>::const_iterator p;
+ typename std::vector<point_type>::const_iterator c;
+ for (s = this->S.rbegin(); s != this->S.rend(); s++)
+ {
+ for (p = s->begin(); p != s->end(); p++)
+ {
+ std::vector<point_type> v = this->children[*p].value();
+ for (c = v.begin(); c != v.end(); c++)
+ {
+
+ set_aux_data(*p, area, get_aux_data(*p, area) + get_aux_data(*c, area));
+
+ unsigned tmp = get_aux_data(*c, height) +
+ this->input[*c].value() - this->input[*p].value();
+
+ set_aux_data(*p, height, ntg::max(tmp, get_aux_data(*p, height)));
+
+ set_aux_data(*p, int_volume, get_aux_data(*p, int_volume) +
+ get_aux_data(*c, int_volume));
+ }
+
+ unsigned tmp = this->input[*p].value() - this->input[this->parent[local_root(*p)].value()].value();
+ if (not tmp)
+ tmp = 1;
+
+ set_aux_data(*p, int_volume, get_aux_data(*p, int_volume) + (get_aux_data(*p, area) * tmp));
+ set_aux_data(*p, ext_volume, get_aux_data(*p, int_volume) +
+ (get_aux_data(*p, area) * get_aux_data(*p, height)));
+ if (not get_aux_data(*p, ext_volume))
+ set_aux_data(*p, ext_volume, 1);
+ }
+ }
+ }
+
+ void impl_init_aux_processing()
+ {
+ }
+
+ // Ctor.
+ clean(const abstract::image_with_nbh<I>& input) :
+ super_type(input)
+ {
+ area_ = 0;
+ level_ = 0;
+ height_ = 0;
+
+ level_tag_ = false;
+ area_tag_ = false;
+ tour_tag_ = false;
+ circle_tag_ = false;
+ height_tag_ = false;
+ center_p_tag_ = false;
+ }
+
+ // Attributes.
+ // tags
+ bool level_tag_;
+ bool area_tag_;
+ bool tour_tag_;
+ bool circle_tag_;
+ bool height_tag_;
+ bool center_p_tag_;
+
+ protected:
+
+ // Attributes.
+ oln_type_of(I, value) level_;
+ oln_type_of(I, value) height_;
+ unsigned area_;
+ };
+
+ } // end of namespace oln::appli::astro
+
+ } // end of namespace oln::appli
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_APPLI_ASTRO_CLEAN_HH
Index: oln/canvas/maxtree.hh
--- oln/canvas/maxtree.hh (revision 0)
+++ oln/canvas/maxtree.hh (revision 0)
@@ -0,0 +1,346 @@
+// 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_CANVAS_MAXTREE_HH
+# define OLENA_CANVAS_MAXTREE_HH
+
+# include <mlc/any.hh>
+
+# include <oln/core/box.hh>
+# include <oln/utils/record.hh>
+# include <oln/core/abstract/image_entry.hh>
+# include <oln/core/ch_value_type.hh>
+# include <oln/level/fill.hh>
+
+# include <oln/canvas/tree.hh>
+# include <oln/basics.hh>
+
+# include <cassert>
+# include <vector>
+# include <functional>
+# include <set>
+
+
+namespace oln {
+
+ namespace canvas {
+
+ namespace misc {
+
+ struct pair_cmp
+ {
+ template<typename L, typename P>
+ bool operator()(const std::pair<L,P>& lhs,
+ const std::pair<L,P>& rhs) const
+ {
+ return lhs.first < rhs.first
+ or (lhs.first == rhs.first
+ and lhs.second.fwd_less(rhs.second));
+ }
+ };
+
+ template<typename I, typename II, typename O, typename V>
+ void set_children(abstract::image_with_nbh<I>& marked,
+ const abstract::image_with_nbh<II>& children,
+ abstract::image_with_nbh<O>& out,
+ const oln_type_of(I, point)& p,
+ const V v)
+ {
+ typedef oln_type_of(I, point) point_type;
+ std::vector<point_type> f = children[p].value();
+ typename std::vector<point_type>::const_iterator pt;
+ for (pt = f.begin(); pt != f.end(); pt++)
+ {
+ out[*pt] = v;
+ marked[*pt] = true;
+ set_children(marked, children, out, *pt, v);
+ }
+ }
+
+
+ template <class I>
+ std::vector<std::vector<oln_type_of(I, point)> >
+ sort(const abstract::image_with_nbh<I>& input)
+ {
+ typedef oln_type_of(I, point) point_type;
+ std::vector<std::vector<point_type> > S(256);
+ oln_type_of(I, fwd_piter) p(input.size());
+
+#ifdef DEBUG
+ typedef std::pair<oln_type_of(I, value), point_type> pair_t;
+ std::set<pair_t,pair_cmp> sc;
+#endif // ! DEBUG
+
+ for_all_p (p)
+ {
+ S[input[p]].push_back(p);
+#ifdef DEBUG
+ sc.insert(pair_t(input[p], p));
+#endif // ! DEBUG
+ }
+
+#ifdef DEBUG
+ {
+ unsigned l;
+
+ typename std::set<pair_t,pair_cmp>::const_iterator i = sc.begin();
+ typename std::vector<std::vector<point_type> >::const_iterator v;
+
+ for (l = 0, v = S.begin();
+ v != S.end(); v++, ++l)
+ {
+ for (typename std::vector<point_type>::const_iterator p = v->begin();
+ p != v->end(); p++, ++i)
+ {
+ assert(input[*p] == l);
+ assert(i->first == l);
+ assert(i->second == *p);
+ }
+ }
+ }
+#endif // ! DEBUG
+
+ return S;
+ }
+
+ } // end of oln::canvas::misc
+
+
+ template <typename I, typename T1, typename T2, typename E>
+ struct max_tree : public tree<I, T1, T2, E>
+ {
+ public:
+
+ typedef canvas::tree<I, T1, T2, E> super_type;
+ typedef oln_type_of(I, point) point_type;
+
+ const point_type impl_parent_get(const point_type& p) const
+ {
+ return parent[p].value();
+ }
+
+// const std::vector<point_type> impl_component_get(const point_type& p) const
+// {
+// // fixme
+// }
+
+ const std::vector<point_type> impl_children_get(const point_type& p) const
+ {
+ return this->children[p].value();
+ }
+
+ const point_type impl_local_root(const point_type& p) const
+ {
+ if ((this->input[parent[p]] == this->input[p]) &&
+ not is_root(p))
+ return local_root(parent[p]);
+ return p;
+ }
+
+ void impl_compute_S()
+ {
+ this->S = misc::sort(this->input);
+ }
+
+ void left_hand_walk(const point_type& p)
+ {
+ for (oln_type_of(I, value) i = this->input[parent[p]].value();
+ i < this->input[p].value(); i++)
+ v_root_point[i + 1].push_back(p);
+
+ std::vector<point_type> f = children[p].value();
+ typename std::vector<point_type>::const_iterator pt;
+ for (pt = f.begin(); pt != f.end(); pt++)
+ left_hand_walk(*pt);
+ }
+
+ void impl_compute_tree()
+ {
+ oln_type_of(I, fwd_piter) p(this->input.size());
+ for_all_p(p)
+ {
+ if (is_root(p))
+ {
+ v_root_point[this->input[p]].push_back(p);
+ left_hand_walk(p);
+ }
+ }
+ }
+
+ void impl_set_default_output()
+ {
+ }
+
+ void impl_set_is_processed_to_false()
+ {
+ oln_type_of(I, fwd_piter) p(is_proc.size());
+ for_all_p (p)
+ is_proc[p] = false;
+ }
+
+ void impl_set_is_processed(const point_type& p)
+ {
+ is_proc[p] = true;
+ }
+
+ bool impl_is_processed(const point_type& n) const
+ {
+ return is_proc[n];
+ }
+
+ void init_aux_data(const point_type& p)
+ {
+ this->exact().impl_init_aux_data(p);
+ }
+
+ void merge_aux_data(const point_type& r , const point_type& p)
+ {
+ children[p].call(&std::vector<point_type>::push_back, r);
+ this->exact().impl_merge_aux_data(r,p);
+ }
+
+ void impl_make_set(const point_type& p)
+ {
+ parent[p] = p;
+ init_aux_data(p);
+ }
+
+ point_type impl_find_root(const point_type& x)
+ {
+ if (is_root(x))
+ return x;
+ return find_root(parent[x]);
+ }
+
+ bool is_root(const point_type& x) const
+ {
+ return parent[x] == x;
+ }
+
+ void impl_parent_set(const point_type& r, const point_type& p)
+ {
+ parent[r] = p;
+ merge_aux_data(r,p);
+ }
+
+ void eligible_component(const point_type& p)
+ {
+ this->exact().impl_eligible_component(p);
+ }
+
+ void compute_image_is_deleted()
+ {
+ for (int i = 0; i <= 255 ;i++)
+ for (typename std::vector<point_type>::const_iterator p = v_root_point[i].begin();
+ p != v_root_point[i].end(); p++)
+ eligible_component(*p);
+ }
+
+ void impl_init_processing()
+ {
+ level::fill(this->marked, false);
+ level::fill(this->is_deleted, false);
+ this->exact().impl_init_aux_processing();
+ }
+
+ void init_compute_attributes()
+ {
+ this->exact().impl_init_compute_attributes();
+ }
+
+ void compute_attributes()
+ {
+ this->exact().impl_compute_attributes();
+ }
+
+ void impl_processing()
+ {
+ init_compute_attributes();
+ compute_attributes();
+ compute_image_is_deleted();
+
+ oln_type_of(I, fwd_piter) p(this->input.size());
+ for_all_p (p)
+ {
+ if (is_deleted[p])
+ this->output[p] = this->new_value[p];
+ else
+ this->output[p] = this->input[p];
+ }
+ }
+
+ // FIXME
+ // protected:
+
+ // Attributes.
+ oln_ch_concrete_type(I, bool) is_proc;
+ oln_ch_concrete_type(I, bool) marked;
+ oln_ch_concrete_type(I, bool) is_deleted;
+ oln_ch_concrete_type(I, point_type) parent;
+ oln_ch_concrete_type(I, std::vector<point_type>) children;
+ std::vector<std::vector<point_type> > v_root_point;
+ oln_type_of(I, concrete) new_value;
+
+ protected:
+
+ // Ctor.
+ // FIXME : will be changed
+ max_tree(const abstract::image_with_nbh<I>& input) :
+ super_type(input)
+ {
+ oln_ch_concrete_type(I, bool) tmp1(input.size());
+ is_proc = tmp1;
+
+ oln_ch_concrete_type(I, point_type) tmp2(input.size());
+ parent = tmp2;
+
+ oln_ch_concrete_type(I, std::vector<point_type>) tmp3(input.size());
+ children = tmp3;
+
+ oln_type_of(I, concrete) tmp4(input.size());
+ this->output = tmp4;
+
+ std::vector<std::vector<point_type> > tmp5(256);
+ v_root_point = tmp5;
+
+ oln_ch_concrete_type(I, bool) tmp6(input.size());
+ marked = tmp6;
+
+ oln_ch_concrete_type(I, bool) tmp7(input.size());
+ is_deleted = tmp7;
+
+ oln_type_of(I, concrete) tmp8(input.size());
+ new_value = tmp8;
+ }
+
+ };
+
+ } // end of namespace oln::canvas
+
+} // end of namespace oln
+
+#endif // ! OLENA_CANVAS_MAXTREE_HH
Index: oln/canvas/tree.hh
--- oln/canvas/tree.hh (revision 0)
+++ oln/canvas/tree.hh (revision 0)
@@ -0,0 +1,215 @@
+// 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_CANVAS_TREE_HH
+# define OLENA_CANVAS_TREE_HH
+
+# include <mlc/any.hh>
+
+# include <oln/core/box.hh>
+# include <oln/utils/record.hh>
+# include <oln/core/abstract/image_entry.hh>
+# include <oln/core/ch_value_type.hh>
+# include <oln/level/fill.hh>
+# include <oln/basics.hh>
+
+# include <vector>
+
+
+namespace oln {
+
+ namespace canvas {
+
+ template <typename I, typename T1, typename T2, typename E>
+ struct tree : public mlc::any<E>
+ {
+ typedef oln_type_of(I, point) point_type;
+
+ // interface
+ void compute_tree()
+ {
+ first_pass();
+ this->exact().impl_compute_tree();
+ }
+
+ void filter_process()
+ {
+ init_processing();
+ processing();
+ }
+
+ const point_type parent_get(const point_type& p) const
+ {
+ return this->exact().impl_parent_get(p);
+ }
+
+ // const std::vector<point_type>& component_get(const point_type& p) const
+// {
+// return this->exact().impl_component_get(p);
+// }
+
+ const std::vector<point_type> children_get(const point_type& p) const
+ {
+ return this->exact().impl_children_get(p);
+ }
+
+ const point_type local_root(const point_type& p) const
+ {
+ return this->exact().impl_local_root(p);
+ }
+
+ point_type find_root(const point_type& p)
+ {
+ return this->exact().impl_find_root(p);
+ }
+
+ oln_ch_concrete_type(I, T1)& aux_data_get()
+ {
+ return aux_data_;
+ }
+
+ // Concrete method.
+ void first_pass()
+ {
+ // init
+ compute_S();
+ set_is_processed_to_false();
+ set_default_output();
+
+ oln_type_of(I, niter) n(input);
+ typename std::vector<std::vector<point_type> >::reverse_iterator i;
+ typename std::vector<point_type>::const_iterator j;
+ for (i = S.rbegin(); i != S.rend(); i++)
+ {
+ for (j = i->begin(); j != i->end(); j++)
+ {
+ make_set(*j);
+ for_all_n_of_p (n, *j)
+ if (input.hold(n) and is_processed(n) and merge_condition(n, *j))
+ do_union(n, *j);
+ set_is_processed(*j);
+ }
+ }
+ }
+
+ bool merge_condition(const point_type& n, const point_type& p)
+ {
+ // FIXME
+ return true;
+ }
+
+ void do_union(const point_type& n, const point_type& p)
+ {
+ point_type r = find_root(n);
+ if (r != p)
+ parent_set(r, p);
+ }
+
+ // Abstract methods.
+ // ---------------------------
+
+ // init
+
+ void init_processing()
+ {
+ this->exact().impl_init_processing();
+ }
+
+ void compute_S()
+ {
+ this->exact().impl_compute_S();
+ }
+ void set_default_output()
+ {
+ this->exact().impl_set_default_output();
+ }
+
+ // about is_processed
+ void set_is_processed_to_false()
+ {
+ this->exact().impl_set_is_processed_to_false();
+ }
+ void set_is_processed(const point_type& p)
+ {
+ this->exact().impl_set_is_processed(p);
+ }
+ bool is_processed(const point_type& n) const
+ {
+ return this->exact().impl_is_processed(n);
+ }
+
+ // core
+
+ void processing()
+ {
+ this->exact().impl_processing();
+ }
+
+ void make_set(const point_type& p)
+ {
+ this->exact().impl_make_set(p);
+ }
+
+ void parent_set(const point_type& r, const point_type& p)
+ {
+ this->exact().impl_parent_set(r, p);
+ }
+
+ // Attributes.
+ box<const I> input;
+ oln_type_of(I, concrete) output;
+
+ protected:
+ std::vector<std::vector<point_type> > S;
+ oln_ch_concrete_type(I, T1) aux_data_;
+ std::vector<std::vector<T2> > aux_level_data_;
+
+
+ // Ctor.
+ tree(const abstract::image_with_nbh<I>& input) :
+ input(input),
+ S()
+ {
+ oln_ch_concrete_type(I, T1) tmp(this->input.size());
+ aux_data_ = tmp;
+ }
+
+ // Check for impls..
+ ~tree()
+ {
+ // FIXME... mlc_check_method_impl(E, void, init, , );
+ }
+
+ };
+
+
+ } // end of namespace oln::canvas
+
+} // end of namespace oln
+
+
+#endif // ! OLENA_CANVAS_TREE_HH
