Commit 602810cd authored by Guillaume Lazzara's avatar Guillaume Lazzara
Browse files

Add new link filters.

	* filter/internal/compute.hh: New routine to compute filter
	results.

	* filter/object_links_center_aligned.hh,
	* filter/object_links_top_aligned.hh,
	* filter/objects_h_thick.hh,
	* filter/objects_v_thick.hh: New filters.

git-svn-id: https://svn.lrde.epita.fr/svn/oln/trunk@4706 4aad255d-cdde-0310-9447-f3009e2ae8c0
parent 6181ecd5
2009-11-03 Guillaume Lazzara <z@lrde.epita.fr>
Add new link filters.
* filter/internal/compute.hh: New routine to compute filter
results.
* filter/object_links_center_aligned.hh,
* filter/object_links_top_aligned.hh,
* filter/objects_h_thick.hh,
* filter/objects_v_thick.hh: New filters.
2009-11-03 Guillaume Lazzara <z@lrde.epita.fr>
Revamp code related to object linking.
......
// Copyright (C) 2009 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 SCRIBO_FILTER_INTERNAL_COMPUTE_HH
# define SCRIBO_FILTER_INTERNAL_COMPUTE_HH
/// \file
///
/// Compute filters.
# include <mln/core/concept/image.hh>
# include <mln/core/concept/neighborhood.hh>
# include <mln/util/array.hh>
# include <scribo/core/object_image.hh>
# include <scribo/primitive/extract/objects.hh>
namespace scribo
{
namespace filter
{
namespace internal
{
using namespace mln;
/// Apply a filter to an image.
///
/// \param[in] input_ A binary image.
/// \param[in] nbh_ A neighborhood used in labeling algorithms.
/// \param[in] label_type The label type used for labeling.
/// \param[in] filter A filter.
///
/// \result A filtered binary image.
//
template <typename I, typename N, typename V, typename F>
mln_concrete(I)
compute(const Image<I>& input_,
const Neighborhood<N>& nbh_,
const V& label_type,
const Function_v2b<F>& filter);
/// Filter an object image.
///
/// \param[in] objects An object image.
/// \param[in] filter A filter functor.
///
/// \result A filtered object image.
//
template <typename L, typename F>
object_image(L)
compute(const object_image(L)& objects,
const Function_v2b<F>& filter);
# ifndef MLN_INCLUDE_ONLY
template <typename I, typename N, typename V, typename F>
inline
mln_concrete(I)
compute(const Image<I>& input_,
const Neighborhood<N>& nbh_,
const V& label_type,
const Function_v2b<F>& filter)
{
trace::entering("scribo::filter::internal::compute");
const I& input = exact(input_);
const N& nbh = exact(nbh_);
mln_precondition(input.is_valid());
mln_precondition(nbh.is_valid());
V nlabels;
typedef mln_ch_value(I,V) lbl_t;
object_image(lbl_t) objects
= primitive::extract::objects(input, nbh, nlabels);
filter.update_objects(objects);
objects.relabel(filter);
mln_concrete(I) output = duplicate(input);
data::fill((output | pw::value(objects) == literal::zero).rw(), false);
trace::exiting("scribo::filter::internal::compute");
return output;
}
template <typename L, typename F>
inline
object_image(L)
compute(const object_image(L)& objects,
const Function_v2b<F>& filter)
{
trace::entering("scribo::filter::internal::compute");
mln_precondition(objects.is_valid());
object_image(L) output;
output.init_from_(objects);
output.relabel(filter);
trace::exiting("scribo::filter::internal::compute");
return output;
}
# endif // ! MLN_INCLUDE_ONLY
} // end of namespace scribo::filter::internal
} // end of namespace scribo::filter
} // end of namespace scribo
#endif // ! SCRIBO_FILTER_INTERNAL_COMPUTE_HH
// Copyright (C) 2009 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 SCRIBO_FILTER_OBJECT_LINKS_CENTER_ALIGNED_HH
# define SCRIBO_FILTER_OBJECT_LINKS_CENTER_ALIGNED_HH
/// \file
///
/// Invalidate links between two objects if their center are not
/// aligned.
# include <mln/util/array.hh>
# include <scribo/core/macros.hh>
# include <scribo/core/object_links.hh>
# include <scribo/core/object_image.hh>
# include <scribo/filter/object_links_non_aligned_simple.hh>
namespace scribo
{
namespace filter
{
using namespace mln;
/*! \brief Invalidate links between two objects if their center are not
aligned.
\param[in] objects An object image.
\param[in] links Object links information.
\param[in] max_alpha Maximum angle value (degrees).
\verbatim
------ ------
| | | | v
| x ~| ~ ~ ~ | ~ ~|~ ~
| ~| ~ | | | => Alpha
| | ~ ~ | x ~|~ ~
------ | | ^
object1 | |
------
object2
\endverbatim
The angle between the two bottoms must be lower than \p max_alpha.
*/
template <typename L>
object_links<L>
object_links_center_aligned(const object_image(L)& objects,
const object_links<L>& links,
float max_alpha);
# ifndef MLN_INCLUDE_ONLY
template <typename L>
object_links<L>
object_links_center_aligned(const object_image(L)& objects,
const object_links<L>& links,
float max_alpha)
{
trace::entering("scribo::filter::object_links_center_aligned");
mln_precondition(objects.is_valid());
mln_precondition(links.is_valid());
object_links<L>
output = object_links_non_aligned_simple(objects, links,
2, max_alpha);
trace::exiting("scribo::filter::object_links_center_aligned");
return output;
}
# endif // ! MLN_INCLUDE_ONLY
} // end of namespace scribo::filter
} // end of namespace scribo
#endif // ! SCRIBO_FILTER_OBJECT_LINKS_CENTER_ALIGNED_HH
// Copyright (C) 2009 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 SCRIBO_FILTER_OBJECT_LINKS_TOP_ALIGNED_HH
# define SCRIBO_FILTER_OBJECT_LINKS_TOP_ALIGNED_HH
/// \file
///
/// Invalidate links between two objects if their top are not
/// aligned.
# include <mln/util/array.hh>
# include <scribo/core/macros.hh>
# include <scribo/core/object_links.hh>
# include <scribo/core/object_image.hh>
# include <scribo/filter/object_links_non_aligned_simple.hh>
namespace scribo
{
namespace filter
{
using namespace mln;
/*! \brief Invalidate links between two objects if their top are not
aligned.
\param[in] objects An object image.
\param[in] links Object links information.
\param[in] max_alpha Maximum angle value (degrees).
\verbatim
~
~ ^
~ |
~ |
~------ | Alpha
~ | | |
~ | | |
~ | | v
------ ~ ~ ~ | ~ ~| ~
| | | |
| x------------x |
| | | |
------ | |
object1 | |
------
object2
\endverbatim
The angle between the two tops must be lower than \p max_alpha.
*/
template <typename L>
object_links<L>
object_links_top_aligned(const object_image(L)& objects,
const object_links<L>& links,
float max_alpha);
# ifndef MLN_INCLUDE_ONLY
template <typename L>
object_links<L>
object_links_top_aligned(const object_image(L)& objects,
const object_links<L>& links,
float max_alpha)
{
trace::entering("scribo::filter::object_links_top_aligned");
mln_precondition(objects.is_valid());
mln_precondition(links.is_valid());
object_links<L>
output = object_links_non_aligned_simple(objects, links,
0,
max_alpha);
trace::exiting("scribo::filter::object_links_top_aligned");
return output;
}
# endif // ! MLN_INCLUDE_ONLY
} // end of namespace scribo::filter
} // end of namespace scribo
#endif // ! SCRIBO_FILTER_OBJECT_LINKS_TOP_ALIGNED_HH
// Copyright (C) 2009 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 SCRIBO_FILTER_OBJECTS_H_THICK_HH
# define SCRIBO_FILTER_OBJECTS_H_THICK_HH
/// \file
///
/// Remove too horizontaly thick objects.
# include <mln/core/concept/image.hh>
# include <mln/core/concept/neighborhood.hh>
# include <mln/util/array.hh>
# include <scribo/core/object_image.hh>
# include <scribo/primitive/extract/objects.hh>
# include <scribo/filter/internal/compute.hh>
namespace scribo
{
namespace filter
{
using namespace mln;
/// Remove objects horizontaly thicker or equal to \p max_thickness.
///
/// \param[in] input_ A binary image.
/// \param[in] nbh_ A neighborhood used in labeling algorithms.
/// \param[in] label_type The label type used for labeling.
/// \param[in] max_thickness The maximum thickness value.
///
/// \result A binary image without thick objects.
//
template <typename I, typename N, typename V>
inline
mln_concrete(I)
objects_h_thick(const Image<I>& input_,
const Neighborhood<N>& nbh_,
const V& label_type,
unsigned max_thickness);
/// Remove objects horizontaly thicker or equal to \p max_thickness.
///
/// \param[in] objects An object image.
/// \param[in] max_thickness The maximum thickness value.
///
/// \result An object image without too thick objects.
//
template <typename L>
inline
object_image(L)
objects_h_thick(const object_image(L)& objects,
unsigned max_thickness);
# ifndef MLN_INCLUDE_ONLY
namespace internal
{
/// Filter Functor. Return false for all objects which are too
/// large.
template <typename L>
struct h_thick_object_filter
: Function_v2b< h_thick_object_filter<L> >
{
/// Constructor
///
/// \param[in] objects An object image.
/// \param[in] max_thickness the maximum thickness allowed.
//
h_thick_object_filter(const object_image(L)& objects,
unsigned max_thickness)
: objects_(objects), max_thickness_(max_thickness)
{
}
/// Constructor
///
/// \param[in] max_thickness the maximum thickness allowed.
//
h_thick_object_filter(unsigned max_thickness)
: max_thickness_(max_thickness)
{
}
/// Set the underlying object image.
//
void update_objects(const object_image(L)& objects)
{
objects_ = objects;
}
/// Return false if the objects is thicker than
/// \p max_thickness_.
///
/// \param[in] l An image value.
bool operator()(const mln_value(L)& l) const
{
if (l == literal::zero)
return true;
return objects_.bbox(l).nrows() < max_thickness_;
}
/// An object image.
object_image(L) objects_;
/// The maximum thickness.
unsigned max_thickness_;
};
} // end of namespace scribo::filter::internal
template <typename I, typename N, typename V>
inline
mln_concrete(I)
objects_thick(const Image<I>& input_,
const Neighborhood<N>& nbh_,
const V& label_type,
unsigned max_thickness)
{
trace::entering("scribo::filter::objects_h_thick");
const I& input = exact(input_);
const N& nbh = exact(nbh_);
mln_precondition(input.is_valid());
mln_precondition(nbh.is_valid());
internal::h_thick_object_filter<V> functor(max_thickness);
mln_concrete(I)
output = internal::compute(input, nbh, label_type, functor);
trace::exiting("scribo::filter::objects_h_thick");
return output;
}
template <typename L>
inline
object_image(L)
objects_h_thick(const object_image(L)& objects,
unsigned max_thickness)
{
trace::entering("scribo::filter::objects_h_thick");
mln_precondition(objects.is_valid());
internal::h_thick_object_filter<L> functor(objects, max_thickness);
object_image(L) output = internal::compute(objects, functor);
trace::exiting("scribo::filter::objects_h_thick");
return output;
}
# endif // ! MLN_INCLUDE_ONLY
} // end of namespace scribo::filter
} // end of namespace scribo
#endif // ! SCRIBO_FILTER_OBJECTS_H_THICK_HH
// Copyright (C) 2009 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 SCRIBO_FILTER_OBJECTS_V_THICK_HH
# define SCRIBO_FILTER_OBJECTS_V_THICK_HH
/// \file
///
/// Remove too verticaly thick objects.