Commit 85cda080 authored by Guillaume Lazzara's avatar Guillaume Lazzara
Browse files

Introduce labeling::value_and_compute.

	* mln/canvas/labeling/video.hh: Call more functor members.

	* mln/labeling/value.hh: Provide new members to the functor.

	* mln/labeling/value_and_compute.hh: New functor computing
	attributes while labeling.
parent e8373a06
2010-06-15 Guillaume Lazzara <z@lrde.epita.fr>
Introduce labeling::value_and_compute.
* mln/canvas/labeling/video.hh: Call more functor members.
* mln/labeling/value.hh: Provide new members to the functor.
* mln/labeling/value_and_compute.hh: New functor computing
attributes while labeling.
2010-05-18 Guillaume Lazzara <z@lrde.epita.fr>
 
* mln/io/magick/load.hh: set minimum resolution for PDF files to
......@@ -162,14 +162,20 @@ namespace mln
return output;
}
output.element(p) = ++nlabels;
f.set_new_label_(p, nlabels);
}
}
else
output.element(p) = output.element(parent.element(p));
{
L lbl = output.element(parent.element(p));
output.element(p) = lbl;
f.set_label_(p, lbl);
}
}
status = true;
}
f.finalize();
trace::exiting("canvas::impl::video_fastest");
return output;
}
......
// Copyright (C) 2007, 2008, 2009 EPITA Research and Development
// Copyright (C) 2007, 2008, 2009, 2010 EPITA Research and Development
// Laboratory (LRDE)
//
// This file is part of Olena.
......@@ -73,7 +73,7 @@ namespace mln
L& nlabels)
{
mln_precondition(exact(input).is_valid());
// mln_precondition(exact(nbh).is_valid());
mln_precondition(exact(nbh).is_valid());
(void) input;
(void) val;
......@@ -90,7 +90,7 @@ namespace mln
// Generic functor.
template <typename I>
template <typename I, typename L>
struct value_functor
{
typedef mln_psite(I) P;
......@@ -108,9 +108,12 @@ namespace mln
bool handles(const P& p) const { return input(p) == val; }
bool equiv(const P& n, const P&) const { return input(n) == val; }
bool labels(const P&) const { return true; }
void do_no_union(const P&, const P&) {}
void do_no_union(const P&, const P&) {}
void init_attr(const P&) {}
void merge_attr(const P&, const P&) {}
void set_new_label(const P& p, const L& l){}
void set_label(const P& p, const L& l) {}
void finalize() {}
// Fastest implementation
......@@ -121,6 +124,9 @@ namespace mln
void do_no_union_(unsigned, unsigned) {}
void init_attr_(unsigned) {}
void merge_attr_(unsigned, unsigned) {}
void set_new_label_(unsigned, const L&) {}
void set_label_(unsigned, const L&) {}
void finalize_() {}
// end of Requirements.
......@@ -148,7 +154,7 @@ namespace mln
internal::value_tests(input, val, nbh, nlabels);
mln_ch_value(I, L) output;
impl::value_functor<I> f(input, val);
impl::value_functor<I,L> f(input, val);
output = canvas::labeling::video(input, nbh, nlabels, f);
trace::exiting("labeling::value");
......
// Copyright (C) 2010 EPITA Research and Development Laboratory (LRDE)
//
// This file is part of Olena.
//
// Olena is free software: you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, version 2 of the License.
//
// Olena 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 Olena. If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free
// software project without restriction. Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to produce
// an executable, this file does not by itself cause the resulting
// executable to be covered by the GNU General Public License. This
// exception does not however invalidate any other reasons why the
// executable file might be covered by the GNU General Public License.
#ifndef MLN_LABELING_VALUE_AND_COMPUTE_HH
# define MLN_LABELING_VALUE_AND_COMPUTE_HH
/// \file
///
/// Connected component labeling of image sites at a given value.
# include <mln/core/concept/image.hh>
# include <mln/core/concept/neighborhood.hh>
# include <mln/canvas/labeling/video.hh>
# include <mln/data/fill.hh>
namespace mln
{
namespace labeling
{
/// \brief Connected component labeling of the image sites at a given
/// value.
///
/// \param[in] input The input image.
/// \param[in] val The value to consider.
/// \param[in] nbh The connectivity of components.
/// \param[out] nlabels The number of labels.
/// \return The label image.
//
template <typename I, typename N, typename L, typename A>
util::couple<mln_ch_value(I,L),
util::couple<util::array<mln_result(A)>,
util::array<A> > >
value_and_compute(const Image<I>& input, const mln_value(I)& val,
const Neighborhood<N>& nbh, L& nlabels,
const Accumulator<A>& accu);
# ifndef MLN_INCLUDE_ONLY
// Tests.
namespace internal
{
template <typename I, typename N, typename L, typename A>
void
value_and_compute_tests(const Image<I>& input, const mln_value(I)& val,
const Neighborhood<N>& nbh, L& nlabels,
const Accumulator<A>& accu)
{
mln_precondition(exact(input).is_valid());
mln_precondition(exact(nbh).is_valid());
(void) accu;
(void) input;
(void) val;
(void) nbh;
(void) nlabels;
}
} // end of namespace mln::labeling::internal
namespace impl
{
// Generic functor.
template <typename I, typename L, typename A>
struct value_and_compute_functor
{
typedef mln_psite(I) P;
util::array<mln_result(A)> result_;
util::array<A> accus_;
const I& input;
const mln_value(I)& val;
typedef mln_result(A) accu_result;
typedef mln_argument(A) accu_argument;
typedef util::couple<util::array<accu_result>,
util::array<A> > result;
// Requirements from mln::canvas::labeling.
typedef mln_domain(I) S;
// Generic implementation
void init() {}
bool handles(const P& p) const { return input(p) == val; }
bool equiv(const P& n, const P&) const { return input(n) == val; }
bool labels(const P&) const { return true; }
void do_no_union(const P&, const P&) {}
void init_attr(const P&) {}
void merge_attr(const P&, const P&) {}
void set_new_label(const P& p, const L& l)
{
accus_.append(A());
process__(accu_argument(), p, l);
}
void set_label(const P& p, const L& l) { process__(accu_argument(), p, l); };
void finalize() { convert::from_to(accus_, result_); }
// Fastest implementation
void init_() { accus_.append(A()); }
bool handles_(unsigned p) const { return input.element(p) == val; }
bool equiv_(unsigned n, unsigned) const { return input.element(n) == val; }
bool labels_(unsigned) const { return true; }
void do_no_union_(unsigned, unsigned) {}
void init_attr_(unsigned) {}
void merge_attr_(unsigned, unsigned) {}
void set_new_label_(unsigned p, const L& l)
{
accus_.append(A());
process__(accu_argument(), p, l);
};
void set_label_(unsigned p, const L& l) { process__(accu_argument(), p, l); };
void finalize_() { convert::from_to(accus_, result_); }
// end of Requirements.
value_and_compute_functor(const Image<I>& input_, const mln_value(I)& val)
: input(exact(input_)),
val(val)
{
}
private:
inline
void process__(const unsigned&, unsigned p, const L& l)
{
accus_[l].take(p);
}
inline
void process__(const mln_psite(I)&, unsigned p, const L& l)
{
accus_[l].take(input.point_at_index(p));
}
inline
void process__(const mln_psite(I)&, const mln_site(I)& p, const L& l)
{
accus_[l].take(p);
}
inline
void process__(const mln_value(I)&, const mln_site(I)&, const L& l)
{
accus_[l].take(l);
}
template <typename V>
inline
void process__(const V&, const mln_site(I)&, const L& l)
{
mlc_abort(V)::check();
}
};
} // end of namespace mln::labeling::impl
// Facade.
template <typename I, typename N, typename L, typename A>
util::couple<mln_ch_value(I,L),
util::couple<util::array<mln_result(A)>,
util::array<A> > >
value_and_compute(const Image<I>& input, const mln_value(I)& val,
const Neighborhood<N>& nbh, L& nlabels,
const Accumulator<A>& accu)
{
trace::entering("labeling::value_and_compute");
internal::value_and_compute_tests(input, val, nbh, nlabels, accu);
typedef mln_ch_value(I,L) out_t;
typedef impl::value_and_compute_functor<I, L, A> func_t;
func_t f(input, val);
out_t output = canvas::labeling::video(input, nbh, nlabels, f);
util::couple<out_t, typename func_t::result>
result = make::couple(output,
make::couple(f.result_, f.accus_));
trace::exiting("labeling::value_and_compute");
return result;
}
# endif // ! MLN_INCLUDE_ONLY
} // end of namespace mln::labeling
} // end of namespace mln
#endif // ! MLN_LABELING_VALUE_AND_COMPUTE_HH
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment