- Olena-patches

milena r1069: Add fast-gaussian
by Simon Nivault 05 Sep '07

05 Sep '07

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2007-09-05 Simon Nivault <simon.nivault(a)lrde.epita.fr> Add fast-gaussian * sandbox/nivault/fast_gaussian.hh: New. * sandbox/nivault/tests/test.cc: New. * sandbox/nivault/tests/test: New. * sandbox/nivault/tests: New. fast_gaussian.hh | 288 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ tests/test | 4 tests/test.cc | 42 ++++++++ 3 files changed, 334 insertions(+) Index: trunk/milena/sandbox/nivault/tests/test =================================================================== --- trunk/milena/sandbox/nivault/tests/test (revision 0) +++ trunk/milena/sandbox/nivault/tests/test (revision 1069) @@ -0,0 +1,4 @@ +#!/bin/bash + +g++ -I../../.. -I../.. -I.. test.cc -O1 +./a.out Property changes on: trunk/milena/sandbox/nivault/tests/test ___________________________________________________________________ Name: svn:executable + * Index: trunk/milena/sandbox/nivault/tests/test.cc =================================================================== --- trunk/milena/sandbox/nivault/tests/test.cc (revision 0) +++ trunk/milena/sandbox/nivault/tests/test.cc (revision 1069) @@ -0,0 +1,42 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#include <mln/core/image2d_b.hh> +#include <mln/io/load_pgm.hh> +#include <mln/io/save_pgm.hh> + +#include <fast_gaussian.hh> + +int main() +{ + mln::image2d_b<mln::value::int_u<8u> > im1 = mln::io::load_pgm("../../../img/lena.pgm"); + mln::image2d_b<float> im2; + + mln::linear::gaussian(im1, 0.2, im2); + + // mln::io::save_pgm(im2, "gausslena.pgm"); + } Index: trunk/milena/sandbox/nivault/fast_gaussian.hh =================================================================== --- trunk/milena/sandbox/nivault/fast_gaussian.hh (revision 0) +++ trunk/milena/sandbox/nivault/fast_gaussian.hh (revision 1069) @@ -0,0 +1,288 @@ +// Copyright (C) 2001, 2002, 2003, 2004 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, Inc., 51 Franklin Street, Fifth Floor, +// Boston, MA 02110-1301, 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_CONVOL_FAST_GAUSSIAN_FILTER_HH__ +# define OLENA_CONVOL_FAST_GAUSSIAN_FILTER_HH__ + +#include <mln/core/concept/image.hh> +#include <mln/level/paste.hh> +#include <mln/geom/ncols.hh> + + +namespace mln +{ + + namespace linear + { + + + struct recursivefilter_coef_ + { + + /*! + ** \brief Constructor. + */ + recursivefilter_coef_(float a0, float a1, + float b0, float b1, + float c0, float c1, + float w0, float w1, + float s); + std::vector<float> n, d, nm, dm; + float sumA, sumC; + }; + + recursivefilter_coef_::recursivefilter_coef_(float a0, float a1, + float b0, float b1, + float c0, float c1, + float w0, float w1, + float s) + { + n.reserve(5); + d.reserve(5); + nm.reserve(5); + dm.reserve(5); + + b0 /= s; + b1 /= s; + w0 /= s; + w1 /= s; + + float sin0 = sin(w0); + float sin1 = sin(w1); + float cos0 = cos(w0); + float cos1 = cos(w1); + + sumA = + (2.0 * a1 * exp( b0 ) * cos0 * cos0 - a0 * sin0 * exp( 2.0 * b0 ) + + a0 * sin0 - 2.0 * a1 * exp( b0 )) / + (( 2.0 * cos0 * exp( b0 ) - exp( 2.0 * b0 ) - 1 ) * sin0); + + sumC = + (2.0 * c1 * exp( b1 ) * cos1 * cos1 - c0 * sin1 * exp( 2.0 * b1 ) + + c0 * sin1 - 2.0 * c1 * exp( b1 )) + / (( 2.0 * cos1 * exp( b1 ) - exp( 2.0 * b1 ) - 1 ) * sin1); + + a0 /= (sumA + sumC); + a1 /= (sumA + sumC); + c0 /= (sumA + sumC); + c1 /= (sumA + sumC); + + n[3] = + exp( -b1 - 2*b0 ) * (c1 * sin1 - cos1 * c0) + + exp( -b0 - 2*b1 ) * (a1 * sin0 - cos0 * a0); + n[2] = + 2 * exp(-b0 - b1) * ((a0 + c0) * cos1 * cos0 - + cos1 * a1 * sin0 - + cos0 * c1 * sin1) + + c0 * exp(-2 * b0) + a0 * exp(-2 * b1); + n[1] = + exp(-b1) * (c1 * sin1 - (c0 + 2*a0) * cos1) + + exp(-b0) * (a1 * sin0 - (2*c0 + a0) * cos0); + n[0] = + a0 + c0; + + d[4] = exp(-2 * b0 - 2 * b1); + d[3] = + -2 * cos0 * exp(-b0 - 2*b1) - + 2 * cos1 * exp(-b1 - 2*b0); + d[2] = + 4 * cos1 * cos0 * exp(-b0 - b1) + + exp(-2*b1) + exp(-2*b0); + d[1] = + -2*exp(-b1) * cos1 - 2 * exp(-b0) * cos0; + + for (unsigned i = 1; i <= 3; ++i) + { + dm[i] = d[i]; + nm[i] = n[i] - d[i] * n[0]; + } + dm[4] = d[4]; + nm[4] = -d[4] * n[0]; + } + + + + template <class WorkType, class I> + void + recursivefilter_(I& ima, + const recursivefilter_coef_& c, + const mln_point(I)& start, + const mln_point(I)& finish, + int len, + const mln_dpoint(I)& d) + { + std::vector<WorkType> tmp1(len); + std::vector<WorkType> tmp2(len); + + // The fourth degree approximation implies to have a special + // look on the four first points we consider that there is + // no signal before 0 (to be discussed) + + // -- + // Causal part + + tmp1[0] = + c.n[0]*ima(start); + + tmp1[1] = + c.n[0]*ima(start + d) + + c.n[1]*ima(start) + - c.d[1]*tmp1[0]; + + tmp1[2] = + c.n[0]*ima(start + d + d) + + c.n[1]*ima(start + d) + + c.n[2]*ima(start) + - c.d[1]*tmp1[1] + - c.d[2]*tmp1[0]; + + tmp1[3] = + c.n[0]*ima(start + d + d + d) + + c.n[1]*ima(start + d + d) + + c.n[2]*ima(start + d) + + c.n[3]*ima(start) + - c.d[1]*tmp1[2] - c.d[2]*tmp1[1] + - c.d[3]*tmp1[0]; + + mln_point(I) current(start + d + d + d + d); + for (mln_coord(I) i = 4; i < len; ++i) + { + tmp1[i] = + c.n[0]*ima(current) + + c.n[1]*ima(current - d) + + c.n[2]*ima(current - d - d) + + c.n[3]*ima(current - d - d - d) + - c.d[1]*tmp1[i - 1] - c.d[2]*tmp1[i - 2] + - c.d[3]*tmp1[i - 3] - c.d[4]*tmp1[i - 4]; + current += d; + } + + // Non causal part + + tmp2[len - 1] = 0; + + tmp2[len - 2] = + c.nm[1]*ima(finish); + + tmp2[len - 3] = + c.nm[1]*ima(finish - d) + + c.nm[2]*ima(finish) + - c.dm[1]*tmp2[len-2]; + + tmp2[len - 4] = + c.nm[1]*ima(finish - d - d) + + c.nm[2]*ima(finish - d) + + c.nm[3]*ima(finish) + - c.dm[1]*tmp2[len-3] + - c.dm[2]*tmp2[len-2]; + + current = finish - d - d - d ; + + for (int i = len - 5; i >= 0; --i) + { + tmp2[i] = + c.nm[1]*ima(current) + + c.nm[2]*ima(current + d) + + c.nm[3]*ima(current + d + d) + + c.nm[4]*ima(current + d + d + d) + - c.dm[1]*tmp2[i+1] - c.dm[2]*tmp2[i+2] + - c.dm[3]*tmp2[i+3] - c.dm[4]*tmp2[i+4]; + current -= d; + } + + // Combine results from causal and non-causal parts. + + current = start; + for (int i = 0; i < len; ++i) + { + ima(current) = tmp1[i] + tmp2[i]; + current += d; + } + } + + + template <class I, class F> + void + gaussian_(Image& img_, const F& coef) + { + I& img = exact(img_); + typedef mln_point(I) P; + // Apply on columns. + + recursivefilter_<float>(img, coef, + make::point2d(0, - img.border()), // FIXME + make::point2d(0, geom::ncols(img) - 1 + img.border()), + geom::ncols(img) + 2 * img.border(), + make::dpoint2d(0, 1)); + } + + + template <class I, class F, class O> + void + gaussian_common_(const Image& in, + const F& coef, + float sigma, + Image<O>& out) + { + mln_ch_value(O, float) work_img(exact(in).domain()); + level::paste(in, work_img); + + // On tiny sigma, Derich algorithm doesn't work. + // It is the same thing that to convolve with a Dirac. + if (sigma > 0.006) + gaussian_(work_img, coef); + /* Convert the result image to the user-requested datatype. + FIXME: We are making an unnecessary copy in case the + user expects a ntg::float_s image. */ + level::paste(work_img, out); + } + + + + + template <class I, class O> + void + gaussian(const Image& in, float sigma, + Image<O>& out) + { + recursivefilter_coef_ + coef(1.68f, 3.735f, + 1.783f, 1.723f, + -0.6803f, -0.2598f, + 0.6318f, 1.997f, + sigma); + + gaussian_common_(in, coef, sigma, out); + } + + } + +} + + + +#endif // OLENA_CONVOL_FAST_GAUSSIAN_FILTER_HH__

1 0

1068: Add labeling routines.
by Thierry Geraud 05 Sep '07

05 Sep '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add labeling routines. * tests/sort_points.cc: Rename as... * tests/level_sort_points.cc: ...this. Augment. * tests/labeling.cc: Rename as... * tests/labeling_foreground.cc: ...this. Update. * tests/labeling_regional_maxima.cc: New. * mln/convert/to_vec_p.hh: New. * mln/pw/image.hh (change_value): Use fixme. * mln/core/vec_p.hh (reserve, hook_): New. * mln/core/vec_p_piter.hh (vec_p_bkd_piter_): Code. * mln/level/sort_points.hh (sort_points): Rename as... (sort_points_increasing): ...this. (sort_points_decreasing): New. * mln/level/fill.hh: Add & to the C function arg; that fixes the behavior of icpc when calling fill with the literal 0. * mln/level/labeling.hh: Remove; obsolete because of labeling::level. * mln/linear/sobel.hh: Add FIXME. * mln/canvas/labeling.hh: New. * mln/labeling/flat_zones.hh: New. * mln/labeling/+foreground.hh: Remove. * mln/labeling/level.hh: New. * mln/labeling/foreground.hh: New. * mln/labeling/regional_minima.hh: New. * mln/labeling/base.hh: New. * mln/labeling/regional_maxima.hh: New. * mln/labeling/background.hh: New. mln/canvas/labeling.hh | 157 ++++++++++++++++++++++++++++++++++++++ mln/convert/to_vec_p.hh | 71 +++++++++++++++++ mln/core/vec_p.hh | 20 ++++ mln/core/vec_p_piter.hh | 121 ++++++++++++++++++++++++++++- mln/labeling/background.hh | 79 +++++++++++++++++++ mln/labeling/base.hh | 94 ++++++++++++++++++++++ mln/labeling/flat_zones.hh | 111 ++++++++++++++++++++++++++ mln/labeling/foreground.hh | 79 +++++++++++++++++++ mln/labeling/level.hh | 118 ++++++++++++++++++++++++++++ mln/labeling/regional_maxima.hh | 120 +++++++++++++++++++++++++++++ mln/labeling/regional_minima.hh | 120 +++++++++++++++++++++++++++++ mln/level/fill.hh | 5 - mln/level/sort_points.hh | 110 ++++++++++++++++++++------ mln/linear/sobel.hh | 2 mln/pw/image.hh | 2 tests/labeling_foreground.cc | 45 ++-------- tests/labeling_regional_maxima.cc | 57 +++++++++++++ tests/level_sort_points.cc | 15 ++- 18 files changed, 1254 insertions(+), 72 deletions(-) Index: tests/level_sort_points.cc --- tests/level_sort_points.cc (revision 1067) +++ tests/level_sort_points.cc (working copy) @@ -47,10 +47,13 @@ image2d_b<int_u8> ima(3, 3); debug::iota(ima); - std::vector<point2d> vec = level::sort_points(ima); - - std::copy(vec.begin(), vec.end(), - std::ostream_iterator<point2d>(std::cout, " ")); - std::cout << std::endl; - + vec_p<point2d> vec; + { + vec = level::sort_points_increasing(ima); + std::cout << vec << std::endl; + } + { + vec = level::sort_points_decreasing(ima); + std::cout << vec << std::endl; + } } Index: tests/labeling_foreground.cc --- tests/labeling_foreground.cc (revision 1067) +++ tests/labeling_foreground.cc (working copy) @@ -25,54 +25,33 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/labeling.cc +/*! \file tests/labeling_foreground.cc * - * \brief Tests on mln::level::labeling. + * \brief Test on mln::labeling::foreground. */ #include <mln/core/image2d_b.hh> #include <mln/core/neighb2d.hh> - #include <mln/value/int_u8.hh> -#include <mln/value/label.hh> - -#include <mln/pw/value.hh> -#include <mln/pw/cst.hh> -#include <mln/fun/ops.hh> +#include <mln/pw/all.hh> #include <mln/io/load_pgm.hh> #include <mln/io/save_pgm.hh> - -#include <mln/level/fill.hh> -#include <mln/level/labeling.hh> -#include <mln/level/to_enc.hh> - +#include <mln/labeling/foreground.hh> int main() { using namespace mln; using value::int_u8; - using value::label; - image2d_b<int_u8> lena = io::load_pgm("../img/lena.pgm"); - - image2d_b<bool> bin(lena.domain()); - level::fill(bin, pw::value(lena) > pw::cst(127)); - - { - image2d_b<int_u8> lab(lena.domain()); - level::labeling(bin, c4(), lab); - io::save_pgm(lab, "lab.pgm"); - } - - { - image2d_b< label<8> > lab(lena.domain()); - level::labeling(bin, c4(), lab); - - image2d_b< int_u8 > out(lena.domain()); - level::to_enc(lab, out); + image2d_b<int_u8> + lena = io::load_pgm("../img/tiny.pgm"), + out(lena.domain()); + + unsigned n; + labeling::foreground((pw::value(lena) > pw::cst(127)) | lena.domain(), + c4(), out, n); io::save_pgm(out, "out.pgm"); - } - + mln_assertion(n = 14); } Index: tests/labeling_regional_maxima.cc --- tests/labeling_regional_maxima.cc (revision 0) +++ tests/labeling_regional_maxima.cc (revision 0) @@ -0,0 +1,57 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/*! \file tests/labeling_regional_maxima.cc + * + * \brief Test on mln::labeling::regional_maxima. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/core/neighb2d.hh> +#include <mln/value/int_u8.hh> + +#include <mln/io/load_pgm.hh> +#include <mln/io/save_pgm.hh> + +#include <mln/labeling/regional_maxima.hh> + + +int main() +{ + using namespace mln; + using value::int_u8; + + image2d_b<int_u8> + lena = io::load_pgm("../img/lena.pgm"), + out(lena.domain()); + + unsigned n; + labeling::regional_maxima(lena, c4(), out, n); + mln_assertion(n = 255); + + io::save_pgm(out, "out.pgm"); +} Index: mln/convert/to_vec_p.hh --- mln/convert/to_vec_p.hh (revision 0) +++ mln/convert/to_vec_p.hh (revision 0) @@ -0,0 +1,71 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_CONVERT_TO_VEC_P_HH +# define MLN_CONVERT_TO_VEC_P_HH + +/*! \file mln/convert/to_vec_p.hh + * + * \brief Conversions to mln::vec_p. + */ + +# include <mln/core/vec_p.hh> + + +namespace mln +{ + + namespace convert + { + + /// Convert a point set \p pset into a vec_p (point set vector). + template <typename S> + vec_p<mln_point(S)> to_vec_p(const Point_Set<S>& pset); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename S> + vec_p<mln_point(S)> to_vec_p(const Point_Set<S>& pset_) + { + const S& pset = exact(pset_); + vec_p<mln_point(S)> v; + v.reserve(pset.npoints()); + mln_fwd_piter(S) p(pset); + for_all(p) + v.append(p); + return v; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::convert + +} // end of namespace mln + + +#endif // ! MLN_CONVERT_TO_VEC_P_HH Index: mln/pw/image.hh --- mln/pw/image.hh (revision 1067) +++ mln/pw/image.hh (working copy) @@ -109,7 +109,7 @@ template <typename U> struct change_value { - typedef void ret; + typedef internal::fixme ret; }; protected: Index: mln/core/vec_p.hh --- mln/core/vec_p.hh (revision 1067) +++ mln/core/vec_p.hh (working copy) @@ -79,6 +79,9 @@ /// Constructor from a vector \p vect. vec_p(const std::vector& vect); + /// Reserve \p n cells. + void reserve(std::size_t n); + /// Test is \p p belongs to this point set. bool has(const P& p) const; @@ -100,6 +103,9 @@ /// Return the \p i-th point. const P& operator[](unsigned i) const; + /// Hook to data. + std::vector& hook_(); + protected: std::vector vect_; @@ -129,6 +135,20 @@ template <typename P> void + vec_p::reserve(std::size_t n) + { + vect_.reserve(n); + } + + template <typename P> + std::vector& + vec_p::hook_() + { + return vect_; + } + + template <typename P> + void vec_p::update_bb_() const { bb_.init(); Index: mln/core/vec_p_piter.hh --- mln/core/vec_p_piter.hh (revision 1067) +++ mln/core/vec_p_piter.hh (working copy) @@ -92,15 +92,63 @@ - // FIXME: + /*! \brief Backward iterator on points of a vec_p. + * + */ template <typename P> - struct vec_p_bkd_piter_ : internal::fixme - {}; + struct vec_p_bkd_piter_ : public Point_Iterator< vec_p_bkd_piter_ > + { + enum { dim = P::dim }; + + /// Point_Site associated type. + typedef P psite; + + /// Point associated type. + typedef P point; + + /// Dpoint associated type. + typedef mln_dpoint(P) dpoint; + + /// Coordinate associated type. + typedef mln_coord(P) coord; + + /// Coordinate associated type. + template <typename S> + vec_p_bkd_piter_(const Point_Set<S>& s); + + /// Give a hook to the point address. + const P* pointer_() const; + + /// Read-only access to the \p i-th coordinate. + coord operator[](unsigned i) const; + + /// Test if the iterator is valid. + bool is_valid() const; + + /// Invalidate the iterator. + void invalidate(); + + /// Start an iteration. + void start(); + + /// Go to the next point. + void next_(); + + /// Convert the iterator into a point. + operator P() const; + + protected: + const std::vector& vect_; + int i_; + P p_; + }; # ifndef MLN_INCLUDE_ONLY + // vec_p_fwd_piter_ + template <typename P> template <typename S> vec_p_fwd_piter_::vec_p_fwd_piter_(const Point_Set<S>& s) @@ -153,6 +201,7 @@ vec_p_fwd_piter_::next_() { ++i_; + if (is_valid()) p_ = vect_[i_]; } @@ -163,6 +212,72 @@ return p_; } + + // vec_p_bkd_piter_ + + template <typename P> + template <typename S> + vec_p_bkd_piter_::vec_p_bkd_piter_(const Point_Set<S>& s) + : vect_(exact(s).vect()) + { + invalidate(); + } + + template <typename P> + const P* + vec_p_bkd_piter_::pointer_() const + { + return & p_; + } + + template <typename P> + mln_coord(P) + vec_p_bkd_piter_::operator[](unsigned i) const + { + mln_precondition(i < dim); + mln_precondition(is_valid()); + return p_[i]; + } + + template <typename P> + bool + vec_p_bkd_piter_::is_valid() const + { + return i_ >= 0; + } + + template <typename P> + void + vec_p_bkd_piter_::invalidate() + { + i_ = -1; + } + + template <typename P> + void + vec_p_bkd_piter_::start() + { + i_ = vect_.size() - 1; + if (is_valid()) + p_ = vect_[i_]; + } + + template <typename P> + void + vec_p_bkd_piter_::next_() + { + --i_; + if (is_valid()) + p_ = vect_[i_]; + } + + template <typename P> + vec_p_bkd_piter_::operator P() const + { + mln_precondition(is_valid()); + return p_; + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/level/sort_points.hh --- mln/level/sort_points.hh (revision 1067) +++ mln/level/sort_points.hh (working copy) @@ -31,13 +31,14 @@ /*! \file mln/level/sort_points.hh * * \brief Sort_Points the contents of an image into another one. + * + * \todo Factor code + optimize. */ -# include <vector> -# include <utility> # include <algorithm> # include <mln/core/concept/image.hh> +# include <mln/convert/to_vec_p.hh> # include <mln/histo/compute.hh> @@ -55,7 +56,7 @@ * \pre \p input.has_data */ template <typename I> - std::vector<mln_point(I)> sort_points(const Image& input); + vec_p<mln_point(I)> sort_points_increasing(const Image& input); # ifndef MLN_INCLUDE_ONLY @@ -63,6 +64,8 @@ namespace impl { + // utility + template <typename I> struct value_point_less_ { @@ -82,31 +85,40 @@ }; template <typename I> - std::vector<mln_point(I)> - sort_points(metal::false_, // general case - const Image& input_) + struct value_point_greater_ { - const I& input = exact(input_); + const I& ima_; - std::vector<mln_point(I)> vec; - vec.reserve(input.npoints()); + value_point_greater_(const I& ima) + : ima_(ima) + { + } - mln_fwd_piter(I) p(input.domain()); - for_all(p) - vec.push_back(p); + bool operator()(const mln_point(I)& lhs, + const mln_point(I)& rhs) const + { + return ima_(lhs) > ima_(rhs) || (ima_(lhs) = ima_(rhs) + && lhs > rhs); + } + }; - std::sort(vec.begin(), vec.end(), + + // increasing + + template <typename I> + vec_p<mln_point(I)> + sort_points_increasing_(metal::false_, const I& input) // general case + { + vec_p<mln_point(I)> v = convert::to_vec_p(input.domain()); + std::sort(v.hook_().begin(), v.hook_().end(), value_point_less_(input)); - return vec; + return v; } template <typename I> - std::vector<mln_point(I)> - sort_points(metal::true_, // low quantization - const Image& input_) + vec_p<mln_point(I)> + sort_points_increasing_(metal::true_, const I& input) // low quantization { - const I& input = exact(input_); - typedef mln_vset(I) S; const S& vset = input.values(); const unsigned n = vset.nvalues(); @@ -120,12 +132,46 @@ for (unsigned i = 1; i != n; ++i) loc[i] = loc[i-1] + h[i-1]; - /* - MEMO. Decreasing case is: + // computing output data + std::vector<mln_point(I)> vec(input.npoints()); + mln_fwd_piter(I) p(input.domain()); + for_all(p) + vec[loc[vset.index_of(input(p))]++] = p; + + vec_p<mln_point(I)> v; + v.hook_() = vec; + return v; + } + + + // decreasing + + template <typename I> + vec_p<mln_point(I)> + sort_points_decreasing_(metal::false_, const I& input) // general case + { + vec_p<mln_point(I)> v = convert::to_vec_p(input.domain()); + std::sort(v.hook_().begin(), v.hook_().end(), + value_point_greater_(input)); + return v; + } + + template <typename I> + vec_p<mln_point(I)> + sort_points_decreasing_(metal::true_, const I& input) // low quantization + { + typedef mln_vset(I) S; + const S& vset = input.values(); + const unsigned n = vset.nvalues(); + + // h + histo::data<S> h = histo::compute(input); + + // preparing output data + std::vector<unsigned> loc(vset.nvalues()); loc[n-1] = 0; for (unsigned i = n - 2; i != 0; --i) loc[i] = loc[i+1] + h[i+1]; - */ // computing output data std::vector<mln_point(I)> vec(input.npoints()); @@ -133,20 +179,32 @@ for_all(p) vec[loc[vset.index_of(input(p))]++] = p; - return vec; + vec_p<mln_point(I)> v; + v.hook_() = vec; + return v; } + } // end of namespace mln::level::impl + // Facades. + template <typename I> - std::vector<mln_point(I)> - sort_points(const Image& input) + vec_p<mln_point(I)> + sort_points_increasing(const Image& input) { mln_precondition(exact(input).has_data()); - return impl::sort_points(mln_is_value_lowq(I)(), exact(input)); + return impl::sort_points_increasing_(mln_is_value_lowq(I)(), exact(input)); } + template <typename I> + vec_p<mln_point(I)> + sort_points_decreasing(const Image& input) + { + mln_precondition(exact(input).has_data()); + return impl::sort_points_decreasing_(mln_is_value_lowq(I)(), exact(input)); + } # endif // ! MLN_INCLUDE_ONLY Index: mln/level/fill.hh --- mln/level/fill.hh (revision 1067) +++ mln/level/fill.hh (working copy) @@ -86,7 +86,7 @@ * \todo Take benefit from quantization when possible. */ template <typename I> - void fill(Image& ima, mln_value(I) (*f)(const mln_point(I)& p)); + void fill(Image& ima, mln_value(I) (*(&f))(const mln_point(I)& p)); /*! Fill the image \p ima with the values given by the array \p arr. @@ -191,8 +191,9 @@ template <typename I> void fill(Image& ima_, - mln_value(I) (*f)(const mln_point(I)& p)) + mln_value(I) (*(&f))(const mln_point(I)& p)) { + mln_precondition(f != 0); I& ima = exact(ima_); mln_precondition(ima.has_data()); mln_piter(I) p(ima.domain()); Index: mln/linear/sobel.hh --- mln/linear/sobel.hh (revision 1067) +++ mln/linear/sobel.hh (working copy) @@ -102,7 +102,7 @@ O temp(exact(input).domain()); sobel_v(input, temp); // output - arith::plus_inplace(output, temp); + arith::plus_inplace(output, temp); // FIXME: abs before plus!!! level::abs_inplace(output); } Index: mln/canvas/labeling.hh --- mln/canvas/labeling.hh (revision 0) +++ mln/canvas/labeling.hh (revision 0) @@ -0,0 +1,157 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_CANVAS_LABELING_HH +# define MLN_CANVAS_LABELING_HH + +/*! \file mln/canvas/labeling.hh + * + * \brief Connected component labeling of the object part in a binary + * image. + */ + +# include <mln/level/fill.hh> +# include <mln/level/sort_points.hh> + + +namespace mln +{ + + namespace canvas + { + + template <typename F> + struct labeling + { + F& f; + + typedef typename F::I I; + typedef typename F::N N; + typedef typename F::O O; + typedef typename F::S S; + typedef mln_point(I) point; + + // aux: + mln_ch_value(O, bool) deja_vu; + mln_ch_value(O, point) parent; + + labeling(F& f) + : f(f), + deja_vu(f.output.domain()), + parent(f.output.domain()) + { + run(); + } + + void run() + { + // init + { + f.nlabels = 0; + mln::level::fill(deja_vu, false); + f.init(); + } + // first pass + { + mln_fwd_piter(S) p(f.s); + mln_niter(N) n(f.nbh, p); + for_all(p) if (f.handles(p)) + { + make_set(p); + for_all(n) + if (f.input.has(n) && deja_vu(n)) + if (f.equiv(n, p)) + do_union(n, p); + else + f.do_no_union(n, p); + deja_vu(p) = true; + } + } + + // second pass + { + mln_bkd_piter(S) p(f.s); + mln_niter(N) n(f.nbh, p); + for_all(p) if (f.handles(p)) + { + if (is_root(p)) + { + if (f.labels(p)) + { + if (f.nlabels = mln_max(mln_value(O))) + { + f.status = false; + return; + } + f.output(p) = ++f.nlabels; + } + } + else + f.output(p) = f.output(parent(p)); + } + f.status = true; + } + + } // end of run() + + void make_set(const point& p) + { + parent(p) = p; + f.init_attr(p); + } + + bool is_root(const point& p) const + { + return parent(p) = p; + } + + point find_root(const point& x) + { + if (parent(x) = x) + return x; + else + return parent(x) = find_root(parent(x)); + } + + void do_union(const point& n, const point& p) + { + point r = find_root(n); + if (r != p) + { + parent(r) = p; + f.merge_attr(r, p); + } + } + + }; + + } // end of namespace mln::canvas + +} // end of namespace mln + + +#endif // ! MLN_CANVAS_LABELING_HH Index: mln/labeling/flat_zones.hh --- mln/labeling/flat_zones.hh (revision 0) +++ mln/labeling/flat_zones.hh (revision 0) @@ -0,0 +1,111 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_FLAT_ZONES_HH +# define MLN_LABELING_FLAT_ZONES_HH + +/*! \file mln/labeling/flat_zones.hh + * + * \brief Connected component labeling of the flat zones of an image. + */ + +# include <mln/labeling/base.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Connected component labeling of the flat zones of an image. + * + * \param[in] input The input image. + * \param[in] nbh The neighborhood to consider. + * \param[out] output The label image. + * \param[out] nlabels The number of labels. + * + * \return The number of labels. + */ + template <typename I, typename N, typename O> + bool flat_zones(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, + unsigned& nlabels); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I_, typename N_, typename O_> + struct flat_zones_ : base_<I_,N_,O_> + { + typedef mln_point(I_) P; + + // requirements from mln::canvas::labeling: + + typedef mln_pset(I_) S; + const S& s; + mln_value(O) nlabels; + bool status; + + bool equiv(const P& n, const P&) const { return input(n) = input(p); } + + // end of requirements + + flat_zones_(const I_& input, const N_& nbh, O_& output) + : base_<I_,N_,O_>(input, nbh, output), + s(input.domain()) + {} + }; + + } // end of namespace mln::labeling::impl + + + // Facade. + + template <typename I, typename N, typename O> + bool flat_zones(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, + unsigned& nlabels) + { + typedef impl::flat_zones_<I,N,O> F; + F f(exact(input), exact(nbh), exact(output)); + canvas::labeling<F> run(f); + nlabels = f.nlabels; + return f.status; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_FLAT_ZONES_HH Index: mln/labeling/level.hh --- mln/labeling/level.hh (revision 0) +++ mln/labeling/level.hh (revision 0) @@ -0,0 +1,118 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_LEVEL_HH +# define MLN_LABELING_LEVEL_HH + +/*! \file mln/labeling/level.hh + * + * \brief Connected component labeling of the image objects at a given + * level. + */ + +# include <mln/labeling/base.hh> +# include <mln/level/fill.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Connected component labeling of the image objects at a given + * level. + * + * \param[in] input The input image. + * \param[in] val The level to consider for the labeling. + * \param[in] nbh The neighborhood. + * \param[out] output The label image. + * \param[out] nlabels The number of labels. + * + * \return Succeed or not. + */ + template <typename I, typename N, typename O> + bool level(const Image& input, const mln_value(I)& val, const Neighborhood<N>& nbh, + Image<O>& output, unsigned& nlabels); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I_, typename N_, typename O_> + struct level_ : base_<I_,N_,O_> + { + typedef mln_point(I_) P; + + // requirements from mln::canvas::labeling: + + typedef mln_pset(I_) S; + const S& s; + + void init() { mln::level::fill(this->output, 0); } + bool handles(const P& p) const { return input(p) = val; } + bool equiv(const P& n, const P&) const { return input(n) = val; } + + // end of requirements + + const mln_value(I_)& val; + + level_(const I_& input, const mln_value(I_)& val, const N_& nbh, O_& output) + : base_<I_,N_,O_>(input, nbh, output), + s(input.domain()), + val(val) + {} + }; + + } // end of namespace mln::labeling::impl + + + // Facade. + + template <typename I, typename N, typename O> + bool level(const Image& input, const mln_value(I)& val, const Neighborhood<N>& nbh, + Image<O>& output, unsigned& nlabels) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + typedef impl::level_<I,N,O> F; + F f(exact(input), val, exact(nbh), exact(output)); + canvas::labeling<F> run(f); + nlabels = f.nlabels; + return f.status; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_LEVEL_HH Index: mln/labeling/foreground.hh --- mln/labeling/foreground.hh (revision 0) +++ mln/labeling/foreground.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_FOREGROUND_HH +# define MLN_LABELING_FOREGROUND_HH + +/*! \file mln/labeling/foreground.hh + * + * \brief Connected component labeling of the object part in a binary + * image. + */ + +# include <mln/labeling/level.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Connected component labeling of the object part in a binary + * image. + * + * \param[in] input The input image. + * \param[in] nbh The neighborhood to consider. + * \param[out] output The label image. + * \param[out] nlabels The number of labels. + * + * \return The number of labels. + */ + template <typename I, typename N, typename O> + bool foreground(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, + unsigned& nlabels); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename N, typename O> + bool foreground(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, + unsigned& nlabels) + { + return labeling::level(input, true, nbh, output, nlabels); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_FOREGROUND_HH Index: mln/labeling/regional_minima.hh --- mln/labeling/regional_minima.hh (revision 0) +++ mln/labeling/regional_minima.hh (revision 0) @@ -0,0 +1,120 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_REGIONAL_MINIMA_HH +# define MLN_LABELING_REGIONAL_MINIMA_HH + +/*! \file mln/labeling/regional_minima.hh + * + * \brief Connected component labeling of the regional minima of an + * image. + */ + +# include <mln/labeling/base.hh> +# include <mln/level/sort_points.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Connected component labeling of the regional minima of an + * image. + * + * \param[in] input The input image. + * \param[in] nbh The neighborhood to consider. + * \param[out] output The label image. + * + * \return The number of labels. + */ + template <typename I, typename N, typename O> + bool regional_minima(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, unsigned& nlabels); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I_, typename N_, typename O_> + struct regional_minima_ : base_<I_,N_,O_> + { + typedef mln_point(I_) P; + + // requirements from mln::canvas::labeling: + + typedef vec_p S; + S s; + + void init() { mln::level::fill(this->output, 0); + level::fill(attr, true); } + bool labels(const P& p) const { return attr(p); } + bool equiv(const P& n, const P& p) const { return input(n) = input(p); } + void do_no_union(const P& n, const P& p) { mln_invariant(input(n) < input(p)); + attr(p) = false; } + void merge_attr(const P& r, const P& p) { attr(p) = attr(p) && attr(r); } + + // end of requirements + + mln_ch_value(O_, bool) attr; + + regional_minima_(const I_& input, const N_& nbh, O_& output) + : base_<I_,N_,O_>(input, nbh, output), + s(level::sort_points_increasing(input)), + attr(output.domain()) + { + } + }; + + } // end of namespace mln::labeling::impl + + + // Facade. + + template <typename I, typename N, typename O> + bool regional_minima(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, unsigned& nlabels) + { + typedef impl::regional_minima_<I,N,O> F; + F f(exact(input), exact(nbh), exact(output)); + canvas::labeling<F> run(f); + nlabels = f.nlabels; + return f.status; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_REGIONAL_MINIMA_HH Index: mln/labeling/base.hh --- mln/labeling/base.hh (revision 0) +++ mln/labeling/base.hh (revision 0) @@ -0,0 +1,94 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_BASE_HH +# define MLN_LABELING_BASE_HH + +/*! \file mln/labeling/base.hh + * + * \brief Base class for labeling functors. + */ + +# include <mln/core/concept/image.hh> +# include <mln/core/concept/neighborhood.hh> +# include <mln/canvas/labeling.hh> + + +namespace mln +{ + + namespace labeling + { + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + /// Base class for labeling functors. + template <typename I_, typename N_, typename O_> + struct base_ + { + typedef I_ I; + typedef N_ N; + typedef O_ O; + typedef mln_point(I_) P; + + const I& input; + const N& nbh; + O& output; + + mln_value(O_) nlabels; + bool status; + + base_(const I_& input, const N_& nbh, O_& output) + : input(input), + nbh(nbh), + output(output) + { + } + + // Defaults. + + bool handles(const P&) const { return true; } + bool labels(const P&) const { return true; } + void init() {} + void do_no_union(const P&, const P&) {} + void init_attr(const P&) {} + void merge_attr(const P&, const P&) {} + }; + + } // end of namespace mln::labeling::impl + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_BASE_HH Index: mln/labeling/regional_maxima.hh --- mln/labeling/regional_maxima.hh (revision 0) +++ mln/labeling/regional_maxima.hh (revision 0) @@ -0,0 +1,120 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_REGIONAL_MAXIMA_HH +# define MLN_LABELING_REGIONAL_MAXIMA_HH + +/*! \file mln/labeling/regional_maxima.hh + * + * \brief Connected component labeling of the regional maxima of an + * image. + */ + +# include <mln/labeling/base.hh> +# include <mln/level/sort_points.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Connected component labeling of the regional maxima of an + * image. + * + * \param[in] input The input image. + * \param[in] nbh The neighborhood to consider. + * \param[out] output The label image. + * + * \return The number of labels. + */ + template <typename I, typename N, typename O> + bool regional_maxima(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, unsigned& nlabels); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I_, typename N_, typename O_> + struct regional_maxima_ : base_<I_,N_,O_> + { + typedef mln_point(I_) P; + + // requirements from mln::canvas::labeling: + + typedef vec_p S; + S s; + + void init() { mln::level::fill(this->output, 0); + level::fill(attr, true); } + bool labels(const P& p) const { return attr(p); } + bool equiv(const P& n, const P& p) const { return input(n) = input(p); } + void do_no_union(const P& n, const P& p) { mln_invariant(input(n) > input(p)); + attr(p) = false; } + void merge_attr(const P& r, const P& p) { attr(p) = attr(p) && attr(r); } + + // end of requirements + + mln_ch_value(O_, bool) attr; + + regional_maxima_(const I_& input, const N_& nbh, O_& output) + : base_<I_,N_,O_>(input, nbh, output), + s(level::sort_points_decreasing(input)), + attr(output.domain()) + { + } + }; + + } // end of namespace mln::labeling::impl + + + // Facade. + + template <typename I, typename N, typename O> + bool regional_maxima(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, unsigned& nlabels) + { + typedef impl::regional_maxima_<I,N,O> F; + F f(exact(input), exact(nbh), exact(output)); + canvas::labeling<F> run(f); + nlabels = f.nlabels; + return f.status; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_REGIONAL_MAXIMA_HH Index: mln/labeling/background.hh --- mln/labeling/background.hh (revision 0) +++ mln/labeling/background.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_BACKGROUND_HH +# define MLN_LABELING_BACKGROUND_HH + +/*! \file mln/labeling/background.hh + * + * \brief Connected component labeling of the background in a binary + * image. + */ + +# include <mln/labeling/level.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Connected component labeling of the background in a binary + * image. + * + * \param[in] input The input image. + * \param[in] nbh The neighborhood to consider. + * \param[out] output The label image. + * \param[out] nlabels The number of labels. + * + * \return The number of labels. + */ + template <typename I, typename N, typename O> + bool background(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, + unsigned& nlabels); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename N, typename O> + bool background(const Image& input, const Neighborhood<N>& nbh, + Image<O>& output, + unsigned& nlabels) + { + return labeling::level(input, false, nbh, output, nlabels); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_BACKGROUND_HH

1 0

1067: Add room in sandbox.
by Thierry Geraud 03 Sep '07

03 Sep '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add room in sandbox. * sandbox/duhamel: New. * sandbox/levillain: New. * sandbox/nivault: New. * sandbox/jardonnet: New. * sandbox/geraud: New. * sandbox/garrigues: New. * sandbox/cxxcompilation: Rename as... * sandbox/ballas: ...this. compilation_unit.rb | 56 -------------------- methods | 104 -------------------------------------- test.cc | 69 ------------------------- vaucanson_bench | 141 ---------------------------------------------------- 4 files changed, 370 deletions(-) Index: sandbox/cxxcompilation/compilation_unit.rb --- sandbox/cxxcompilation/compilation_unit.rb (revision 1066) +++ sandbox/cxxcompilation/compilation_unit.rb (working copy) @@ -1,56 +0,0 @@ -#! /usr/bin/ruby - -#Create a compilation unit file from a .cc file - -#USAGE: ./compilation_unit.rb file.cc - - -class CompilationUnit - attr_reader :sourceFileName, :name, :namespaceName - - public - def initialize(sourceFileName) - - - @sourceFileName = sourceFileName - @name = sourceFileName.gsub(/.cc\z/, ".unit.cc") - @namespaceName = "__instanciator_code" - - if not File.exist?(@name) then - self.createCompilationUnitFile - end - end - - def update - createCompilationUnitFile - end - - #Create UnitCompilationfile from source - def createCompilationUnitFile - sourceFile = File.new("#{@sourceFileName}", "r") - destinationFile = File.new("#{@name}", "w") - - # Copy usefull include files into cache file. - sourceFile.each_line do |line| - destinationFile.puts(line) if line =~ /#include/ - end - - # trash namespace - destinationFile.puts("namespace #{@namespaceName} {") - - # puts code line into trash namespace - sourceFile.close - sourceFile = File.new("#{@sourceFileName}", "r") - sourceFile.each_line do |line| - destinationFile.puts(line) if not (line =~ /#include/) - end - - # end of namespace - destinationFile.puts("}") - - sourceFile.close - destinationFile.close - end -end - -unit = CompilationUnit.new(ARGV[0]) Index: sandbox/cxxcompilation/test.cc --- sandbox/cxxcompilation/test.cc (revision 1066) +++ sandbox/cxxcompilation/test.cc (working copy) @@ -1,69 +0,0 @@ -// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, -// Boston, MA 02111-1307, USA. -// -// As a special exception, you may use this file as part of a free -// software library without restriction. Specifically, if other files -// instantiate templates or use macros or inline functions from this -// file, or you compile this file and link it with other files to -// produce an executable, this file does not by itself cause the -// resulting executable to be covered by the GNU General Public -// License. This exception does not however invalidate any other -// reasons why the executable file might be covered by the GNU General -// Public License. - -#include <oln/core/2d/image2d.hh> -#include <oln/core/3d/image3d.hh> -#include <oln/core/1d/image1d.hh> -#include <oln/level/fill.hh> - - -using namespace oln; - -int main(void) -{ - image1d<char> ima1d1(5); - image1d<int> ima1d2(5); - image1d<float> ima1d3(5); - image1d<double> ima1d4(5); - - level::fill(inplace(ima1d1), 5); - level::fill(inplace(ima1d2), 5); - level::fill(inplace(ima1d3), 5); - level::fill(inplace(ima1d4), 5); - - image2d<char> ima2d1(5, 5); - image2d<int> ima2d2(5, 5); - image2d<float> ima2d3(5, 5); - image2d<double> ima2d4(5, 5); - - level::fill(inplace(ima2d1), 5); - level::fill(inplace(ima2d2), 5); - level::fill(inplace(ima2d3), 5); - level::fill(inplace(ima2d4), 5); - - image3d<char> ima3d1(5, 5, 5); - image3d<int> ima3d2(5, 5, 5); - image3d<float> ima3d3(5, 5, 5); - image3d<double> ima3d4(5, 5, 5); - - level::fill(inplace(ima3d1), 5); - level::fill(inplace(ima3d2), 5); - level::fill(inplace(ima3d3), 5); - level::fill(inplace(ima3d4), 5); - - return 0; -} Index: sandbox/cxxcompilation/methods --- sandbox/cxxcompilation/methods (revision 1066) +++ sandbox/cxxcompilation/methods (working copy) @@ -1,104 +0,0 @@ - -*- Outline -*- - -* without optimization flags - -** Benchmark - -compilation: 2.131 -execution: 18.538 -total: 22.670 - - -* O1 - -** Benchmark -compilation: 3.616 -execution: 4.893 -total: 8.509 - -* O2 -** Benchmark -compilation: 4.610 -execution: 3.781 -total: 8.391 - -* 03 -compilation: 5.071 -execution: 1.567 -total: 6.638 - - - - -The next part introduces different method to speed up C++ compilation time. - -Test are made with union_find.cc file. - -* precompiled header (without optimization option) - -** Description - -Generate precompiled header (.gch) which can parsed in a faster way by g++. - - -How to automize header precompilation, just make a precompilation of usefull header ? - -** Benchmark - -compilation: 3.733 -execution: 18.119 -total: 21.852 - -* ccache (without optimization option) - -** Description - -"ccache is a compiler cache. It acts as a caching pre-processor to C/C++ compilers, using the -E compiler switch and a hash to detect when a compilation can be satisfied from cache. This often results in a 5 to 10 times speedup in common compilations." http://cache.samba.org - -** Benchmark - -* Vacauson Way (without optimization option) - -** Description - -cf: http://www.lrde.epita.fr/cgi-bin/twiki/view/Know/SpeedUpCxxCompilation - - -*** total recompilation protocol of source.cc: ---> (1) compile source.cc to "ref".o (cache used for function addresse reference) ---> (2) source.cc -> source.o with -DINTERFACE_ONLY (real program) ---> (3) links source.o to "ref".o - -*** Protocole: ---> do (1) ---> do (2) and (3) as long as there is no linkage error, else redo (1) - - -*** Problems: - -You must recompile the cache when you use an new algorithm/data type in your program. ---> solution: ask developper to write usefull algorithm/data types/includes at the start of the programm and uses template instantiation - - -Automatization?? ---> how deals with several files ---> how deals with missing .hh files ---> differenciate link error from other error - -***Others things: - -wrapper script or Makefile??? ---> script used by Makefile - -** Benchmark - -*** first compilation or total recompilation is longer than a normal compilation - -you need to compile program two times - - -*** next time when cache recompilation is not needed - -compilation: 0.200 -execution: 17.875 -toto: 18.075 Index: sandbox/cxxcompilation/vaucanson_bench --- sandbox/cxxcompilation/vaucanson_bench (revision 1066) +++ sandbox/cxxcompilation/vaucanson_bench (working copy) @@ -1,141 +0,0 @@ - -*- Outline -*- - -* Summary: - - This files present c++ compilation benchmark with Vaucanson method. - -* Vaucanson method: - -** Files used: -*** source.cc -client code - -*** source.unit.cc -This files contains instantiations of templated data and algorithms used by the client code. - -A Compilation unit copies #include directives used by source.cc -Furthermore, it copies client source code into a trash name's (in order to instantiated templates). - -But other method exists to create compilation unit(cf .hcc). - - -** Compilation process: - -*** total recompilation - ---> (1) compile source.unit.cc to an object file (source.unit.o) (cache used to find function address reference). - ---> (2) compile source.cc to source.o with -DINTERFACE_ONLY (or INCLUDE_ONLY, we want to compile just the interface the objects). - ---> (3) link source.o with source.unit.o - -*** Protocol: ---> do (1) ---> do (2) and (3) as long as there are no linkage errors, else redo (1) - - - - -* Benchmark: - -** With Olena: - -compile command: -g++ -W -Wall -Werror -ansi -pedantic -Ipath/metalic -Ipath/olena -Ipath/extended - -dimension of image used for test: 512 * 512. -Note: We can add optimization flag to speed up execution time. - - -******************************************************************************* -** File: oln/morpho/Rd/union_find.cc - -*** normal compilation: -compilation time: 4.110 -execution time: 42.893 -total time: 47.003 - -*** With Vaucanson method: - -**** total recompilation: - -compilation time: 6.749 ---> (1) : 4.062 ---> (2) : 2.524 ---> (3) : 0.163 - -execution time: 42.058 -total time: 48.807 - -~= 2 second slower than a normal compilation - -**** Usual recompilation - -compilation time: 2.702 ---> (2) : 2.542 ---> (3) : 0.160 - -execution time:42.060 -total time: 44.762 - -******************************************************************************* -** oln/morpho/Rd/queue_based.cc - -*** normal compilation: -compilation time: 4.296 -execution time: 35.836 -total time: 40.132 - -*** With Vaucanson method: - -**** total recompilation: - -compilation time: 7.187 ---> (1) : 4.378 ---> (2) : 2.636 ---> (3) : 0.173 - -execution time: 35.836 -total time: 43.023 - -**** Usual recompilation - -compilation time: 2.809 ---> (2) : 2.636 ---> (3) : 0.173 - -******************************************************************************* -** test.cc - -(declare and fill 12 differents image types) - -*** normal compilation: -compilation time: 25.585 -execution time: 0.006 -total time: 25.596 - -*** With Vaucanson method: - -**** total recompilation: - -compilation time: 45.087 ---> (1) : 25.378 ---> (2) : 19.318 ---> (3) : 0.391 - -execution time: 0.006 -total time: 45.093 - -**** Usual recompilation - -compilation time: 19.664 ---> (2) : 19.259 ---> (3) : 0.405 - -** with morpher - -FIXME - -*** With Milena - -FIXME

1 0

1066: Fix doc.
by Thierry Geraud 03 Sep '07

03 Sep '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Fix doc. * tests/t_image.cc, * tests/local_convolve.cc, * tests/mean.cc, * tests/pw_image.cc, * tests/linear_lap.cc, * doc/Doxyfile.in, * mln/fun/v2v/id.hh, * mln/core/sparse_encode.hh, * mln/core/internal/dpoints_base.hh, * mln/core/rle_encode.hh, * mln/make/w_window.hh: Fix doc. * mln/linear/hconvolve.hh: Remove; obsolete. doc/Doxyfile.in | 2 ++ mln/core/internal/dpoints_base.hh | 2 +- mln/core/rle_encode.hh | 2 +- mln/core/sparse_encode.hh | 2 +- mln/fun/v2v/id.hh | 4 ++-- mln/make/w_window.hh | 5 ++--- tests/linear_lap.cc | 2 +- tests/local_convolve.cc | 4 ++-- tests/mean.cc | 4 ++-- tests/pw_image.cc | 4 ++-- tests/t_image.cc | 2 +- 11 files changed, 17 insertions(+), 16 deletions(-) Index: tests/t_image.cc --- tests/t_image.cc (revision 1065) +++ tests/t_image.cc (working copy) @@ -25,7 +25,7 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/+t_image.cc +/*! \file tests/t_image.cc * * \brief Tests on mln::t_image. */ Index: tests/local_convolve.cc --- tests/local_convolve.cc (revision 1065) +++ tests/local_convolve.cc (working copy) @@ -25,9 +25,9 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/convolve.cc +/*! \file tests/local_convolve.cc * - * \brief Tests on mln::linear::convolve. + * \brief Tests on mln::linear::local::convolve. */ #include <mln/core/image2d_b.hh> Index: tests/mean.cc --- tests/mean.cc (revision 1065) +++ tests/mean.cc (working copy) @@ -25,9 +25,9 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/assign.cc +/*! \file tests/mean.cc * - * \brief Tests on mln::level::assign. + * \brief Tests on mln::estim::mean. */ #include <mln/core/image2d_b.hh> Index: tests/pw_image.cc --- tests/pw_image.cc (revision 1065) +++ tests/pw_image.cc (working copy) @@ -25,9 +25,9 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/fimage.cc +/*! \file tests/pw_image.cc * - * \brief Tests on mln::fimage. + * \brief Tests on mln::pw::image. */ #include <mln/fun/p2b/chess.hh> Index: tests/linear_lap.cc --- tests/linear_lap.cc (revision 1065) +++ tests/linear_lap.cc (working copy) @@ -25,7 +25,7 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/linear_lAP.cc +/*! \file tests/linear_lap.cc * * \brief Tests on mln::linear::lap_4. */ Index: doc/Doxyfile.in --- doc/Doxyfile.in (revision 1065) +++ doc/Doxyfile.in (working copy) @@ -1042,6 +1042,7 @@ # instead of the = operator. PREDEFINED = \ + "mlc_unqualif(T)=typename mln::metal::unqualif<T>::ret" \ "mln_piter(T)=typename T::piter" \ "mln_fwd_piter(T)=typename T::fwd_piter" \ "mln_bkd_piter(T)=typename T::bkd_piter" \ @@ -1059,6 +1060,7 @@ "mln_value(T)=typename T::value" \ "mln_qlf_value(T)=typename T::qlf_value" \ "mln_pset(T)=typename T::pset" \ + "mln_sum(T)=typename mln::value::props<T>::sum" \ "mln_vset(T)=typename T::vset" \ "mln_rvalue(T)=typename T::rvalue" \ "mln_lvalue(T)=typename T::lvalue" \ Index: mln/fun/v2v/id.hh --- mln/fun/v2v/id.hh (revision 1065) +++ mln/fun/v2v/id.hh (working copy) @@ -28,9 +28,9 @@ #ifndef MLN_FUN_V2V_ID_HH # define MLN_FUN_V2V_ID_HH -/*! \file mln/fun/id.hh +/*! \file mln/fun/v2v/id.hh * - * \brief FIXME. + * \brief Identity function. */ # include <mln/fun/internal/selector.hh> Index: mln/core/sparse_encode.hh --- mln/core/sparse_encode.hh (revision 1065) +++ mln/core/sparse_encode.hh (working copy) @@ -28,7 +28,7 @@ #ifndef MLN_CORE_SPARSE_ENCODE_HH # define MLN_CORE_SPARSE_ENCODE_HH -/*! \file mln/core/sparse_image.hh +/*! \file mln/core/sparse_encode.hh * * \brief FIXME */ Index: mln/core/internal/dpoints_base.hh --- mln/core/internal/dpoints_base.hh (revision 1065) +++ mln/core/internal/dpoints_base.hh (working copy) @@ -28,7 +28,7 @@ #ifndef MLN_CORE_INTERNAL_DPOINTS_BASE_HH # define MLN_CORE_INTERNAL_DPOINTS_BASE_HH -/*! \file mln/core/internal/dpoints_base_.hh +/*! \file mln/core/internal/dpoints_base.hh * * \brief Definition of a base class for classes based on a set of dpoints. */ Index: mln/core/rle_encode.hh --- mln/core/rle_encode.hh (revision 1065) +++ mln/core/rle_encode.hh (working copy) @@ -28,7 +28,7 @@ #ifndef MLN_CORE_RLE_ENCODE_HH # define MLN_CORE_RLE_ENCODE_HH -/*! \file mln/core/sparse_image.hh +/*! \file mln/core/rle_encode.hh * * \brief FIXME */ Index: mln/make/w_window.hh --- mln/make/w_window.hh (revision 1065) +++ mln/make/w_window.hh (working copy) @@ -47,9 +47,8 @@ /*! \brief Create a mln::w_window from a window and a weight * function. * - * \param[in] weights Array. - * - * \pre The array size, \c M, has to be a square of an odd integer. + * \param[in] win The window. + * \param[in] wei A weight function. * * \return A weighted window. */

1 0

1065: Fix missing file.
by Thierry Geraud 03 Sep '07

03 Sep '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Fix missing file. * mln/value/cast.hh: New. labeling/+foreground.hh | 106 ++++++++++++++++++++++++++++++++++++++++++++++++ value/cast.hh | 85 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 191 insertions(+) Index: mln/value/cast.hh --- mln/value/cast.hh (revision 0) +++ mln/value/cast.hh (revision 0) @@ -0,0 +1,85 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_VALUE_CAST_HH +# define MLN_VALUE_CAST_HH + +/*! \file mln/value/cast.hh + * \brief Definition of the mln::value::cast routine. + */ + +# include <mln/core/concept/value.hh> + + +namespace mln +{ + + namespace value + { + + + /// Cast a value \p src from type \c Src to type \c Dest. + template <typename Dest, typename Src> + Dest cast(const Src& src); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace internal + { + + template <typename S> + const S& + cast_(const S& src, ...) + { + return src; + } + + template <typename T, typename S> + typename S::equiv + cast_(const T&, const Value<S>& src) + { + return exact(src); + } + + } // end of namespace mln::value::internal + + template <typename Dest, typename Src> + Dest cast(const Src& src) + { + return internal::cast_(src, src); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::value + +} // end of namespace mln + + +#endif // ! MLN_VALUE_CAST_HH Index: mln/labeling/+foreground.hh --- mln/labeling/+foreground.hh (revision 0) +++ mln/labeling/+foreground.hh (revision 0) @@ -0,0 +1,106 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LABELING_FOREGROUND_HH +# define MLN_LABELING_FOREGROUND_HH + +/*! \file mln/labeling/foreground.hh + * + * \brief Foreground a function-object onto image pixel values. + */ + +# include <mln/core/concept/image.hh> +# include <mln/core/concept/function.hh> + + +namespace mln +{ + + namespace labeling + { + + /*! Foreground a function-object to the image \p input. + * + * \param[in,out] input The input image. + * \param[in] f The function-object. + * + * This routine runs: \n + * for all p of \p input, \p input(p) = \p f( \p input(p) ) \n + * + * This routine is equivalent to labeling::tranform(input, f, input) + * but it is faster since a single iterator is required. + * + * \todo Add versions for lowq images. + */ + template <typename I, typename F> + void foreground(Image& input, const Function_v2v<F>& f); + + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename F> + void foreground_(Image& input_, const F& f) + { + I& input = exact(input_); + mln_piter(I) p(input.domain()); + for_all(p) + input(p) = f(input(p)); + } + + template <typename I, typename F> + void foreground_(Fast_Image& input_, const F& f) + { + I& input = exact(input_); + mln_pixter(I) pxl(input); + for_all(pxl) + pxl.val() = f(pxl.val()); + } + + } // end of namespace mln::labeling::impl + + + // Facade. + + template <typename I, typename F> + void foreground(Image& input, const Function_v2v<F>& f) + { + mln_precondition(exact(input).has_data()); + impl::foreground_(exact(input), exact(f)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::labeling + +} // end of namespace mln + + +#endif // ! MLN_LABELING_FOREGROUND_HH

1 0

1064: Augment morphology.
by Thierry Geraud 31 Aug '07

31 Aug '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Augment morphology. * mln/value/cast.hh: Rename as... * mln/core/cast_image.hh: ...this. Update. * mln/core/concept/value.hh (cast): Move to and rename as... * mln/value/cast.hh (cast_image): ...this, here. * tests/cast_image.cc: Update. * mln/morpho/thickening.hh: New. * mln/morpho/laplacian.hh: New. * mln/morpho/thick_miss.hh: New. * mln/morpho/thin_fit.hh: New. * mln/morpho/thinning.hh: New. * tests/morpho_thinning.cc: New. * tests/morpho_laplacian.cc: New. * tests/morpho_hit_or_miss.cc: Update. * mln/morpho/plus.hh (mln_postcondition): Remove. * mln/morpho/minus.hh: Remove dead lines. * mln/morpho/hit_or_miss.hh: Augment doc. Add postconditions. Add a FIXME. * mln/io/save_pgm.hh: Rewrite. * mln/arith/plus.hh (plus_cst, plus_cst_inplace): New. * img/picasso.pgm: Invert. img/picasso.pgm | 0 mln/arith/plus.hh | 31 ++++++++++++++ mln/core/cast_image.hh | 50 +++++++++++------------- mln/core/concept/value.hh | 48 +---------------------- mln/io/save_pgm.hh | 72 +++++++++++++++++++++++++++++++--- mln/morpho/hit_or_miss.hh | 41 +++++++++++++++---- mln/morpho/laplacian.hh | 83 ++++++++++++++++++++++++++++++++++++++++ mln/morpho/minus.hh | 3 - mln/morpho/plus.hh | 3 - mln/morpho/thick_miss.hh | 79 ++++++++++++++++++++++++++++++++++++++ mln/morpho/thickening.hh | 79 ++++++++++++++++++++++++++++++++++++++ mln/morpho/thin_fit.hh | 79 ++++++++++++++++++++++++++++++++++++++ mln/morpho/thinning.hh | 91 ++++++++++++++++++++++++++++++++++++++++++++ tests/cast_image.cc | 6 +- tests/morpho_hit_or_miss.cc | 6 +- tests/morpho_laplacian.cc | 63 ++++++++++++++++++++++++++++++ tests/morpho_thinning.cc | 69 +++++++++++++++++++++++++++++++++ 17 files changed, 705 insertions(+), 98 deletions(-) Index: tests/cast_image.cc --- tests/cast_image.cc (revision 1063) +++ tests/cast_image.cc (working copy) @@ -27,14 +27,14 @@ /*! \file tests/cast_image.cc * - * \brief Tests on mln::value::cast_image. + * \brief Tests on mln::cast_image. */ #include <mln/core/image2d_b.hh> #include <mln/fun/p2b/chess.hh> #include <mln/level/fill.hh> #include <mln/debug/println.hh> -#include <mln/value/cast.hh> +#include <mln/core/cast_image.hh> int main() @@ -44,5 +44,5 @@ image2d_b<bool> ima(8, 8); level::fill(ima, fun::p2b::chess); debug::println(ima); - debug::println( value::cast<int>(ima) ); + debug::println( cast_image<int>(ima) ); } Index: tests/morpho_thinning.cc --- tests/morpho_thinning.cc (revision 0) +++ tests/morpho_thinning.cc (revision 0) @@ -0,0 +1,69 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/*! \file tests/morpho_thinning.cc + * + * \brief Test on mln::morpho::thinning. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/value/int_u8.hh> + +#include <mln/core/win/rectangle2d.hh> +#include <mln/core/window2d.hh> + +#include <mln/io/load_pgm.hh> +#include <mln/io/save_pgm.hh> + +#include <mln/morpho/thinning.hh> + + +int main() +{ + using namespace mln; + using value::int_u8; + + bool fg[] = { 0, 0, 0, + 0, 1, 0, + 0, 0, 0 }; + window2d win_fg = make::window2d(fg); + + bool bg[] = { 0, 0, 0, + 1, 0, 1, + 0, 0, 0 }; + window2d win_bg = make::window2d(bg); + + border::thickness = 2; + + image2d_b<int_u8> + pic = io::load_pgm("../img/picasso.pgm"), + out(pic.domain()); + + morpho::thinning(pic, win_fg, win_bg, out); + + io::save_pgm(out, "out.pgm"); +} Index: tests/morpho_hit_or_miss.cc --- tests/morpho_hit_or_miss.cc (revision 1063) +++ tests/morpho_hit_or_miss.cc (working copy) @@ -76,10 +76,10 @@ border::thickness = 2; image2d_b<int_u8> - lena = io::load_pgm("../img/picasso.pgm"), - out(lena.domain()); + pic = io::load_pgm("../img/picasso.pgm"), + out(pic.domain()); - morpho::hit_or_miss(lena, win_hit, win_miss, out); + morpho::hit_or_miss(pic, win_hit, win_miss, out); io::save_pgm(out, "out.pgm"); } Index: tests/morpho_laplacian.cc --- tests/morpho_laplacian.cc (revision 0) +++ tests/morpho_laplacian.cc (revision 0) @@ -0,0 +1,63 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/*! \file tests/morpho_laplacian.cc + * + * \brief Test on mln::morpho::laplacian. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/core/win/rectangle2d.hh> + +#include <mln/io/load_pgm.hh> +#include <mln/io/save_pgm.hh> + +#include <mln/value/int_u_sat.hh> +#include <mln/core/cast_image.hh> +#include <mln/pw/image.hh> +#include <mln/arith/plus.hh> + +#include <mln/morpho/laplacian.hh> + + + +int main() +{ + using namespace mln; + using value::int_u8; + + win::rectangle2d rect(5, 5); + border::thickness = 2; + + image2d_b<int_u8> lena = io::load_pgm("../img/tiny.pgm"); + image2d_b<int> lap(lena.domain()); + morpho::laplacian(lena, rect, lap); + + image2d_b< value::int_u_sat<8> > out(lena.domain()); + arith::plus_cst(lap, 128, out); + io::save_pgm(out, "out.pgm"); +} Index: mln/core/cast_image.hh --- mln/core/cast_image.hh (revision 1063) +++ mln/core/cast_image.hh (working copy) @@ -25,29 +25,27 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_VALUE_CAST_HH -# define MLN_VALUE_CAST_HH +#ifndef MLN_CORE_CAST_IMAGE_HH +# define MLN_CORE_CAST_IMAGE_HH -/*! \file mln/value/cast.hh +/*! \file mln/core/cast_image.hh * * \brief Definition of an image class FIXME */ # include <mln/core/concept/image.hh> # include <mln/value/set.hh> +# include <mln/value/cast.hh> namespace mln { - namespace value - { - /*! \brief FIXME * */ template <typename T, typename I> - struct cast_image : public mln::internal::image_base_< mln_pset(I), cast_image<T,I> > + struct cast_image_ : public mln::internal::image_base_< mln_pset(I), cast_image_<T,I> > { /// Point_Site associated type. typedef mln_psite(I) psite; @@ -62,14 +60,14 @@ typedef T rvalue; /// Return type of read-write access. - typedef void lvalue; // FIXME + typedef T lvalue; /// Value set associated type. typedef mln::value::set<T> vset; /// Constructor. - cast_image(const Image& ima); + cast_image_(const Image& ima); /// Test if this image has been initialized. @@ -84,8 +82,8 @@ /// Read-only access of pixel value at point site \p p. T operator()(const psite& p) const; - /// Read-write access is present but disabled. - void operator()(const psite&); + /// Mutable access is only OK for reading (not writing). + T operator()(const psite& p); /// Give the set of values of the image. const vset& values() const; @@ -104,11 +102,11 @@ template <typename T, typename I> - cast_image<T,I> - cast(const Image& ima) + cast_image_<T,I> + cast_image(const Image& ima) { mln_precondition(exact(ima).has_data()); - cast_image<T,I> tmp(ima); + cast_image_<T,I> tmp(ima); return tmp; } @@ -117,59 +115,57 @@ # ifndef MLN_INCLUDE_ONLY template <typename T, typename I> - cast_image<T,I>::cast_image(const Image& ima) + cast_image_<T,I>::cast_image_(const Image& ima) : ima_(exact(ima)) { mln_precondition(exact(ima).has_data()); } template <typename T, typename I> - bool cast_image<T,I>::has_data() const + bool cast_image_<T,I>::has_data() const { mln_invariant(ima_.has_data()); return true; } template <typename T, typename I> - bool cast_image<T,I>::owns_(const psite& p) const + bool cast_image_<T,I>::owns_(const psite& p) const { return ima_.owns_(p); } template <typename T, typename I> const mln_pset(I)& - cast_image<T,I>::domain() const + cast_image_<T,I>::domain() const { return ima_.domain(); } template <typename T, typename I> T - cast_image<T,I>::operator()(const psite& p) const + cast_image_<T,I>::operator()(const psite& p) const { mln_precondition(ima_.owns_(p)); - return ima_(p); + return mln::value::cast<T>( ima_(p) ); } template <typename T, typename I> - void - cast_image<T,I>::operator()(const psite&) + T + cast_image_<T,I>::operator()(const psite& p) { - mln_invariant(0); // FIXME: Turn into a compile-time error... + return mln::value::cast<T>( ima_(p) ); } template <typename T, typename I> const mln::value::set<T>& - cast_image<T,I>::values() const + cast_image_<T,I>::values() const { return vset::the(); } # endif // ! MLN_INCLUDE_ONLY - } // end of namespace mln::value - } // end of namespace mln -#endif // ! MLN_VALUE_CAST_HH +#endif // ! MLN_CORE_CAST_IMAGE_HH Index: mln/core/concept/value.hh --- mln/core/concept/value.hh (revision 1063) +++ mln/core/concept/value.hh (working copy) @@ -63,17 +63,6 @@ - namespace value - { - - /// Cast a value \p src from type \c Src to type \c Dest. - template <typename Dest, typename Src> - Dest cast(const Src& src); - - } // end of namespace mln::value - - - # ifndef MLN_INCLUDE_ONLY template <typename E> @@ -99,43 +88,12 @@ return exact(*this); } - - namespace value - { - - namespace internal - { - - template <typename S> - const S& - cast_(const S& src, ...) - { - return src; - } - - template <typename T, typename S> - typename S::equiv - cast_(const T&, const Value<S>& src) - { - return exact(src); - } - - } // end of namespace mln::value::internal - - - template <typename Dest, typename Src> - Dest cast(const Src& src) - { - return internal::cast_(src, src); - } - - - } // end of namespace mln::value - - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln +# include <mln/value/cast.hh> + + #endif // ! MLN_CORE_CONCEPT_VALUE_HH Index: mln/morpho/thickening.hh --- mln/morpho/thickening.hh (revision 0) +++ mln/morpho/thickening.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_THICKENING_HH +# define MLN_MORPHO_THICKENING_HH + +/*! \file mln/morpho/thickening.hh + * + * \brief Morphological thickening. + */ + +# include <mln/morpho/hit_or_miss.hh> + + +namespace mln +{ + + namespace morpho + { + + + /*! Morphological thickening. + * + * This operator is THICK_B = Id + HMT_B, where B = (Bfg, Bbg). + */ + template <typename I, typename Wfg, typename Wbg, typename O> + void thickening(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename Wfg, typename Wbg, typename O> + void thickening(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + mln_precondition(exact(win_bg).is_centered()); + mln_precondition(set::inter(exact(win_fg), exact(win_bg)).is_empty()); + + O temp(exact(input).domain()); + hit_or_miss(input, win_fg, win_bg, temp); + morpho::plus(input, temp, output); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_THICKENING_HH Index: mln/morpho/plus.hh --- mln/morpho/plus.hh (revision 1063) +++ mln/morpho/plus.hh (working copy) @@ -85,10 +85,7 @@ { mln_precondition(exact(rhs).domain() = exact(lhs).domain()); mln_precondition(exact(output).domain() = exact(lhs).domain()); - impl::plus_(mln_value_kind(I)(), exact(lhs), exact(rhs), output); - - mln_postcondition(output <= lhs); } template <typename I, typename J> Index: mln/morpho/laplacian.hh --- mln/morpho/laplacian.hh (revision 0) +++ mln/morpho/laplacian.hh (revision 0) @@ -0,0 +1,83 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_LAPLACIAN_HH +# define MLN_MORPHO_LAPLACIAN_HH + +/*! \file mln/morpho/laplacian.hh + * + * \brief Morphological laplacian. + * + * \todo Save memory. + */ + +# include <mln/morpho/includes.hh> + + +namespace mln +{ + + namespace morpho + { + + /*! Morphological laplacian. + * + * This operator is (d_B - Id) - (Id - e_B). + */ + template <typename I, typename W, typename O> + void laplacian(const Image& input, const Window<W>& win, + Image<O>& output); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename W, typename O> + void laplacian(const Image& input, const Window<W>& win, Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + mln_precondition(! exact(win).is_empty()); + + dilation(input, win, output); // output = dilation + morpho::minus_inplace(output, input); // now output = dilation - input + + O temp(exact(input).domain()); + { + O temp_(exact(input).domain()); + erosion(input, win, temp_); // temp_ = erosion + morpho::minus(input, temp_, temp); // temp = input - erosion + } + morpho::minus_inplace(output, temp); // now output = (dilation - input) - (input - erosion) + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_LAPLACIAN_HH Index: mln/morpho/minus.hh --- mln/morpho/minus.hh (revision 1063) +++ mln/morpho/minus.hh (working copy) @@ -64,9 +64,7 @@ const Image& lhs, const Image<J>& rhs, Image<O>& output) { - // FIXME: mln_precondition(rhs <= lhs); return logical::and_not(lhs, rhs, output); - // FIXME: mln_postcondition(output <= lhs); } template <typename K, typename I, typename J, typename O> @@ -87,7 +85,6 @@ { mln_precondition(exact(rhs).domain() = exact(lhs).domain()); mln_precondition(exact(output).domain() = exact(lhs).domain()); - impl::minus_(mln_value_kind(I)(), exact(lhs), exact(rhs), output); } Index: mln/morpho/thick_miss.hh --- mln/morpho/thick_miss.hh (revision 0) +++ mln/morpho/thick_miss.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_THICK_MISS_HH +# define MLN_MORPHO_THICK_MISS_HH + +/*! \file mln/morpho/thick_miss.hh + * + * \brief Morphological thick-miss. + */ + +# include <mln/morpho/hit_or_miss.hh> + + +namespace mln +{ + + namespace morpho + { + + + /*! Morphological thick-miss. + * + * This operator is THICK_B = Id + HMTopeBG_B, where B = (Bfg, Bbg). + */ + template <typename I, typename Wfg, typename Wbg, typename O> + void thick_miss(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename Wfg, typename Wbg, typename O> + void thick_miss(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + mln_precondition(exact(win_miss).is_centered()); + mln_precondition(set::inter(exact(win_fg), exact(win_bg)).is_empty()); + + O temp(exact(input).domain()); + hit_or_miss_background_opening(input, win_fg, win_bg, temp); + morpho::plus(input, temp, output); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_THICK_MISS_HH Index: mln/morpho/thin_fit.hh --- mln/morpho/thin_fit.hh (revision 0) +++ mln/morpho/thin_fit.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_THIN_FIT_HH +# define MLN_MORPHO_THIN_FIT_HH + +/*! \file mln/morpho/thin_fit.hh + * + * \brief Morphological thin-fit. + */ + +# include <mln/morpho/hit_or_miss.hh> + + +namespace mln +{ + + namespace morpho + { + + + /*! Morphological thin-fit. + * + * This operator is THIN_B = Id - HMTope_B where B = (Bfg, Bbg). + */ + template <typename I, typename Wfg, typename Wbg, typename O> + void thin_fit(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename Wfg, typename Wbg, typename O> + void thin_fit(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + mln_precondition(exact(win_fg).is_centered()); + mln_precondition(set::inter(exact(win_fg), exact(win_bg)).is_empty()); + + O temp(exact(input).domain()); + hit_or_miss_opening(input, win_fg, win_bg, temp); + morpho::minus(input, temp, output); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_THIN_FIT_HH Index: mln/morpho/thinning.hh --- mln/morpho/thinning.hh (revision 0) +++ mln/morpho/thinning.hh (revision 0) @@ -0,0 +1,91 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_THINNING_HH +# define MLN_MORPHO_THINNING_HH + +/*! \file mln/morpho/thinning.hh + * + * \brief Morphological thinning. + */ + +# include <mln/morpho/hit_or_miss.hh> +# include <mln/morpho/thickening.hh> + + +namespace mln +{ + + namespace morpho + { + + + /*! Morphological thinning. + * + * This operator is THIN_B = Id - HMT_B, where B = (Bfg, Bbg). + */ + template <typename I, typename Wfg, typename Wbg, typename O> + void thinning(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I, typename Wfg, typename Wbg, typename O> + void thinning(const Image& input, + const Window<Wfg>& win_fg, const Window<Wbg>& win_bg, + Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + mln_precondition(exact(win_fg).is_centered()); + mln_precondition(set::inter(exact(win_fg), exact(win_bg)).is_empty()); + + O temp(exact(input).domain()); + hit_or_miss(input, win_fg, win_bg, temp); + morpho::minus(input, temp, output); + // FIXME: Pass postcondition! +# ifndef NDEBUG + { + O temp(exact(input).domain()); + complementation(input, temp); + O output_(exact(input).domain()); + thickening(temp, win_bg, win_fg, output_); + complementation_inplace(output_); + mln_postcondition(output_ = output); + } +# endif // ! NDEBUG + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_THINNING_HH Index: mln/morpho/hit_or_miss.hh --- mln/morpho/hit_or_miss.hh (revision 1063) +++ mln/morpho/hit_or_miss.hh (working copy) @@ -61,7 +61,7 @@ /*! Morphological hit-or-miss opening. * - * This operator is d_(-Bh) o HMT_(Bh,Bm). + * This operator is HMTope_(Bh,Bm) = d_(-Bh) o HMT_(Bh,Bm). */ template <typename I, typename Wh, typename Wm, typename O> void hit_or_miss_opening(const Image& input, @@ -70,7 +70,7 @@ /*! Morphological hit-or-miss opening of the background. * - * This operator is FIXME. + * This operator is HMTopeBG = HMTope_(Bm,Bh) o C = d_(-Bm) o HMT_(Bh,Bm). */ template <typename I, typename Wh, typename Wm, typename O> void hit_or_miss_background_opening(const Image& input, @@ -79,7 +79,7 @@ /*! Morphological hit-or-miss closing. * - * This operator is FIXME. + * This operator is C o HMTope o C. */ template <typename I, typename Wh, typename Wm, typename O> void hit_or_miss_closing(const Image& input, @@ -88,7 +88,7 @@ /*! Morphological hit-or-miss closing of the background. * - * This operator is FIXME. + * This operator is C o HMTopeBG o C. */ template <typename I, typename Wh, typename Wm, typename O> void hit_or_miss_background_closing(const Image& input, @@ -150,7 +150,8 @@ erosion(input, win_hit, ero_fg); dilation(input, win_miss, dil_bg); level::fill(output, - fun::p2v::ternary(pw::value(input) = pw::value(ero_fg) && pw::value(dil_bg) < pw::value(input), + fun::p2v::ternary(pw::value(input) = pw::value(ero_fg) + && pw::value(dil_bg) < pw::value(input), pw::value(input) - pw::value(dil_bg), pw::cst(V::zero))); } @@ -160,12 +161,13 @@ erosion(input, win_miss, ero_bg); dilation(input, win_hit, dil_fg); level::fill(output, - fun::p2v::ternary(pw::value(input) = pw::value(dil_fg) && pw::value(ero_bg) > pw::value(input), + fun::p2v::ternary(pw::value(input) = pw::value(dil_fg) + && pw::value(ero_bg) > pw::value(input), pw::value(ero_bg) - pw::value(input), pw::cst(V::zero))); } else - level::fill(output, pw::cst(V::zero)); + level::fill(output, V::zero); } else // Unconstrained: UHMT. { @@ -201,6 +203,7 @@ O temp(exact(input).domain()); hit_or_miss(input, win_hit, win_miss, temp); dilation(temp, geom::sym(win_hit), output); + // FIXME: Postcondition. } template <typename I, typename Wh, typename Wm, typename O> @@ -209,7 +212,18 @@ Image<O>& output) { impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); - hit_or_miss_opening(input, win_miss, win_hit, output); + O temp(exact(input).domain()); + complementation(input, temp); + hit_or_miss_opening(temp, win_miss, win_hit, output); +# ifndef NDEBUG + { + O temp(exact(input).domain()); + hit_or_miss(input, win_hit, win_miss, temp); + O output_(exact(input).domain()); + dilation(temp, geom::sym(win_miss), output_); + mln_postcondition(output_ = output); + } +# endif // ! NDEBUG } template <typename I, typename Wh, typename Wm, typename O> @@ -222,6 +236,7 @@ complementation(input, temp); hit_or_miss_opening(temp, win_hit, win_miss, output); complementation_inplace(output); + // FIXME: Postcondition. } template <typename I, typename Wh, typename Wm, typename O> @@ -231,6 +246,16 @@ { impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); hit_or_miss_closing(input, win_miss, win_hit, output); +# ifndef NDEBUG + { + O temp(exact(input).domain()); + complementation(input, temp); + O output_(exact(input).domain()); + hit_or_miss_background_opening(temp, win_hit, win_miss, output_); + complementation_inplace(output_); + mln_postcondition(output_ = output); + } +# endif // ! NDEBUG } # endif // ! MLN_INCLUDE_ONLY Index: mln/io/save_pgm.hh --- mln/io/save_pgm.hh (revision 1063) +++ mln/io/save_pgm.hh (working copy) @@ -32,20 +32,37 @@ # include <iostream> # include <fstream> -# include <mln/core/image2d_b.hh> # include <mln/geom/size2d.hh> -# include <mln/value/int_u8.hh> +# include <mln/metal/equal.hh> +# include <mln/metal/bexpr.hh> namespace mln { + // Fwd decl. + namespace value { + template <unsigned> class int_u; + template <unsigned> class int_u_sat; + } + + namespace io { - void save_pgm(const image2d_b<value::int_u8>& ima, const std::string& filename) + template <typename I> + void save_pgm(const Image& ima, const std::string& filename); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I> + void save_pgm_header_(const I& ima, const std::string& filename, + std::ofstream& file) { - std::ofstream file(filename.c_str()); if (! file) { std::cerr << "error: cannot open file '" << filename @@ -53,14 +70,22 @@ abort(); } file << "P5" << std::endl; - file << "# olena" << std::endl; + file << "# milena" << std::endl; file << geom::ncols(ima) << ' ' << geom::nrows(ima) << std::endl; file << "255" << std::endl; + } + + template <typename I> + void save_pgm_(const Fast_Image& ima_, const std::string& filename) + { + const I& ima = exact(ima_); + std::ofstream file(filename.c_str()); + save_pgm_header_(ima, filename, file); const int min_row = geom::min_row(ima), max_row = geom::max_row(ima); point2d p; - if (sizeof(value::int_u8) = 1) + if (sizeof(mln_value(I)) = 1) { p.col() = geom::min_col(ima); size_t len = geom::ncols(ima); @@ -82,6 +107,41 @@ } } + template <typename I> + void save_pgm_(const Image& ima_, const std::string& filename) + { + const I& ima = exact(ima_); + std::ofstream file(filename.c_str()); + save_pgm_header_(ima, filename, file); + const int + min_row = geom::min_row(ima), + max_row = geom::max_row(ima), + min_col = geom::min_col(ima), + max_col = geom::max_col(ima); + point2d p; + for (p.row() = min_row; p.row() <= max_row; ++p.row()) + for (p.col() = min_col; p.col() <= max_col; ++p.col()) + { + unsigned char c = ima(p); + file.write((char*)(&c), 1); + } + } + + } // end of namespace mln::io::impl + + + template <typename I> + void save_pgm(const Image& ima, const std::string& filename) + { + mln::metal::or_< + mln::metal::equal<mln_value(I), value::int_u<8> >, + mln::metal::equal<mln_value(I), value::int_u_sat<8> > + >::check(); + impl::save_pgm_(exact(ima), filename); + } + +# endif // ! MLN_INCLUDE_ONLY + } // end of namespace mln::io } // end of namespace mln Index: mln/arith/plus.hh --- mln/arith/plus.hh (revision 1063) +++ mln/arith/plus.hh (working copy) @@ -31,10 +31,15 @@ /*! \file mln/arith/plus.hh * * \brief Point-wise addition between images. + * + * \todo Speedup versions with cst. */ # include <mln/core/concept/image.hh> +# include <mln/pw/cst.hh> +# include <mln/pw/image.hh> + namespace mln { @@ -54,6 +59,18 @@ void plus(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output); + /*! Point-wise addition of the value \p val to image \p input. + * + * \param[in] input The image. + * \param[in] val The value. + * \param[out] output The result image. + * + * \pre \p output.domain = \p input.domain + */ + template <typename I, typename V, typename O> + void plus_cst(const Image& input, const V& val, Image<O>& output); + + /*! Point-wise addition of image \p rhs in image \p lhs. * * \param[in] lhs First operand image (subject to addition). @@ -127,6 +144,13 @@ impl::plus_(exact(lhs), exact(rhs), exact(output)); } + template <typename I, typename V, typename O> + void plus_cst(const Image& input, const V& val, Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + plus(input, pw::cst(val) | exact(input).domain(), output); // Calls the previous version. + } + template <typename L, typename R> void plus_inplace(Image<L>& lhs, const Image<R>& rhs) { @@ -134,6 +158,13 @@ impl::plus_inplace_(exact(lhs), exact(rhs)); } + template <typename I, typename V> + void plus_cst_inplace(Image& input, const V& val) + { + mln_precondition(exact(input).has_data()); + plus_inplace(input, pw::cst(val) | exact(input).domain()); // Calls the previous version. + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::arith Index: img/picasso.pgm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream

1 0

1063: Add hit-or-miss and p2v ternary+elif functions.
by Thierry Geraud 31 Aug '07

31 Aug '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add hit-or-miss and p2v ternary+elif functions. * tests/morpho_hit_or_miss.cc: New. * mln/fun/p2v/elifs.hh: New. * mln/fun/p2v/ternary.hh: New. * mln/morpho/min.hh: New. * mln/morpho/hit_or_miss.hh: New. * mln/arith/min.hh: New. * mln/value/int_u_sat.hh: New. * img/picasso.pgm: New. * mln/arith/revert.hh: Fix. * mln/morpho/includes.hh: Update. img/picasso.pgm | 0 mln/arith/min.hh | 147 ++++++++++++++++++++++++++ mln/arith/revert.hh | 2 mln/fun/p2v/elifs.hh | 84 +++++++++++++++ mln/fun/p2v/ternary.hh | 117 +++++++++++++++++++++ mln/morpho/hit_or_miss.hh | 243 ++++++++++++++++++++++++++++++++++++++++++++ mln/morpho/includes.hh | 4 mln/morpho/min.hh | 121 +++++++++++++++++++++ mln/value/int_u_sat.hh | 191 ++++++++++++++++++++++++++++++++++ tests/morpho_hit_or_miss.cc | 85 +++++++++++++++ 10 files changed, 992 insertions(+), 2 deletions(-) Index: tests/morpho_hit_or_miss.cc --- tests/morpho_hit_or_miss.cc (revision 0) +++ tests/morpho_hit_or_miss.cc (revision 0) @@ -0,0 +1,85 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/*! \file tests/morpho_hit_or_miss.cc + * + * \brief Test on mln::morpho::hit_or_miss. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/value/int_u8.hh> + +#include <mln/core/win/rectangle2d.hh> +#include <mln/core/window2d.hh> +#include <mln/geom/shift.hh> +#include <mln/set/diff.hh> + +#include <mln/io/load_pgm.hh> +#include <mln/io/save_pgm.hh> +#include <mln/level/fill.hh> +#include <mln/level/stretch.hh> + +#include <mln/morpho/hit_or_miss.hh> + + +int main() +{ + using namespace mln; + using value::int_u8; + + window2d win_hit = geom::shift(win::rectangle2d(3, 3), + make::dpoint2d(+1, +1)); + window2d win_miss = set::diff(win::rectangle2d(5, 5), win_hit); + + { + bool hit[] = { 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, + 0, 0, 1, 1, 1, + 0, 0, 1, 1, 1 }; + window2d win_hit_ = make::window2d(hit); + mln_precondition(win_hit_ = win_hit); + + bool miss[] = { 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, + 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0, + 1, 1, 0, 0, 0 }; + window2d win_miss_ = make::window2d(miss); + mln_precondition(win_miss_ = win_miss); + } + + border::thickness = 2; + + image2d_b<int_u8> + lena = io::load_pgm("../img/picasso.pgm"), + out(lena.domain()); + + morpho::hit_or_miss(lena, win_hit, win_miss, out); + + io::save_pgm(out, "out.pgm"); +} Index: mln/fun/p2v/elifs.hh --- mln/fun/p2v/elifs.hh (revision 0) +++ mln/fun/p2v/elifs.hh (revision 0) @@ -0,0 +1,84 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_P2V_ELIFS_HH +# define MLN_FUN_P2V_ELIFS_HH + +/*! \file mln/fun/p2v/elifs.hh + * + * \brief FIXME. + */ + +# include <mln/fun/p2v/ternary.hh> + + +namespace mln +{ + + namespace fun + { + + namespace p2v + { + + template <typename T1, typename N1, + typename T2, typename N2, + typename O> + ternary_<T1, N1, + ternary_<T2, N2, O> > + elifs(const Function_p2b<T1>& f_if_1, const Function_p2v<N1>& f_then_1, + const Function_p2b<T2>& f_if_2, const Function_p2v<N2>& f_then_2, + const Function_p2v<O>& f_otherwise); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename T1, typename N1, + typename T2, typename N2, + typename O> + ternary_<T1, N1, + ternary_<T2, N2, O> > + elifs(const Function_p2b<T1>& f_if_1, const Function_p2v<N1>& f_then_1, + const Function_p2b<T2>& f_if_2, const Function_p2v<N2>& f_then_2, + const Function_p2v<O>& f_otherwise) + { + typedef ternary_<T2, N2, O> T2_N2_O; + T2_N2_O f_otherwise_1(f_if_2, f_then_2, f_otherwise); + ternary_<T1, N1, T2_N2_O> tmp(f_if_1, f_then_1, f_otherwise_1); + return tmp; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::p2v + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_P2V_ELIFS_HH Index: mln/fun/p2v/ternary.hh --- mln/fun/p2v/ternary.hh (revision 0) +++ mln/fun/p2v/ternary.hh (revision 0) @@ -0,0 +1,117 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_FUN_P2V_TERNARY_HH +# define MLN_FUN_P2V_TERNARY_HH + +/*! \file mln/fun/p2v/ternary.hh + * + * \brief FIXME. + */ + +# include <mln/fun/internal/selector.hh> + + +namespace mln +{ + + namespace fun + { + + namespace p2v + { + + template <typename P, typename T, typename F> + struct ternary_ + : fun::internal::selector_p2_<mln_result(T), ternary_<P,T,F> >::ret + { + typedef mln_result(T) result; + + ternary_(const Function_p2b& f_pred, + const Function_p2v<T>& f_true, + const Function_p2v<F>& f_false); + + template <typename Pt> + result operator()(const Pt& p) const; + + protected: + const P f_pred_; + const T f_true_; + const F f_false_; + }; + + + template <typename P, typename T, typename F> + ternary_<P, T, F> + ternary(const Function_p2b& f_pred, + const Function_p2v<T>& f_true, + const Function_p2v<F>& f_false); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename P, typename T, typename F> + ternary_<P,T,F>::ternary_(const Function_p2b& f_pred, + const Function_p2v<T>& f_true, + const Function_p2v<F>& f_false) + : f_pred_(exact(f_pred)), + f_true_(exact(f_true)), + f_false_(exact(f_false)) + { + } + + template <typename P, typename T, typename F> + template <typename Pt> + mln_result(T) + ternary_<P,T,F>::operator()(const Pt& p) const + { + return f_pred_(p) ? f_true_(p) : f_false_(p); + } + + + template <typename P, typename T, typename F> + ternary_<P, T, F> + ternary(const Function_p2b& f_pred, + const Function_p2v<T>& f_true, + const Function_p2v<F>& f_false) + { + ternary_<P, T, F> tmp(exact(f_pred), + exact(f_true), + exact(f_false)); + return tmp; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::p2v + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_P2V_TERNARY_HH Index: mln/morpho/min.hh --- mln/morpho/min.hh (revision 0) +++ mln/morpho/min.hh (revision 0) @@ -0,0 +1,121 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_MIN_HH +# define MLN_MORPHO_MIN_HH + +# include <mln/level/compare.hh> +# include <mln/logical/and.hh> +# include <mln/arith/min.hh> + + +namespace mln +{ + + namespace morpho + { + + /*! Morphological min: either a logical "and" (if morpho on sets) + * or an arithmetical min (if morpho on functions). + */ + template <typename I, typename J, typename O> + void min(const Image& lhs, const Image<J>& rhs, + Image<O>& output); + + /*! Morphological min, inplace version: either a logical "and" (if + * morpho on sets) or an arithmetical min (if morpho on + * functions). + */ + template <typename I, typename J> + void min_inplace(Image& lhs, const Image<J>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename J, typename O> + void min_(value::binary_kind, // binary => morphology on sets + const Image& lhs, const Image<J>& rhs, + Image<O>& output) + { + return logical::and_(lhs, rhs, output); + } + + template <typename K, typename I, typename J, typename O> + void min_(K, // otherwise => morphology on functions + const Image& lhs, const Image<J>& rhs, + Image<O>& output) + { + return arith::min(lhs, rhs, output); + } + + // in place + + template <typename I, typename J> + void min_inplace_(value::binary_kind, // binary => morphology on sets + Image& lhs, const Image<J>& rhs) + { + return logical::and_inplace(lhs, rhs); + } + + template <typename K, typename I, typename J> + void min_inplace_(K, // otherwise => morphology on functions + Image& lhs, const Image<J>& rhs) + { + return arith::min_inplace(lhs, rhs); + } + + } // end of namespace mln::morpho::impl + + + // Facades. + + template <typename I, typename J, typename O> + void min(const Image& lhs, const Image<J>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + impl::min_(mln_value_kind(I)(), exact(lhs), exact(rhs), output); + } + + template <typename I, typename J> + void min_inplace(Image& lhs, const Image<J>& rhs) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + impl::min_inplace_(mln_value_kind(I)(), exact(lhs), exact(rhs)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_MIN_HH Index: mln/morpho/includes.hh --- mln/morpho/includes.hh (revision 1062) +++ mln/morpho/includes.hh (working copy) @@ -49,13 +49,15 @@ # include <mln/border/fill.hh> # include <mln/geom/sym.hh> +# include <mln/set/inter.hh> # include <mln/morpho/dilation.hh> # include <mln/morpho/erosion.hh> +# include <mln/morpho/min.hh> +# include <mln/morpho/complementation.hh> # include <mln/morpho/minus.hh> # include <mln/morpho/plus.hh> -# include <mln/morpho/complementation.hh> #endif // ! MLN_MORPHO_INCLUDES_HH Index: mln/morpho/hit_or_miss.hh --- mln/morpho/hit_or_miss.hh (revision 0) +++ mln/morpho/hit_or_miss.hh (revision 0) @@ -0,0 +1,243 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_HIT_OR_MISS_HH +# define MLN_MORPHO_HIT_OR_MISS_HH + +/*! \file mln/morpho/hit_or_miss.hh + * + * \brief Morphological hit-or-miss. + * + * \todo Save memory. + */ + +# include <mln/morpho/includes.hh> +# include <mln/pw/all.hh> +# include <mln/fun/p2v/ternary.hh> + + +namespace mln +{ + + namespace morpho + { + + + bool constrained_hit_or_miss = true; + + + /*! Morphological hit-or-miss. + * + * This operator is HMT_(Bh,Bm) = e_Bh /\ (e_Bm o C). + */ + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output); + + /*! Morphological hit-or-miss opening. + * + * This operator is d_(-Bh) o HMT_(Bh,Bm). + */ + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_opening(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output); + + /*! Morphological hit-or-miss opening of the background. + * + * This operator is FIXME. + */ + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_background_opening(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output); + + /*! Morphological hit-or-miss closing. + * + * This operator is FIXME. + */ + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_closing(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output); + + /*! Morphological hit-or-miss closing of the background. + * + * This operator is FIXME. + */ + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_background_closing(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + // Preconditions. + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_preconditions_(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + mln_precondition(set::inter(exact(win_hit), exact(win_miss)).is_empty()); + } + + // On sets. + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_(value::binary_kind, // binary => morphology on sets + const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + erosion(input, win_hit, output); // output = ero(input)_hit + + O temp_1(exact(input).domain()); + complementation(input, temp_1); // temp1 = C(input) + + O temp_2(exact(input).domain()); + erosion(temp_1, win_miss, temp_2); // temp_2 = ero(C(input))_miss + + logical::and_inplace(output, temp_2); // output = ero(input)_hit /\ ero(C(input))_miss + } + + // On functions. + + template <typename K, + typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_(K, // otherwise => morphology on functions + const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + typedef mln_value(O) V; + + if (constrained_hit_or_miss) // CHMT. + { + if (exact(win_hit).is_centered()) + { + O ero_fg(exact(input).domain()), dil_bg(exact(input).domain()); + erosion(input, win_hit, ero_fg); + dilation(input, win_miss, dil_bg); + level::fill(output, + fun::p2v::ternary(pw::value(input) = pw::value(ero_fg) && pw::value(dil_bg) < pw::value(input), + pw::value(input) - pw::value(dil_bg), + pw::cst(V::zero))); + } + else if (exact(win_miss).is_centered()) + { + O ero_bg(exact(input).domain()), dil_fg(exact(input).domain()); + erosion(input, win_miss, ero_bg); + dilation(input, win_hit, dil_fg); + level::fill(output, + fun::p2v::ternary(pw::value(input) = pw::value(dil_fg) && pw::value(ero_bg) > pw::value(input), + pw::value(ero_bg) - pw::value(input), + pw::cst(V::zero))); + } + else + level::fill(output, pw::cst(V::zero)); + } + else // Unconstrained: UHMT. + { + O ero(exact(input).domain()), dil(exact(input).domain()); + erosion(input, win_hit, ero); + dilation(input, win_miss, dil); + level::fill(output, + fun::p2v::ternary(pw::value(dil) < pw::value(ero), + pw::value(ero) - pw::value(dil), + pw::cst(V::zero))); + } + } + + } // end of mln::morpho::impl + + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); + impl::hit_or_miss_(mln_value_kind(I)(), input, win_hit, win_miss, output); + } + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_opening(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); + + O temp(exact(input).domain()); + hit_or_miss(input, win_hit, win_miss, temp); + dilation(temp, geom::sym(win_hit), output); + } + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_background_opening(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); + hit_or_miss_opening(input, win_miss, win_hit, output); + } + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_closing(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); + I temp(input.domain()); + complementation(input, temp); + hit_or_miss_opening(temp, win_hit, win_miss, output); + complementation_inplace(output); + } + + template <typename I, typename Wh, typename Wm, typename O> + void hit_or_miss_background_closing(const Image& input, + const Window<Wh>& win_hit, const Window<Wm>& win_miss, + Image<O>& output) + { + impl::hit_or_miss_preconditions_(input, win_hit, win_miss, output); + hit_or_miss_closing(input, win_miss, win_hit, output); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_HIT_OR_MISS_HH Index: mln/arith/min.hh --- mln/arith/min.hh (revision 0) +++ mln/arith/min.hh (revision 0) @@ -0,0 +1,147 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_ARITH_MIN_HH +# define MLN_ARITH_MIN_HH + +/*! \file mln/arith/min.hh + * + * \brief Point-wise min between images. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace arith + { + + /*! Point-wise min of images \p lhs and \p rhs. + * + * \param[in] lhs First operand image. + * \param[in] rhs Second operand image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p lhs.domain = \p rhs.domain + */ + template <typename L, typename R, typename O> + void min(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output); + + + /*! Point-wise min of image \p lhs in image \p rhs. + * + * \param[in,out] lhs First operand image. + * \param[in] rhs Second operand image. + * + * This substraction performs: \n + * for all p of rhs.domain \n + * if rhs(p) < lhs(p) \n + * lhs(p) = rhs(p) + * + * \pre \p rhs.domain <= \p lhs.domain + */ + template <typename L, typename R> + void min_inplace(Image<L>& lhs, const Image<R>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename L, typename R, typename O> + void min_(const Image<L>& lhs_, const Image<R>& rhs_, Image<O>& output_) + { + const L& lhs = exact(lhs_); + const R& rhs = exact(rhs_); + O& output = exact(output_); + mln_piter(L) p(lhs.domain()); + for_all(p) + output(p) = lhs(p) < rhs(p) ? lhs(p) : rhs(p); + } + + template <typename L, typename R, typename O> + void min_(const Fast_Image<L>& lhs, const Fast_Image<R>& rhs, Fast_Image<O>& output) + { + mln_pixter(const L) lp(exact(lhs)); + mln_pixter(const R) rp(exact(rhs)); + mln_pixter(O) op(exact(output)); + for_all_3(lp, rp, op) + op.val() = lp.val() < rp.val() ? lp.val() : rp.val(); + } + + template <typename L, typename R> + void min_inplace_(Image<L>& lhs_, const Image<R>& rhs_) + { + L& lhs = exact(lhs_); + const R& rhs = exact(rhs_); + mln_piter(R) p(rhs.domain()); + for_all(p) + if (rhs(p) < lhs(p)) + lhs(p) = rhs(p); + } + + template <typename L, typename R> + void min_inplace_(Fast_Image<L>& lhs, const Fast_Image<R>& rhs) + { + mln_pixter(L) lp(exact(lhs)); + mln_pixter(const R) rp(exact(rhs)); + for_all_2(rp, lp) + if (rp.val() < lp.val()) + lp.val() = rp.val(); + } + + } // end of namespace mln::arith::impl + + + // Facades. + + template <typename L, typename R, typename O> + void min(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + impl::min_(exact(lhs), exact(rhs), exact(output)); + } + + template <typename L, typename R> + void min_inplace(Image<L>& lhs, const Image<R>& rhs) + { + mln_precondition(exact(rhs).domain() <= exact(lhs).domain()); + impl::min_inplace_(exact(lhs), exact(rhs)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::arith + +} // end of namespace mln + + +#endif // ! MLN_ARITH_MIN_HH Index: mln/arith/revert.hh --- mln/arith/revert.hh (revision 1062) +++ mln/arith/revert.hh (working copy) @@ -95,7 +95,7 @@ mln_pixter(const I) ip(exact(input)); mln_pixter(O) op(exact(output)); for_all_2(ip, op) - op.val() = mln_min(V) + (mln_max(V) - op.val()); + op.val() = mln_min(V) + (mln_max(V) - ip.val()); } } // end of namespace mln::arith::impl Index: mln/value/int_u_sat.hh --- mln/value/int_u_sat.hh (revision 0) +++ mln/value/int_u_sat.hh (revision 0) @@ -0,0 +1,191 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_VALUE_INT_U_SAT_HH +# define MLN_VALUE_INT_U_SAT_HH + +/*! \file mln/value/int_u_sat.hh + * + * \brief Define a generic class for unsigned integers with saturation + * behavior. + */ + +# include <mln/metal/math.hh> +# include <mln/value/internal/value_like.hh> +# include <mln/value/internal/encoding.hh> +# include <mln/value/props.hh> +# include <mln/debug/format.hh> + + +namespace mln +{ + + namespace value + { + + + /*! \brief Unsigned integer value class with saturation behavior. + * + * The parameter is \c n the number of encoding bits. + */ + template <unsigned n> + struct int_u_sat + : public internal::value_like_< typename internal::encoding_unsigned_<n>::ret, + int_u_sat<n> > + { + protected: + typedef internal::value_like_< typename internal::encoding_unsigned_<n>::ret, + int_u_sat<n> > super; + + public: + + /// Encoding associated type. + typedef typename super::enc enc; + + /// Constructor without argument. + int_u_sat(); + + /// Constructor from an integer. + int_u_sat(int i); + + /// Assignment from an integer. + int_u_sat<n>& operator=(int i); + + /// Zero value. + static const int_u_sat<n> zero; + + /// Unit value. + static const int_u_sat<n> one; + + /// Self addition. + int_u_sat<n>& operator+=(int i); + + /// Self subtraction. + int_u_sat<n>& operator-=(int i); + }; + + + // Safety. + template <> struct int_u_sat<0>; + template <> struct int_u_sat<1>; + + + + template <unsigned n> + struct props< int_u_sat<n> > + { + static const std::size_t card_ = metal::pow<2, n>::value; + static const int_u_sat<n> min() { return 0; } + static const int_u_sat<n> max() { return card_ - 1; } + static const unsigned nbits = n; + typedef data_kind kind; + typedef float sum; + }; + + + + /*! \brief Print a saturated unsigned integer \p i into the output + * stream \p ostr. + * + * \param[in,out] ostr An output stream. + * \param[in] i A saturated unsigned integer. + * + * \return The modified output stream \p ostr. + */ + template <unsigned n> + std::ostream& operator<<(std::ostream& ostr, const int_u_sat<n>& i); + + +# ifndef MLN_INCLUDE_ONLY + + template <unsigned n> + int_u_sat<n>::int_u_sat() + { + } + + template <unsigned n> + int_u_sat<n>::int_u_sat(int i) + { + if (i < 0) + this->v_ = enc(0); + else if (i > mln_max(enc)) + this->v_ = mln_max(enc); + else + this->v_ = enc(i); + } + + template <unsigned n> + int_u_sat<n>& + int_u_sat<n>::operator=(int i) + { + if (i < 0) + this->v_ = enc(0); + else if (i > mln_max(enc)) + this->v_ = mln_max(enc); + else + this->v_ = enc(i); + return *this; + } + + template <unsigned n> + int_u_sat<n>& + int_u_sat<n>::operator+=(int i) + { + int v = int(this->v_) + i; + *this = v; + return *this; + } + + template <unsigned n> + int_u_sat<n>& + int_u_sat<n>::operator-=(int i) + { + int v = int(this->v_) - i; + *this = v; + return *this; + } + + template <unsigned n> + const int_u_sat<n> int_u_sat<n>::zero = 0; + + template <unsigned n> + const int_u_sat<n> int_u_sat<n>::one = 1; + + template <unsigned n> + std::ostream& operator<<(std::ostream& ostr, const int_u_sat<n>& i) + { + return ostr << debug::format(i.to_equiv()); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::value + +} // end of namespace mln + + +#endif // ! MLN_VALUE_INT_U_SAT_HH Index: img/picasso.pgm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/picasso.pgm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream

1 0

1062: Make operations on windows more explicit.
by Thierry Geraud 30 Aug '07

30 Aug '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Make operations on windows more explicit. * mln/convert/to_std_set.hh: New. * mln/geom/sym.hh: New. * mln/geom/shift.hh: New. * mln/set: New directory. * mln/set/inter.hh: New. * mln/set/diff.hh: New. * mln/set/union.hh: New. * mln/set/sym_diff.hh: New. * mln/convert/to_image.hh: Typo. * mln/convert/to_window.hh (to_window): New overload. * mln/convert/to_dpoint.hh: Typo. * mln/core/w_window.hh (sym_): Rename as... (sym): ...this and update. * mln/core/window.hh: Likewise. (operator-): Remove the unary version. (operator+, operator-): Remove; now handle by... * mln/geom/shift.hh (shift): ...this. * mln/core/concept/weighted_window.hh: Update. (operator-): Remove. * mln/core/concept/window.hh: Likewise. * mln/core/concept/doc/weighted_window.hh, * mln/core/concept/doc/window.hh, * mln/core/win/vline2d.hh, * mln/core/win/hline2d.hh, * mln/core/win/rectangle2d.hh, * mln/morpho/includes.hh, * mln/morpho/closing.hh, * mln/morpho/opening.hh, * mln/level/was.median.hh, * mln/level/median.hh, * mln/level/fast_median.hh, * tests/rectangle2d.cc: Update. * mln/core/concept/value.hh: Fix warning. mln/convert/to_dpoint.hh | 2 mln/convert/to_image.hh | 2 mln/convert/to_std_set.hh | 75 ++++++++++++++++++++++++++++ mln/convert/to_window.hh | 19 +++++++ mln/core/concept/doc/weighted_window.hh | 4 - mln/core/concept/doc/window.hh | 4 - mln/core/concept/value.hh | 2 mln/core/concept/weighted_window.hh | 10 --- mln/core/concept/window.hh | 24 ++------- mln/core/w_window.hh | 14 +++-- mln/core/win/hline2d.hh | 6 +- mln/core/win/rectangle2d.hh | 6 +- mln/core/win/vline2d.hh | 6 +- mln/core/window.hh | 70 +++----------------------- mln/geom/shift.hh | 73 ++++++++++++++++++++++++++++ mln/geom/sym.hh | 68 ++++++++++++++++++++++++++ mln/level/fast_median.hh | 14 +++-- mln/level/median.hh | 14 +++-- mln/level/was.median.hh | 12 ++-- mln/morpho/closing.hh | 2 mln/morpho/includes.hh | 2 mln/morpho/opening.hh | 2 mln/set/diff.hh | 80 ++++++++++++++++++++++++++++++ mln/set/inter.hh | 83 ++++++++++++++++++++++++++++++++ mln/set/sym_diff.hh | 79 ++++++++++++++++++++++++++++++ mln/set/union.hh | 82 +++++++++++++++++++++++++++++++ tests/rectangle2d.cc | 3 - 27 files changed, 630 insertions(+), 128 deletions(-) Index: tests/rectangle2d.cc --- tests/rectangle2d.cc (revision 1061) +++ tests/rectangle2d.cc (working copy) @@ -31,6 +31,7 @@ */ #include <mln/core/win/rectangle2d.hh> +#include <mln/geom/sym.hh> @@ -43,7 +44,7 @@ mln_assertion(rec.is_centered()); mln_assertion(rec.is_symmetric()); - mln_assertion(rec = -rec); + mln_assertion(rec = geom::sym(rec)); mln_assertion(rec.ndpoints() = h * w); } Index: mln/convert/to_image.hh --- mln/convert/to_image.hh (revision 1061) +++ mln/convert/to_image.hh (working copy) @@ -30,7 +30,7 @@ /*! \file mln/convert/to_image.hh * - * \brief Convertions to mln::Image. + * \brief Conversions to mln::Image. */ # include <mln/core/image2d_b.hh> Index: mln/convert/to_std_set.hh --- mln/convert/to_std_set.hh (revision 0) +++ mln/convert/to_std_set.hh (revision 0) @@ -0,0 +1,75 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_CONVERT_TO_STD_SET_HH +# define MLN_CONVERT_TO_STD_SET_HH + +/*! \file mln/convert/to_std_set.hh + * + * \brief Conversions to std::set. + */ + +# include <set> +# include <algorithm> +# include <iterator> + +# include <mln/core/window.hh> + + +namespace mln +{ + + namespace convert + { + + /// Convert a window \p win into a std::set of delta-points. + template <typename W> + std::set<mln_dpoint(W)> to_std_set(const Window<W>& win); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename W> + std::set<mln_dpoint(W)> to_std_set(const Window<W>& win) + { + typedef mln_dpoint(W) D; + typedef mln_point(D) P; + std::set<D> s; + mln_qiter(W) q(exact(win), P::zero); + for_all(q) + s.insert(q - P::zero); + return s; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::convert + +} // end of namespace mln + + +#endif // ! MLN_CONVERT_TO_STD_SET_HH Index: mln/convert/to_window.hh --- mln/convert/to_window.hh (revision 1061) +++ mln/convert/to_window.hh (working copy) @@ -33,10 +33,14 @@ * \brief Conversions to mln::window. */ +# include <set> + +# include <mln/core/concept/dpoint.hh> # include <mln/core/concept/neighborhood.hh> # include <mln/core/window.hh> # include <mln/pw/image.hh> # include <mln/pw/cst.hh> +# include <mln/metal/is_a.hh> namespace mln @@ -57,6 +61,10 @@ template <typename S, typename F> window<mln_dpoint(S)> to_window(const Point_Set<S>& pset); + /// Convert an std::set \p s of delta-points into a window. + template <typename D> + window<D> to_window(const std::set<D>& s); + # ifndef MLN_INCLUDE_ONLY @@ -95,6 +103,17 @@ return to_window(pw::cst(true) | pset); } + template <typename D> + window<D> to_window(const std::set<D>& s) + { + mln::metal::is_a<D, Dpoint>::check(); + window<D> win; + for (typename std::set<D>::const_iterator i = s.begin(); + i != s.end(); ++i) + win.insert(*i); + return win; + } + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::convert Index: mln/convert/to_dpoint.hh --- mln/convert/to_dpoint.hh (revision 1061) +++ mln/convert/to_dpoint.hh (working copy) @@ -30,7 +30,7 @@ /*! \file mln/convert/to_dpoint.hh * - * \brief Convertions to mln::Dpoint. + * \brief Conversions to mln::Dpoint. */ # include <mln/core/concept/generalized_point.hh> Index: mln/geom/sym.hh --- mln/geom/sym.hh (revision 0) +++ mln/geom/sym.hh (revision 0) @@ -0,0 +1,68 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_GEOM_SYM_HH +# define MLN_GEOM_SYM_HH + +/*! \file mln/geom/sym.hh + * + * \brief Give the symmetrical object. + */ + +# include <mln/core/concept/window.hh> + + + +namespace mln +{ + + namespace geom + { + + /*! \brief Give the symmetrical window of \p win. + */ + template <typename W> + W sym(const Window<W>& win); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename W> + W sym(const Window<W>& win) + { + W tmp = exact(win); + return tmp.sym(); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::geom + +} // end of namespace mln + + +#endif // ! MLN_GEOM_SYM_HH Index: mln/geom/shift.hh --- mln/geom/shift.hh (revision 0) +++ mln/geom/shift.hh (revision 0) @@ -0,0 +1,73 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_GEOM_SHIFT_HH +# define MLN_GEOM_SHIFT_HH + +/*! \file mln/geom/shift.hh + * + * \brief Shift. + */ + +# include <mln/core/window.hh> + + + +namespace mln +{ + + namespace geom + { + + /// Shift a window \p win with a delta-point \p dp. + template <typename W> + window<mln_dpoint(W)> + shift(const Window<W>& win, const mln_dpoint(W)& dp); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename W> + window<mln_dpoint(W)> + shift(const Window<W>& win, const mln_dpoint(W)& dp) + { + typedef mln_point(W) P; + window<mln_dpoint(W)> tmp; + mln_qiter(W) q(win, P::zero); + for_all(q) + tmp.insert(convert::to_dpoint(q) + dp); + return tmp; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::geom + +} // end of namespace mln + + +#endif // ! MLN_GEOM_SHIFT_HH Index: mln/core/w_window.hh --- mln/core/w_window.hh (revision 1061) +++ mln/core/w_window.hh (working copy) @@ -104,8 +104,8 @@ const mln::window<D>& win() const; - /// Give the symmetrical w_window. - w_window<D,W> sym_() const; + /// Apply a central symmetry to the target window. + w_window<D,W>& sym(); protected: @@ -252,11 +252,13 @@ } template <typename D, typename W> - w_window<D,W> - w_window<D,W>::sym_() const + w_window<D,W>& + w_window<D,W>::sym() { - w_window<D,W> tmp(*this); - tmp.win_ = - this->win_; + w_window<D,W> tmp; + for (unsigned i = 0; i < this->ndpoints(); ++i) + tmp.insert(this->w(i), this->dp(i)); + *this = tmp; return *this; } Index: mln/core/window.hh --- mln/core/window.hh (revision 1061) +++ mln/core/window.hh (working copy) @@ -40,6 +40,7 @@ # include <mln/core/box.hh> # include <mln/convert/to_dpoint.hh> +# include <mln/geom/sym.hh> namespace mln @@ -87,8 +88,8 @@ /// Insert a delta-point \p dp. window<D>& insert(const D& dp); - /// Give the symmetrical window. - window<D> sym_() const; + /// Apply a central symmetry to the target window. + window<D>& sym(); protected: @@ -96,24 +97,6 @@ }; - // FIXME: Move both ops below to mln/core/concept/window.hh - - /// Shift a window \p win with a delta-point \p dp. - template <typename W> - window<mln_dpoint(W)> operator+(const Window<W>& win, - const mln_dpoint(W)& dp); - - /// Shift a window \p win with the delta-point (-\p dp). - template <typename W> - window<mln_dpoint(W)> operator-(const Window<W>& win, - const mln_dpoint(W)& dp); - - /// Substract \p rhs from \p lhs. - // FIXME: Give details! - template <typename Wl, typename Wr> - window<mln_dpoint(Wl)> operator-(const Window<Wl>& lhs, - const Window<Wr>& rhs); - # ifndef MLN_INCLUDE_ONLY @@ -128,7 +111,7 @@ template <typename D> bool window<D>::is_symmetric() const { - return this->sym_() = *this; + return geom::sym(*this) = *this; } template <typename D> @@ -141,52 +124,15 @@ } template <typename D> - window<D> - window<D>::sym_() const + window<D>& + window<D>::sym() { window<D> tmp; const unsigned n = this->ndpoints(); for (unsigned i = 0; i < n; ++i) tmp.insert(- this->dp(i)); - return tmp; - } - - - // operators - - template <typename W> - window<mln_dpoint(W)> operator+(const Window<W>& win, - const mln_dpoint(W)& dp) - { - typedef mln_point(W) P; - window<mln_dpoint(W)> tmp; - mln_qiter(W) q(win, P::zero); - for_all(q) - tmp.insert(convert::to_dpoint(q) + dp); - return tmp; - } - - template <typename W> - window<mln_dpoint(W)> operator-(const Window<W>& win, - const mln_dpoint(W)& dp) - { - return win + (-dp); - } - - template <typename W, typename Wr> - window<mln_dpoint(W)> operator-(const Window<W>& lhs, - const Window<Wr>& rhs) - { - typedef mln_point(W) P; - window<mln_dpoint(W)> tmp; - mln_qiter(W) q(lhs, P::zero); - for_all(q) - { - mln_dpoint(W) dp = convert::to_dpoint(q); - if (! exact(rhs).has(dp)) - tmp.insert(dp); - } - return tmp; + *this = tmp; + return *this; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/concept/weighted_window.hh --- mln/core/concept/weighted_window.hh (revision 1061) +++ mln/core/concept/weighted_window.hh (working copy) @@ -58,7 +58,7 @@ typedef weight; typedef window; - E sym_() const; + E& sym(); */ /// Test if the weighted window is empty; final method. @@ -107,19 +107,13 @@ typedef mln_fwd_qiter(E) fwd_qiter; typedef mln_bkd_qiter(E) bkd_qiter; - E (E::*m1)() const = & E::sym_; + E& (E::*m1)() = & E::sym; m1 = 0; const window& (E::*m2)() const = & E::win; m2 = 0; } - template <typename W> - W operator-(const Weighted_Window<W>& rhs) - { - return exact(rhs).sym_(); - } - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/core/concept/window.hh --- mln/core/concept/window.hh (revision 1061) +++ mln/core/concept/window.hh (working copy) @@ -39,6 +39,7 @@ namespace mln { + /*! \brief Base class for implementation classes that are windows. * * \see mln::doc::Window for a complete documentation of this class @@ -61,7 +62,7 @@ unsigned delta() const; - E sym_() const; + E& sym(); */ protected: @@ -69,22 +70,17 @@ }; - /*! \brief Compute the symmetrical window of \p rhs. - * - * \relates mln::Window - */ - template <typename W> - W operator-(const Window<W>& rhs); - - /*! \brief Equality comparison between windows \p lhs and \p rhs. * * \relates mln::Window + * + * \todo Move into mln/set/compare.hh and delegate to replace this special impl. */ template <typename Wl, typename Wr> bool operator=(const Window<Wl>& lhs, const Window<Wr>& rhs); + # ifndef MLN_INCLUDE_ONLY template <typename E> @@ -105,14 +101,8 @@ m3 = 0; unsigned (E::*m4)() const = & E::delta; m4 = 0; - E (E::*m_)() const = & E::sym_; - m_ = 0; - } - - template <typename W> - W operator-(const Window<W>& rhs) - { - return exact(rhs).sym_(); + E& (E::*m5)() = & E::sym; + m5 = 0; } template <typename Wl, typename Wr> Index: mln/core/concept/doc/weighted_window.hh --- mln/core/concept/doc/weighted_window.hh (revision 1061) +++ mln/core/concept/doc/weighted_window.hh (working copy) @@ -89,9 +89,9 @@ */ const window& win() const; - /*! \brief Give the symmetrical weighted_window. + /*! \brief Apply a central symmetry to the target weighted window. */ - E sym_() const; + E& sym(); }; } // end of namespace mln::doc Index: mln/core/concept/doc/window.hh --- mln/core/concept/doc/window.hh (revision 1061) +++ mln/core/concept/doc/window.hh (working copy) @@ -81,9 +81,9 @@ */ unsigned delta() const; - /*! \brief Give the symmetrical window. + /*! \brief Apply a central symmetry to the target window. */ - E sym_() const; + E& sym(); }; } // end of namespace mln::doc Index: mln/core/concept/value.hh --- mln/core/concept/value.hh (revision 1061) +++ mln/core/concept/value.hh (working copy) @@ -115,7 +115,7 @@ template <typename T, typename S> typename S::equiv - cast_(const T& dummy, const Value<S>& src) + cast_(const T&, const Value<S>& src) { return exact(src); } Index: mln/core/win/vline2d.hh --- mln/core/win/vline2d.hh (revision 1061) +++ mln/core/win/vline2d.hh (working copy) @@ -108,8 +108,8 @@ */ unsigned delta() const; - /// Get the symmetrical window. - vline2d sym_() const; + /// Apply a central symmetry to the target window. + vline2d& sym(); protected: unsigned length_; @@ -161,7 +161,7 @@ return length_ / 2; } - vline2d vline2d::sym_() const + vline2d& vline2d::sym() { return *this; } Index: mln/core/win/hline2d.hh --- mln/core/win/hline2d.hh (revision 1061) +++ mln/core/win/hline2d.hh (working copy) @@ -106,8 +106,8 @@ */ unsigned delta() const; - /// Get the symmetrical window. - hline2d sym_() const; + /// Apply a central symmetry to the target window. + hline2d& sym(); protected: unsigned length_; @@ -159,7 +159,7 @@ return length_ / 2; } - hline2d hline2d::sym_() const + hline2d& hline2d::sym() { return *this; } Index: mln/core/win/rectangle2d.hh --- mln/core/win/rectangle2d.hh (revision 1061) +++ mln/core/win/rectangle2d.hh (working copy) @@ -111,8 +111,8 @@ */ unsigned delta() const; - /// Get the symmetrical window. - rectangle2d sym_() const; + /// Apply a central symmetry to the target window. + rectangle2d& sym(); protected: unsigned height_, width_; @@ -171,7 +171,7 @@ return width_ > height_ ? width_ / 2 : height_ / 2; } - rectangle2d rectangle2d::sym_() const + rectangle2d& rectangle2d::sym() { return *this; } Index: mln/set/inter.hh --- mln/set/inter.hh (revision 0) +++ mln/set/inter.hh (revision 0) @@ -0,0 +1,83 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_SET_INTER_HH +# define MLN_SET_INTER_HH + +/*! \file mln/set/inter.hh + * + * \brief Several routines to compute the intersection between a + * couple of sets. + */ + +# include <mln/convert/to_std_set.hh> +# include <mln/convert/to_window.hh> +# include <mln/metal/equal.hh> + + + +namespace mln +{ + + namespace set + { + + /*! \brief Intersection between a couple of windows. + * + * \relates mln::Window + */ + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + inter(const Window<Wl>& lhs, const Window<Wr>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + inter(const Window<Wl>& lhs, const Window<Wr>& rhs) + { + mln::metal::equal<mln_dpoint(Wl), mln_dpoint(Wr)>::check(); + typedef mln_dpoint(Wl) D; + std::set<D> + sl = convert::to_std_set(lhs), + sr = convert::to_std_set(rhs), + s; + std::set_intersection(sl.begin(), sl.end(), + sr.begin(), sr.end(), + std::inserter(s, s.begin())); + return convert::to_window(s); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::set + +} // end of namespace mln + + +#endif // ! MLN_SET_INTER_HH Index: mln/set/diff.hh --- mln/set/diff.hh (revision 0) +++ mln/set/diff.hh (revision 0) @@ -0,0 +1,80 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_SET_DIFF_HH +# define MLN_SET_DIFF_HH + +/*! \file mln/set/diff.hh + * + * \brief Set theoretic difference (non-symmetrical) of a couple of + * sets. + */ + +# include <mln/convert/to_std_set.hh> +# include <mln/convert/to_window.hh> +# include <mln/metal/equal.hh> + + + +namespace mln +{ + + namespace set + { + + /// Set theoretic difference of \p lhs and \p rhs. + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + diff(const Window<Wl>& lhs, const Window<Wr>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + diff(const Window<Wl>& lhs, const Window<Wr>& rhs) + { + mln::metal::equal<mln_dpoint(Wl), mln_dpoint(Wr)>::check(); + typedef mln_dpoint(Wl) D; + std::set<D> + sl = convert::to_std_set(lhs), + sr = convert::to_std_set(rhs), + s; + std::set_difference(sl.begin(), sl.end(), + sr.begin(), sr.end(), + std::inserter(s, s.begin())); + return convert::to_window(s); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::set + +} // end of namespace mln + + +#endif // ! MLN_SET_DIFF_HH Index: mln/set/union.hh --- mln/set/union.hh (revision 0) +++ mln/set/union.hh (revision 0) @@ -0,0 +1,82 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_SET_UNION_HH +# define MLN_SET_UNION_HH + +/*! \file mln/set/union.hh + * + * \brief Several routines to compute the union of a couple of sets. + */ + +# include <mln/convert/to_std_set.hh> +# include <mln/convert/to_window.hh> +# include <mln/metal/equal.hh> + + + +namespace mln +{ + + namespace set + { + + /*! \brief Union of a couple of windows. + * + * \relates mln::Window + */ + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + union(const Window<Wl>& lhs, const Window<Wr>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + union(const Window<Wl>& lhs, const Window<Wr>& rhs) + { + mln::metal::equal<mln_dpoint(Wl), mln_dpoint(Wr)>::check(); + typedef mln_dpoint(Wl) D; + std::set<D> + sl = convert::to_std_set(lhs), + sr = convert::to_std_set(rhs), + s; + std::set_union(sl.begin(), sl.end(), + sr.begin(), sr.end(), + std::inserter(s, s.begin())); + return convert::to_window(s); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::set + +} // end of namespace mln + + +#endif // ! MLN_SET_UNION_HH Index: mln/set/sym_diff.hh --- mln/set/sym_diff.hh (revision 0) +++ mln/set/sym_diff.hh (revision 0) @@ -0,0 +1,79 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_SET_SYM_DIFF_HH +# define MLN_SET_SYM_DIFF_HH + +/*! \file mln/set/sym_diff.hh + * + * \brief Set theoretic symmetrical difference of a couple of sets. + */ + +# include <mln/convert/to_std_set.hh> +# include <mln/convert/to_window.hh> +# include <mln/metal/equal.hh> + + + +namespace mln +{ + + namespace set + { + + /// Set theoretic symmetrical difference of \p lhs and \p rhs. + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + sym_diff(const Window<Wl>& lhs, const Window<Wr>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename Wl, typename Wr> + window<mln_dpoint(Wl)> + sym_diff(const Window<Wl>& lhs, const Window<Wr>& rhs) + { + mln::metal::equal<mln_dpoint(Wl), mln_dpoint(Wr)>::check(); + typedef mln_dpoint(Wl) D; + std::set<D> + sl = convert::to_std_set(lhs), + sr = convert::to_std_set(rhs), + s; + std::set_symmetric_difference(sl.begin(), sl.end(), + sr.begin(), sr.end(), + std::inserter(s, s.begin())); + return convert::to_window(s); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::set + +} // end of namespace mln + + +#endif // ! MLN_SET_SYM_DIFF_HH Index: mln/morpho/includes.hh --- mln/morpho/includes.hh (revision 1061) +++ mln/morpho/includes.hh (working copy) @@ -48,6 +48,8 @@ # include <mln/border/resize.hh> # include <mln/border/fill.hh> +# include <mln/geom/sym.hh> + # include <mln/morpho/dilation.hh> # include <mln/morpho/erosion.hh> Index: mln/morpho/closing.hh --- mln/morpho/closing.hh (revision 1061) +++ mln/morpho/closing.hh (working copy) @@ -64,7 +64,7 @@ O temp(input.domain()); dilation(input, win, temp); - erosion(temp, -win, output); + erosion(temp, geom::sym(win), output); mln_postcondition(output >= input); } Index: mln/morpho/opening.hh --- mln/morpho/opening.hh (revision 1061) +++ mln/morpho/opening.hh (working copy) @@ -64,7 +64,7 @@ O temp(input.domain()); erosion(input, win, temp); - dilation(temp, -win, output); + dilation(temp, geom::sym(win), output); mln_postcondition(output <= input); } Index: mln/level/was.median.hh --- mln/level/was.median.hh (revision 1061) +++ mln/level/was.median.hh (working copy) @@ -59,12 +59,12 @@ min_col = geom::min_col(input), max_col = geom::max_col(input); window2d - win_fwd_plus = win - (win + left), - win_fwd_minus = (win + left) - win, - win_bkd_plus = win - (win + right), - win_bkd_minus = (win + right) - win, - win_bot = win - (win + up), - win_top = (win + up) - win; + win_fwd_plus = set::diff(win, geom::shift(win, left)), + win_fwd_minus = set::diff(geom::shift(win, left), win), + win_bkd_plus = set::diff(win, geom::shift(win, right)), + win_bkd_minus = set::diff(geom::shift(win, right), win), + win_bot = set::diff(win, geom::shift(win, up)), + win_top = set::diff(geom::shift(win, up), win); point2d p; mln_qiter(W) Index: mln/level/median.hh --- mln/level/median.hh (revision 1061) +++ mln/level/median.hh (working copy) @@ -38,11 +38,14 @@ # include <mln/core/window2d.hh> # include <mln/core/win/hline2d.hh> - # include <mln/core/t_image.hh> + # include <mln/accu/median.hh> # include <mln/canvas/sbrowsing.hh> +# include <mln/geom/shift.hh> +# include <mln/set/diff.hh> + namespace mln { @@ -98,9 +101,12 @@ // aux data med(input.values()), p(), - win_fp(win - (win + left)), win_fm((win + left) - win), - win_bp(win - (win + right)), win_bm((win + right) - win), - win_dp(win - (win + up)), win_dm((win + up) - win), + win_fp(set::diff(win, geom::shift(win, left))), + win_fm(set::diff(geom::shift(win, left), win)), + win_bp(set::diff(win, geom::shift(win, right))), + win_bm(set::diff(geom::shift(win, right), win)), + win_dp(set::diff(win, geom::shift(win, up))), + win_dm(set::diff(geom::shift(win, up), win)), q_fp(win_fp, p), q_fm(win_fm, p), q_bp(win_bp, p), q_bm(win_bm, p), q_dp(win_dp, p), q_dm(win_dm, p) Index: mln/level/fast_median.hh --- mln/level/fast_median.hh (revision 1061) +++ mln/level/fast_median.hh (working copy) @@ -36,6 +36,8 @@ # include <mln/core/concept/image.hh> # include <mln/core/window2d.hh> # include <mln/accu/median.hh> +# include <mln/geom/shift.hh> +# include <mln/set/diff.hh> namespace mln @@ -77,12 +79,12 @@ min_col = geom::min_col(input), max_col = geom::max_col(input); window2d - win_fwd_plus = win - (win + left), - win_fwd_minus = (win + left) - win, - win_bkd_plus = win - (win + right), - win_bkd_minus = (win + right) - win, - win_bot = win - (win + up), - win_top = (win + up) - win; + win_fwd_plus = set::diff(win, geom::shift(win, left)), + win_fwd_minus = set::diff(geom::shift(win, left), win), + win_bkd_plus = set::diff(win, geom::shift(win, right)), + win_bkd_minus = set::diff(geom::shift(win, right), win), + win_bot = set::diff(win, geom::shift(win, up)), + win_top = set::diff(geom::shift(win, up), win); accu::median<mln_vset(I)> med(input.values());

1 0

1061: Add morphological complementation.
by Thierry Geraud 29 Aug '07

29 Aug '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add morphological complementation. * tests/morpho_contrast.cc: Augment. * mln/core/concept/value.hh (cast): New. * mln/fun/v2v/saturate.hh: Update. * mln/morpho/minus.hh: Move assertions. * mln/logical/and.hh, * mln/logical/and_not.hh, * mln/logical/or.hh: Fix doc. * mln/value/int_s.hh (operator=): New. * mln/value/int_u.hh: Likewise. * mln/morpho/complementation.hh: New. * mln/morpho/includes.hh: Update. * mln/arith/revert.hh: New. * mln/logical/not.hh: New. mln/arith/revert.hh | 127 ++++++++++++++++++++++++++++++++++++++++++ mln/core/concept/value.hh | 46 +++++++++++++++ mln/fun/v2v/saturate.hh | 10 +-- mln/logical/and.hh | 2 mln/logical/and_not.hh | 2 mln/logical/not.hh | 120 +++++++++++++++++++++++++++++++++++++++ mln/logical/or.hh | 2 mln/morpho/complementation.hh | 105 ++++++++++++++++++++++++++++++++++ mln/morpho/includes.hh | 1 mln/morpho/minus.hh | 7 -- mln/value/int_s.hh | 13 ++++ mln/value/int_u.hh | 13 ++++ tests/morpho_contrast.cc | 22 ++++++- 13 files changed, 455 insertions(+), 15 deletions(-) Index: tests/morpho_contrast.cc --- tests/morpho_contrast.cc (revision 1060) +++ tests/morpho_contrast.cc (working copy) @@ -37,7 +37,11 @@ #include <mln/io/save_pgm.hh> #include <mln/value/int_u8.hh> +#include <mln/value/int_s.hh> + #include <mln/morpho/contrast.hh> + +#include <mln/level/fill.hh> #include <mln/level/saturate.hh> @@ -53,9 +57,23 @@ lena = io::load_pgm("../img/tiny.pgm"), out(lena.domain()); - image2d_b<int> tmp(lena.domain()); - morpho::contrast(lena, rect, tmp); + image2d_b< value::int_s<10> > + in(lena.domain()), + tmp(lena.domain()); + + level::fill(in, lena); + morpho::contrast(in, rect, tmp); level::saturate(tmp, out); io::save_pgm(out, "out.pgm"); + + { + // self-duality test: + morpho::complementation_inplace(in); + image2d_b< value::int_s<10> > tmp_(lena.domain()); + morpho::contrast(in, rect, tmp_); + morpho::complementation_inplace(tmp_); + mln_assertion(tmp_ = tmp); + } + } Index: mln/core/concept/value.hh --- mln/core/concept/value.hh (revision 1060) +++ mln/core/concept/value.hh (working copy) @@ -62,6 +62,18 @@ }; + + namespace value + { + + /// Cast a value \p src from type \c Src to type \c Dest. + template <typename Dest, typename Src> + Dest cast(const Src& src); + + } // end of namespace mln::value + + + # ifndef MLN_INCLUDE_ONLY template <typename E> @@ -87,6 +99,40 @@ return exact(*this); } + + namespace value + { + + namespace internal + { + + template <typename S> + const S& + cast_(const S& src, ...) + { + return src; + } + + template <typename T, typename S> + typename S::equiv + cast_(const T& dummy, const Value<S>& src) + { + return exact(src); + } + + } // end of namespace mln::value::internal + + + template <typename Dest, typename Src> + Dest cast(const Src& src) + { + return internal::cast_(src, src); + } + + + } // end of namespace mln::value + + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln Index: mln/fun/v2v/saturate.hh --- mln/fun/v2v/saturate.hh (revision 1060) +++ mln/fun/v2v/saturate.hh (working copy) @@ -57,7 +57,7 @@ typedef V result; template <typename W> - V operator()(const W& v) const; + V operator()(const W& w) const; protected: V min_, max_; @@ -84,13 +84,13 @@ template <typename V> template <typename W> V - saturate<V>::operator()(const W& v) const + saturate<V>::operator()(const W& w) const { - if (v < min_) + if (w < min_) return min_; - if (v > max_) + if (w > max_) return max_; - return v; + return mln::value::cast<V>(w); } # endif // ! MLN_INCLUDE_ONLY Index: mln/morpho/includes.hh --- mln/morpho/includes.hh (revision 1060) +++ mln/morpho/includes.hh (working copy) @@ -53,6 +53,7 @@ # include <mln/morpho/minus.hh> # include <mln/morpho/plus.hh> +# include <mln/morpho/complementation.hh> #endif // ! MLN_MORPHO_INCLUDES_HH Index: mln/morpho/minus.hh --- mln/morpho/minus.hh (revision 1060) +++ mln/morpho/minus.hh (working copy) @@ -64,7 +64,9 @@ const Image& lhs, const Image<J>& rhs, Image<O>& output) { + // FIXME: mln_precondition(rhs <= lhs); return logical::and_not(lhs, rhs, output); + // FIXME: mln_postcondition(output <= lhs); } template <typename K, typename I, typename J, typename O> @@ -85,19 +87,14 @@ { mln_precondition(exact(rhs).domain() = exact(lhs).domain()); mln_precondition(exact(output).domain() = exact(lhs).domain()); - mln_precondition(rhs <= lhs); impl::minus_(mln_value_kind(I)(), exact(lhs), exact(rhs), output); - - mln_postcondition(output <= lhs); } template <typename I, typename J> void minus_inplace(Image& lhs, const Image<J>& rhs) { mln_precondition(exact(rhs).domain() = exact(lhs).domain()); - mln_precondition(rhs <= lhs); - morpho::minus(lhs, rhs, lhs); // Calls the previous version. } Index: mln/morpho/complementation.hh --- mln/morpho/complementation.hh (revision 0) +++ mln/morpho/complementation.hh (revision 0) @@ -0,0 +1,105 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_COMPLEMENTATION_HH +# define MLN_MORPHO_COMPLEMENTATION_HH + +# include <mln/level/compare.hh> +# include <mln/logical/not.hh> +# include <mln/arith/revert.hh> + + +namespace mln +{ + + namespace morpho + { + + /*! Morphological complementation: either a logical "not" (if + * morpho on sets) or an arithmetical complementation (if morpho + * on functions). + */ + template <typename I, typename O> + void complementation(const Image& input, Image<O>& output); + + + /*! Morphological complementation, inplace version: either a + * logical "not" (if morpho on sets) or an arithmetical + * complementation (if morpho on functions). + */ + template <typename I> + void complementation_inplace(Image& input); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename O> + void complementation_(value::binary_kind, // binary => morphology on sets + const Image& input, + Image<O>& output) + { + return logical::not_(input, output); + } + + template <typename K, typename I, typename O> + void complementation_(K, // otherwise => morphology on functions + const Image& input, + Image<O>& output) + { + return arith::revert(input, output); + } + + } // end of namespace mln::morpho::impl + + + // Facades. + + template <typename I, typename O> + void complementation(const Image& input, Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + impl::complementation_(mln_value_kind(I)(), exact(input), output); + } + + template <typename I> + void complementation_inplace(Image& input) + { + mln_precondition(exact(input).has_data()); + morpho::complementation(input, input); // Calls the previous version. + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_COMPLEMENTATION_HH Index: mln/arith/revert.hh --- mln/arith/revert.hh (revision 0) +++ mln/arith/revert.hh (revision 0) @@ -0,0 +1,127 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_ARITH_REVERT_HH +# define MLN_ARITH_REVERT_HH + +/*! \file mln/arith/revert.hh + * + * \brief Point-wise revert (min -> max and max -> min) of images. + * + * \todo Add static assertion and save one iterator in in-place version. + */ + +# include <mln/core/concept/image.hh> +# include <mln/value/props.hh> + +// FIXME: Rely instead on mln/fun/v2v/revert.hh. +// FIXME: Revert on int value 0 does not give 0 (since min != - max; idem for float etc.) + + + +namespace mln +{ + + namespace arith + { + + /*! Point-wise reversion of image \p input. + * + * \param[in] input the input image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p input.domain + */ + template <typename I, typename O> + void revert(const Image& input, Image<O>& output); + + + /*! Point-wise in-place reversion of image \p input. + * + * \param[in,out] input The target image. + * + * It performs: \n + * for all p of input.domain \n + * input(p) = min + (max - input(p)) + */ + template <typename I> + void revert_inplace(Image& input); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename O> + void revert_(const Image& input_, Image<O>& output_) + { + const I& input = exact(input_); + O& output = exact(output_); + typedef mln_value(I) V; + mln_piter(I) p(input.domain()); + for_all(p) + output(p) = mln_min(V) + (mln_max(V) - input(p)); + } + + template <typename I, typename O> + void revert_(const Fast_Image& input, Fast_Image<O>& output) + { + typedef mln_value(I) V; + mln_pixter(const I) ip(exact(input)); + mln_pixter(O) op(exact(output)); + for_all_2(ip, op) + op.val() = mln_min(V) + (mln_max(V) - op.val()); + } + + } // end of namespace mln::arith::impl + + + // Facades. + + template <typename I, typename O> + void revert(const Image& input, Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + impl::revert_(exact(input), exact(output)); + } + + template <typename I> + void revert_inplace(Image& input) + { + mln_precondition(exact(input).has_data()); + impl::revert_(exact(input), exact(input)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::arith + +} // end of namespace mln + + +#endif // ! MLN_ARITH_REVERT_HH Index: mln/logical/and.hh --- mln/logical/and.hh (revision 1060) +++ mln/logical/and.hh (working copy) @@ -61,7 +61,7 @@ * \param[in] lhs First operand image. * \param[in,out] rhs Second operand image. * - * This addition performs: \n + * It performs: \n * for all p of rhs.domain \n * lhs(p) = lhs(p) and rhs(p) * Index: mln/logical/and_not.hh --- mln/logical/and_not.hh (revision 1060) +++ mln/logical/and_not.hh (working copy) @@ -61,7 +61,7 @@ * \param[in] lhs First operand image. * \param[in,out] rhs Second operand image. * - * This addition performs: \n + * It performs: \n * for all p of rhs.domain \n * lhs(p) = lhs(p) and not rhs(p) * Index: mln/logical/or.hh --- mln/logical/or.hh (revision 1060) +++ mln/logical/or.hh (working copy) @@ -61,7 +61,7 @@ * \param[in] lhs First operand image. * \param[in,out] rhs Second operand image. * - * This addition performs: \n + * It performs: \n * for all p of rhs.domain \n * lhs(p) = lhs(p) or rhs(p) * Index: mln/logical/not.hh --- mln/logical/not.hh (revision 0) +++ mln/logical/not.hh (revision 0) @@ -0,0 +1,120 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LOGICAL_NOT_HH +# define MLN_LOGICAL_NOT_HH + +/*! \file mln/logical/not.hh + * + * \brief Point-wise "logical not" of a binary image. + * + * \todo Add static assertion and save one iterator in in-place version. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace logical + { + + /*! Point-wise "logical not" of image \p input. + * + * \param[in] input the input image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p input.domain + */ + template <typename I, typename O> + void not_(const Image& input, Image<O>& output); + + + /*! Point-wise in-place "logical not" of image \p input. + * + * \param[in,out] input The target image. + * + * It performs: \n + * for all p of input.domain \n + * input(p) = not input(p) + */ + template <typename I> + void not_inplace(Image& input); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename O> + void not__(const Image& input_, Image<O>& output_) + { + const I& input = exact(input_); + O& output = exact(output_); + mln_piter(I) p(input.domain()); + for_all(p) + output(p) = ! input(p); + } + + template <typename I, typename O> + void not__(const Fast_Image& input, Fast_Image<O>& output) + { + mln_pixter(const I) ip(exact(input)); + mln_pixter(O) op(exact(output)); + for_all_2(ip, op) + op.val() = ! ip.val(); + } + + } // end of namespace mln::logical::impl + + + // Facades. + + template <typename I, typename O> + void not_(const Image& input, Image<O>& output) + { + mln_precondition(exact(output).domain() = exact(input).domain()); + impl::not__(exact(input), exact(output)); + } + + template <typename I> + void not_inplace(Image& input) + { + mln_precondition(exact(input).has_data()); + impl::not__(exact(input), exact(input)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::logical + +} // end of namespace mln + + +#endif // ! MLN_LOGICAL_NOT_HH Index: mln/value/int_s.hh --- mln/value/int_s.hh (revision 1060) +++ mln/value/int_s.hh (working copy) @@ -71,6 +71,9 @@ /// Constructor from an integer. int_s(int i); + /// Assignment from an integer. + int_s<n>& operator=(int i); + /// Negation. int_s<n> operator-() const; @@ -135,6 +138,16 @@ } template <unsigned n> + int_s<n>& + int_s<n>::operator=(int i) + { + mln_precondition(i >= mln_min(enc)); + mln_precondition(i <= mln_max(enc)); + this->v_ = i; + return *this; + } + + template <unsigned n> int_s<n> int_s<n>::operator-() const { Index: mln/value/int_u.hh --- mln/value/int_u.hh (revision 1060) +++ mln/value/int_u.hh (working copy) @@ -71,6 +71,9 @@ /// Constructor from an integer. int_u(int i); + /// Assignment from an integer. + int_u<n>& operator=(int i); + /// Zero value. static const int_u<n> zero; @@ -132,6 +135,16 @@ template <unsigned n> int_u<n>& + int_u<n>::operator=(int i) + { + mln_precondition(i >= 0); + mln_precondition(i <= mln_max(enc)); + this->v_ = i; + return *this; + } + + template <unsigned n> + int_u<n>& int_u<n>::operator+=(int i) { mln_precondition(long(this->v_) + i >= 0);

1 0

1060: Add morphology plus and minus.
by Thierry Geraud 29 Aug '07

29 Aug '07

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add morphology plus and minus. * tests/erosion.cc: Rename as... * tests/morpho_erosion.cc: ...this. * mln/geom/pmin_pmax.hh: Fix. * mln/morpho/plus.hh: New. * mln/morpho/minus.hh: New. * mln/logical: New. * mln/logical/and.hh: New. * mln/logical/and_not.hh: New. * mln/logical/or.hh: New. * mln/morpho/includes.hh, * mln/morpho/gradient.hh, * mln/morpho/contrast.hh, * mln/morpho/top_hat.hh: Update. mln/geom/pmin_pmax.hh | 4 - mln/logical/and.hh | 127 ++++++++++++++++++++++++++++++++++++++++++++++++ mln/logical/and_not.hh | 127 ++++++++++++++++++++++++++++++++++++++++++++++++ mln/logical/or.hh | 127 ++++++++++++++++++++++++++++++++++++++++++++++++ mln/morpho/contrast.hh | 4 - mln/morpho/gradient.hh | 6 +- mln/morpho/includes.hh | 5 - mln/morpho/minus.hh | 111 +++++++++++++++++++++++++++++++++++++++++ mln/morpho/plus.hh | 108 ++++++++++++++++++++++++++++++++++++++++ mln/morpho/top_hat.hh | 6 +- tests/morpho_erosion.cc | 2 11 files changed, 613 insertions(+), 14 deletions(-) Index: tests/morpho_erosion.cc --- tests/morpho_erosion.cc (revision 1059) +++ tests/morpho_erosion.cc (working copy) @@ -25,7 +25,7 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/*! \file tests/erosion.cc +/*! \file tests/morpho_erosion.cc * * \brief Test on mln::morpho::erosion. */ Index: mln/geom/pmin_pmax.hh --- mln/geom/pmin_pmax.hh (revision 1059) +++ mln/geom/pmin_pmax.hh (working copy) @@ -108,7 +108,7 @@ { typedef mln_point(I) P; std::pair<P, P> tmp; - pmin_pmax(p, tmp.first, tmp.second); // calls the previous version + pmin_pmax(p, tmp.first, tmp.second); // Calls the previous version. return tmp; } @@ -156,7 +156,7 @@ mln_precondition(exact(s).npoints() != 0); typedef mln_point(S) P; std::pair<P, P> tmp; - pmin_pmax(p_, tmp.first, tmp.second); // calls the previous version + pmin_pmax(s, tmp.first, tmp.second); // Calls the previous version. return tmp; } Index: mln/morpho/plus.hh --- mln/morpho/plus.hh (revision 0) +++ mln/morpho/plus.hh (revision 0) @@ -0,0 +1,108 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_PLUS_HH +# define MLN_MORPHO_PLUS_HH + +# include <mln/level/compare.hh> +# include <mln/logical/or.hh> +# include <mln/arith/plus.hh> + + +namespace mln +{ + + namespace morpho + { + + /*! Morphological plus: either a "logical or" (if morpho on sets) + * or an "arithmetical plus" (if morpho on functions). + */ + template <typename I, typename J, typename O> + void plus(const Image& lhs, const Image<J>& rhs, + Image<O>& output); + + /*! Morphological plus, inplace version: either a "logical or" (if + * morpho on sets) or an "arithmetical plus" (if morpho on + * functions). + */ + template <typename I, typename J> + void plus_inplace(Image& lhs, const Image<J>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename J, typename O> + void plus_(value::binary_kind, // binary => morphology on sets + const Image& lhs, const Image<J>& rhs, + Image<O>& output) + { + return logical::or_(lhs, rhs, output); + } + + template <typename K, typename I, typename J, typename O> + void plus_(K, // otherwise => morphology on functions + const Image& lhs, const Image<J>& rhs, + Image<O>& output) + { + return arith::plus(lhs, rhs, output); + } + + } // end of namespace mln::morpho::impl + + + // Facades. + + template <typename I, typename J, typename O> + void plus(const Image& lhs, const Image<J>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + + impl::plus_(mln_value_kind(I)(), exact(lhs), exact(rhs), output); + + mln_postcondition(output <= lhs); + } + + template <typename I, typename J> + void plus_inplace(Image& lhs, const Image<J>& rhs) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + morpho::plus(lhs, rhs, lhs); // Calls the previous version. + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_PLUS_HH Index: mln/morpho/includes.hh --- mln/morpho/includes.hh (revision 1059) +++ mln/morpho/includes.hh (working copy) @@ -40,9 +40,6 @@ # include <mln/accu/min.hh> # include <mln/accu/max.hh> -# include <mln/arith/plus.hh> -# include <mln/arith/minus.hh> - # include <mln/level/compare.hh> # include <mln/level/fill.hh> @@ -54,6 +51,8 @@ # include <mln/morpho/dilation.hh> # include <mln/morpho/erosion.hh> +# include <mln/morpho/minus.hh> +# include <mln/morpho/plus.hh> #endif // ! MLN_MORPHO_INCLUDES_HH Index: mln/morpho/minus.hh --- mln/morpho/minus.hh (revision 0) +++ mln/morpho/minus.hh (revision 0) @@ -0,0 +1,111 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_MORPHO_MINUS_HH +# define MLN_MORPHO_MINUS_HH + +# include <mln/level/compare.hh> +# include <mln/logical/and_not.hh> +# include <mln/arith/minus.hh> + + +namespace mln +{ + + namespace morpho + { + + /*! Morphological minus: either a logical "and not" (if morpho on + * sets) or an arithmetical minus (if morpho on functions). + */ + template <typename I, typename J, typename O> + void minus(const Image& lhs, const Image<J>& rhs, + Image<O>& output); + + /*! Morphological minus, inplace version: either a logical "and + * not" (if morpho on sets) or an arithmetical minus (if morpho + * on functions). + */ + template <typename I, typename J> + void minus_inplace(Image& lhs, const Image<J>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename J, typename O> + void minus_(value::binary_kind, // binary => morphology on sets + const Image& lhs, const Image<J>& rhs, + Image<O>& output) + { + return logical::and_not(lhs, rhs, output); + } + + template <typename K, typename I, typename J, typename O> + void minus_(K, // otherwise => morphology on functions + const Image& lhs, const Image<J>& rhs, + Image<O>& output) + { + return arith::minus(lhs, rhs, output); + } + + } // end of namespace mln::morpho::impl + + + // Facades. + + template <typename I, typename J, typename O> + void minus(const Image& lhs, const Image<J>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + mln_precondition(rhs <= lhs); + + impl::minus_(mln_value_kind(I)(), exact(lhs), exact(rhs), output); + + mln_postcondition(output <= lhs); + } + + template <typename I, typename J> + void minus_inplace(Image& lhs, const Image<J>& rhs) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(rhs <= lhs); + + morpho::minus(lhs, rhs, lhs); // Calls the previous version. + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::morpho + +} // end of namespace mln + + +#endif // ! MLN_MORPHO_MINUS_HH Index: mln/morpho/gradient.hh --- mln/morpho/gradient.hh (revision 1059) +++ mln/morpho/gradient.hh (working copy) @@ -86,7 +86,7 @@ dilation(input, win, output); // output = dilation O temp(input.domain()); erosion(input, win, temp); // temp = erosion - arith::minus_inplace(output, temp); // now output = dilation - erosion + morpho::minus_inplace(output, temp); // now output = dilation - erosion mln_postcondition(test::positive(output)); } @@ -104,7 +104,7 @@ O temp(input.domain()); erosion(input, win, temp); // temp = erosion - arith::minus(input, temp, output); // output = input - erosion + morpho::minus(input, temp, output); // output = input - erosion mln_postcondition(test::positive(output)); } @@ -121,7 +121,7 @@ mln_precondition(! win.is_empty()); dilation(input, win, output); // output = dilation - arith::minus_inplace(output, input); // now output = dilation - input + morpho::minus_inplace(output, input); // now output = dilation - input mln_postcondition(test::positive(output)); } Index: mln/morpho/contrast.hh --- mln/morpho/contrast.hh (revision 1059) +++ mln/morpho/contrast.hh (working copy) @@ -66,10 +66,10 @@ mln_precondition(! win.is_empty()); top_hat_white(input, win, output); // output = wth - arith::plus_inplace(output, input); // now output = wth + input + morpho::plus_inplace(output, input); // now output = wth + input O temp(input.domain()); top_hat_black(input, win, temp); // temp = bth - arith::minus_inplace(output, temp); // now output = wth + input - bth + morpho::minus_inplace(output, temp); // now output = wth + input - bth } # endif // ! MLN_INCLUDE_ONLY Index: mln/morpho/top_hat.hh --- mln/morpho/top_hat.hh (revision 1059) +++ mln/morpho/top_hat.hh (working copy) @@ -89,7 +89,7 @@ O temp(input.domain()); opening(input, win, temp); // temp = opening - arith::minus(input, temp, output); // output = input - opening + morpho::minus(input, temp, output); // output = input - opening mln_postcondition(test::positive(output)); } @@ -105,7 +105,7 @@ mln_precondition(! win.is_empty()); closing(input, win, output); // output = closing - arith::minus_inplace(output, input); // now output = closing - input + morpho::minus_inplace(output, input); // now output = closing - input mln_postcondition(test::positive(output)); } @@ -123,7 +123,7 @@ closing(input, win, output); // output = closing O temp(input.domain()); opening(input, win, temp); // temp = opening - arith::minus_inplace(output, temp); // now output = closing - opening + morpho::minus_inplace(output, temp); // now output = closing - opening mln_postcondition(test::positive(output)); } Index: mln/logical/and.hh --- mln/logical/and.hh (revision 0) +++ mln/logical/and.hh (revision 0) @@ -0,0 +1,127 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LOGICAL_AND_HH +# define MLN_LOGICAL_AND_HH + +/*! \file mln/logical/and.hh + * + * \brief Point-wise "logical and" between binary images. + * + * \todo Add static assertion and save one iterator in in-place version. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace logical + { + + /*! Point-wise "logical and" between images \p lhs and \p rhs. + * + * \param[in] lhs First operand image. + * \param[in] rhs Second operand image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p lhs.domain = \p rhs.domain + */ + template <typename L, typename R, typename O> + void and_(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output); + + + /*! Point-wise in-place "logical and" of image \p rhs in image \p lhs. + * + * \param[in] lhs First operand image. + * \param[in,out] rhs Second operand image. + * + * This addition performs: \n + * for all p of rhs.domain \n + * lhs(p) = lhs(p) and rhs(p) + * + * \pre \p rhs.domain <= \p lhs.domain + */ + template <typename L, typename R> + void and_inplace(Image<L>& lhs, const Image<R>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename L, typename R, typename O> + void and__(const Image<L>& lhs_, const Image<R>& rhs_, Image<O>& output_) + { + const L& lhs = exact(lhs_); + const R& rhs = exact(rhs_); + O& output = exact(output_); + mln_piter(L) p(lhs.domain()); + for_all(p) + output(p) = lhs(p) && rhs(p); + } + + template <typename L, typename R, typename O> + void and__(const Fast_Image<L>& lhs, const Fast_Image<R>& rhs, Fast_Image<O>& output) + { + mln_pixter(const L) lp(exact(lhs)); + mln_pixter(const R) rp(exact(rhs)); + mln_pixter(O) op(exact(output)); + for_all_3(lp, rp, op) + op.val() = lp.val() && rp.val(); + } + + } // end of namespace mln::logical::impl + + + // Facades. + + template <typename L, typename R, typename O> + void and_(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + impl::and__(exact(lhs), exact(rhs), exact(output)); + } + + template <typename L, typename R> + void and_inplace(Image<L>& lhs, const Image<R>& rhs) + { + mln_precondition(exact(rhs).domain() <= exact(lhs).domain()); + impl::and__(exact(lhs), exact(rhs), exact(lhs)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::logical + +} // end of namespace mln + + +#endif // ! MLN_LOGICAL_AND_HH Index: mln/logical/and_not.hh --- mln/logical/and_not.hh (revision 0) +++ mln/logical/and_not.hh (revision 0) @@ -0,0 +1,127 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LOGICAL_AND_NOT_HH +# define MLN_LOGICAL_AND_NOT_HH + +/*! \file mln/logical/and_not.hh + * + * \brief Point-wise logical "and not" between binary images. + * + * \todo Add static assertion and save one iterator in in-place version. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace logical + { + + /*! Point-wise logical "and not" between images \p lhs and \p rhs. + * + * \param[in] lhs First operand image. + * \param[in] rhs Second operand image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p lhs.domain = \p rhs.domain + */ + template <typename L, typename R, typename O> + void and_not(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output); + + + /*! Point-wise in-place logical "and not" of image \p rhs in image \p lhs. + * + * \param[in] lhs First operand image. + * \param[in,out] rhs Second operand image. + * + * This addition performs: \n + * for all p of rhs.domain \n + * lhs(p) = lhs(p) and not rhs(p) + * + * \pre \p rhs.domain <= \p lhs.domain + */ + template <typename L, typename R> + void and_not_inplace(Image<L>& lhs, const Image<R>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename L, typename R, typename O> + void and_not_(const Image<L>& lhs_, const Image<R>& rhs_, Image<O>& output_) + { + const L& lhs = exact(lhs_); + const R& rhs = exact(rhs_); + O& output = exact(output_); + mln_piter(L) p(lhs.domain()); + for_all(p) + output(p) = lhs(p) && ! rhs(p); + } + + template <typename L, typename R, typename O> + void and_not_(const Fast_Image<L>& lhs, const Fast_Image<R>& rhs, Fast_Image<O>& output) + { + mln_pixter(const L) lp(exact(lhs)); + mln_pixter(const R) rp(exact(rhs)); + mln_pixter(O) op(exact(output)); + for_all_3(lp, rp, op) + op.val() = lp.val() && ! rp.val(); + } + + } // end of namespace mln::logical::impl + + + // Facades. + + template <typename L, typename R, typename O> + void and_not(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + impl::and_not_(exact(lhs), exact(rhs), exact(output)); + } + + template <typename L, typename R> + void and_not_inplace(Image<L>& lhs, const Image<R>& rhs) + { + mln_precondition(exact(rhs).domain() <= exact(lhs).domain()); + impl::and_not_(exact(lhs), exact(rhs), exact(lhs)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::logical + +} // end of namespace mln + + +#endif // ! MLN_LOGICAL_AND_NOT_HH Index: mln/logical/or.hh --- mln/logical/or.hh (revision 0) +++ mln/logical/or.hh (revision 0) @@ -0,0 +1,127 @@ +// Copyright (C) 2007 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, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef MLN_LOGICAL_OR_HH +# define MLN_LOGICAL_OR_HH + +/*! \file mln/logical/or.hh + * + * \brief Point-wise "logical or" between binary images. + * + * \todo Add static assertion and save one iterator in in-place version. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace logical + { + + /*! Point-wise "logical or" between images \p lhs and \p rhs. + * + * \param[in] lhs First operand image. + * \param[in] rhs Second operand image. + * \param[out] output The result image. + * + * \pre \p output.domain = \p lhs.domain = \p rhs.domain + */ + template <typename L, typename R, typename O> + void or_(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output); + + + /*! Point-wise in-place "logical or" of image \p rhs in image \p lhs. + * + * \param[in] lhs First operand image. + * \param[in,out] rhs Second operand image. + * + * This addition performs: \n + * for all p of rhs.domain \n + * lhs(p) = lhs(p) or rhs(p) + * + * \pre \p rhs.domain <= \p lhs.domain + */ + template <typename L, typename R> + void or_inplace(Image<L>& lhs, const Image<R>& rhs); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename L, typename R, typename O> + void or__(const Image<L>& lhs_, const Image<R>& rhs_, Image<O>& output_) + { + const L& lhs = exact(lhs_); + const R& rhs = exact(rhs_); + O& output = exact(output_); + mln_piter(L) p(lhs.domain()); + for_all(p) + output(p) = lhs(p) || rhs(p); + } + + template <typename L, typename R, typename O> + void or__(const Fast_Image<L>& lhs, const Fast_Image<R>& rhs, Fast_Image<O>& output) + { + mln_pixter(const L) lp(exact(lhs)); + mln_pixter(const R) rp(exact(rhs)); + mln_pixter(O) op(exact(output)); + for_all_3(lp, rp, op) + op.val() = lp.val() || rp.val(); + } + + } // end of namespace mln::logical::impl + + + // Facades. + + template <typename L, typename R, typename O> + void or_(const Image<L>& lhs, const Image<R>& rhs, Image<O>& output) + { + mln_precondition(exact(rhs).domain() = exact(lhs).domain()); + mln_precondition(exact(output).domain() = exact(lhs).domain()); + impl::or__(exact(lhs), exact(rhs), exact(output)); + } + + template <typename L, typename R> + void or_inplace(Image<L>& lhs, const Image<R>& rhs) + { + mln_precondition(exact(rhs).domain() <= exact(lhs).domain()); + impl::or__(exact(lhs), exact(rhs), exact(lhs)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::logical + +} // end of namespace mln + + +#endif // ! MLN_LOGICAL_OR_HH

1 0