Olena-patches February 2008

olena-patches@lrde.epita.fr

12 participants
70 discussions

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Binarization. * mln/level/threshold.hh: Remove. * mln/fun/v2b: New directory : value to bool function. * mln/fun/v2b/threshold.hh: value to bool threshold. * mln/fun/v2v/threshold.hh: Remove. * mln/binarization: New directory. * mln/binarization/includes.hh: include for binarization. * mln/binarization/binarization.hh: generic binarization (v2b for now). * mln/binarization/thresholding.hh: thresholding. * mln/io/pnm/save.hh: Comments for dummy (me) users who try to save binary as pgm. * tests/binarization: New test directory. * tests/binarization/thresholding.cc: New test file. mln/binarization/binarization.hh | 106 +++++++++++++++++++++++++++++++++++++ mln/binarization/includes.hh | 43 +++++++++++++++ mln/binarization/thresholding.hh | 89 +++++++++++++++++++++++++++++++ mln/fun/v2b/threshold.hh | 90 +++++++++++++++++++++++++++++++ mln/io/pnm/save.hh | 2 tests/binarization/thresholding.cc | 54 ++++++++++++++++++ 6 files changed, 384 insertions(+) Index: tests/binarization/thresholding.cc --- tests/binarization/thresholding.cc (revision 0) +++ tests/binarization/thresholding.cc (revision 0) @@ -0,0 +1,54 @@ +// Copyright (C) 2007, 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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/binarization/thresholding.cc + * + * \brief Test on mln::binarization::thresholding + */ + + +#include <mln/core/image2d.hh> +#include <mln/binarization/thresholding.hh> +#include <mln/level/all.hh> + +#include <mln/io/pgm/load.hh> +#include <mln/io/pbm/save.hh> + +//#include "tests/data.hh" + +int main(int argc, char **) +{ + using namespace mln; + using value::int_u8; + + typedef image2d<int_u8> I; + + I lena; + io::pgm::load(lena, "../../img/lena.pgm"); + + io::pbm::save(binarization::thresholding(lena, argc), "out1.pgm"); +} Index: tests/morpho/gradient.cc Index: mln/fun/v2b/threshold.hh --- mln/fun/v2b/threshold.hh (revision 0) +++ mln/fun/v2b/threshold.hh (revision 0) @@ -0,0 +1,90 @@ +// Copyright (C) 2008 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_V2B_THRESHOLD_HH +# define MLN_FUN_V2B_THRESHOLD_HH + +/*! \file mln/fun/v2b/threshold.hh + * + * \brief FIXME. + */ + +# include <mln/core/concept/function.hh> + + +namespace mln +{ + + namespace fun + { + + namespace v2b + { + + /*! + *\brief Threshold function. + * f(v) = (v >= threshold). + * + */ + template <typename V> + struct threshold : public Function_v2b< threshold<V> > + { + typedef bool result; + bool operator()(const V& v) const; + + threshold(const V& a); + V a; + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename V> + inline + threshold<V>::threshold(const V& a) + : a(a) + { + } + + template <typename V> + inline + bool + threshold<V>::operator()(const V& v) const + { + return (v >= a); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::fun::v2b + + } // end of namespace mln::fun + +} // end of namespace mln + + +#endif // ! MLN_FUN_V2B_THRESHOLD_HH Index: mln/binarization/includes.hh --- mln/binarization/includes.hh (revision 0) +++ mln/binarization/includes.hh (revision 0) @@ -0,0 +1,43 @@ +// Copyright (C) 2008 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_BINARIZATION_INCLUDES_HH +# define MLN_BINARIZATION_INCLUDES_HH + +/*! \file mln/binarization/includes.hh + * + * \brief Basic list of includes for all files in mln/binarization/. + */ + + +# include <mln/core/concept/image.hh> +# include <mln/core/concept/window.hh> +# include <mln/core/concept/neighborhood.hh> + +# include <mln/metal/has_neighborhood.hh> + +#endif // ! MLN_BINARIZATION_INCLUDES_HH Index: mln/binarization/binarization.hh --- mln/binarization/binarization.hh (revision 0) +++ mln/binarization/binarization.hh (revision 0) @@ -0,0 +1,106 @@ +// Copyright (C) 2008 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_BINARIZATION_BINARIZATION_HH +# define MLN_BINARIZATION_BINARIZATION_HH + +/*! \file mln/binarization/threshold.hh + * + * \brief Threshold the contents of an image into another binary one. + */ + +# include <mln/core/concept/function.hh> +# include <mln/level/transform.hh> + + +namespace mln +{ + + namespace binarization + { + + /*! Thresholds the values of \p input so that they can be stored in + * the \p output binary image. + * + * \param[in] input The input image. + * \param[in] fun The thresholding function, from value(I) to bool. + * + * for_all(p), output(p) = fun(p) + * + */ + template <typename I, typename F> + inline + mln_concrete_ch_value(I, bool) + binarization(const Image& input, const Function_v2b<F>& fun); + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I, typename F> + inline + mln_concrete_ch_value(I, bool) + binarization_(const I& input, const Function_v2b<F>& fun) + { + trace::entering("binarization::impl::binarization_"); + mln_concrete_ch_value(I, bool) output(input.domain()); + + level::transform(input, fun, output); + + trace::exiting("binarization::impl::binarization_"); + return output; + } + + } // end of namespace mln::binarization::impl + + + template <typename I, typename F> + inline + mln_concrete_ch_value(I, bool) + binarization(const Image& input, const Function_v2b<F>& fun) + { + trace::entering("binarization::binarization"); + mln_precondition(exact(input).has_data()); + mlc_is(mln_trait_value_nature(mln_value(I)), + trait::value::nature::scalar)::check(); + + mln_concrete_ch_value(I, bool) output(exact(input).domain()); + output = impl::binarization_(exact(input), fun); + + trace::exiting("binarization::binarization"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::binarization + +} // end of namespace mln + + +#endif // ! MLN_BINARIZATION_THRESHOLDING_HH Index: mln/binarization/thresholding.hh --- mln/binarization/thresholding.hh (revision 0) +++ mln/binarization/thresholding.hh (revision 0) @@ -0,0 +1,89 @@ +// Copyright (C) 2008 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_BINARIZATION_THRESHOLDING_HH +# define MLN_BINARIZATION_THRESHOLDING_HH + +/*! \file mln/binarization/thresholding.hh + * + * \brief Threshold the contents of an image into another binary one. + */ + +# include <mln/binarization/binarization.hh> +# include <mln/fun/v2b/threshold.hh> + + +namespace mln +{ + + namespace binarization + { + + /*! Thresholds the values of \p input so that they can be stored in + * the \p output binary image. + * + * \param[in] input The input image. + * \param[in] threshold The threshold. + * + * If input(p) is greater or equal than the threshold, the + * value in the output image in the same point will be TRUE, else FALSE. + * + */ + template <typename I> + mln_concrete_ch_value(I, bool) + thresholding(const Image& input, const mln_value(I) threshold); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + inline + mln_concrete_ch_value(I, bool) + thresholding(const Image& input, const mln_value(I) threshold) + { + trace::entering("binarization::thresholding"); + mln_precondition(exact(input).has_data()); + mlc_is(mln_trait_value_nature(mln_value(I)), + trait::value::nature::scalar)::check(); + + mln_concrete_ch_value(I, bool) output(exact(input).domain()); + + fun::v2b::threshold< mln_value(I) > f(threshold); + output = binarization::binarization(exact(input), f); + + trace::exiting("binarization::thresholding"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::binarization + +} // end of namespace mln + + +#endif // ! MLN_BINARIZATION_THRESHOLDING_HH Index: mln/io/pnm/save.hh --- mln/io/pnm/save.hh (revision 1734) +++ mln/io/pnm/save.hh (working copy) @@ -102,6 +102,8 @@ void write_value(std::ofstream& file, const V& v) { + // if V is not a struct you are probably trying to write binary images + // use pbm files for binary images typedef typename V::enc E; E c = v.to_enc();

16 years, 2 months

milena r1734: New structures

by Caroline Vigouroux

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2008-02-17 Caroline Vigouroux <vigour_c(a)epita.fr> New structures. * my_hsl.hh: New. * my_hsv.hh: New. * my_xyz.hh: New. * my_yiq.hh: New. * rgb_to_hsi.hh: . --- my_hsl.hh | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ my_hsv.hh | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ my_xyz.hh | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ my_yiq.hh | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ rgb_to_hsi.hh | 11 ++++++-- 5 files changed, 288 insertions(+), 3 deletions(-) Index: trunk/milena/sandbox/vigouroux/color/my_hsl.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/my_hsl.hh (revision 0) +++ trunk/milena/sandbox/vigouroux/color/my_hsl.hh (revision 1734) @@ -0,0 +1,71 @@ +#include <mln/value/ops.hh> + +#include <mln/value/concept/vectorial.hh> +#include <mln/value/int_u.hh> +#include <mln/metal/vec.hh> + +#ifndef MLN_VALUE_HSL_HH +# define MLN_VALUE_HSL_HH + +namespace mln +{ + namespace value + { + template <unsigned n> + struct hsl + { + public: + /// Constructor without argument. + hsl<n>(); + + /// Constructor from component values. + hsl<n>(int h, int s, int l); + + /// Access to component values. + double h() const { return this->h_; } + double s() const { return this->s_; } + double l() const { return this->l_; } + + /// Set component values. + void h(double h) + { + this->h_ = h; + } + void s(double s) + { + this->s_ = s; + } + void l(double l) + { + mln_precondition(l >= 0); + this->l_ = l; + } + + private: + double h_; + double s_; + double l_; + }; + + template <unsigned n> + inline + hsl<n>::hsl() + :h_(0), s_(0), l_(0) + { + } + + template <unsigned n> + inline + hsl<n>::hsl(int h, int s, int l) + { + mln_precondition(h >= 0); + mln_precondition(s >= 0); + mln_precondition(l >= 0); + this->h_ = h; + this->s_ = s; + this->l_ = l; + } + } +} + +#endif // ! MLN_VALUE_HSL_HH Index: trunk/milena/sandbox/vigouroux/color/my_xyz.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/my_xyz.hh (revision 0) +++ trunk/milena/sandbox/vigouroux/color/my_xyz.hh (revision 1734) @@ -0,0 +1,69 @@ +// #include <mln/value/ops.hh> + +// #include <mln/value/concept/vectorial.hh> +// #include <mln/value/int_u.hh> +// #include <mln/metal/vec.hh> + +#ifndef MLN_VALUE_XYZ_HH +# define MLN_VALUE_XYZ_HH + +namespace mln +{ + namespace value + { + template <unsigned n> + struct xyz + { + public: + /// Constructor without argument. + xyz<n>(); + + /// Constructor from component values. + xyz<n>(double x, double y, double z); + + /// Access to component values. + double x() const { return this->x_; } + double y() const { return this->y_; } + double z() const { return this->z_; } + + /// Set component values. + void x(double x) + { + this->x_ = x; + } + void y(double y) + { + this->y_ = y; + } + void z(double z) + { + mln_precondition(z >= 0); + this->z_ = z; + } + + private: + double x_; + double y_; + double z_; + }; + + template <unsigned n> + inline + xyz<n>::xyz() + :x_(0), y_(0), z_(0) + { + } + + template <unsigned n> + inline + xyz<n>::xyz(double x, double y, double z) + { + mln_precondition(z >= 0); + this->x_ = x; + this->y_ = y; + this->z_ = z; + } + } +} + +#endif // ! MLN_VALUE_XYZ_HH Index: trunk/milena/sandbox/vigouroux/color/my_hsv.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/my_hsv.hh (revision 0) +++ trunk/milena/sandbox/vigouroux/color/my_hsv.hh (revision 1734) @@ -0,0 +1,71 @@ +#include <mln/value/ops.hh> + +#include <mln/value/concept/vectorial.hh> +#include <mln/value/int_u.hh> +#include <mln/metal/vec.hh> + +#ifndef MLN_VALUE_HSV_HH +# define MLN_VALUE_HSV_HH + +namespace mln +{ + namespace value + { + template <unsigned n> + struct hsv + { + public: + /// Constructor without argument. + hsv<n>(); + + /// Constructor from component values. + hsv<n>(int h, int s, int v); + + /// Access to component values. + double h() const { return this->h_; } + double s() const { return this->s_; } + double v() const { return this->v_; } + + /// Set component values. + void h(double h) + { + this->h_ = h; + } + void s(double s) + { + this->s_ = s; + } + void v(double v) + { + mln_precondition(v >= 0); + this->v_ = v; + } + + private: + double h_; + double s_; + double v_; + }; + + template <unsigned n> + inline + hsi<n>::hsv() + :h_(0), s_(0), v_(0) + { + } + + template <unsigned n> + inline + hsv<n>::hsv(int h, int s, int v) + { + mln_precondition(h >= 0); + mln_precondition(s >= 0); + mln_precondition(v >= 0); + this->h_ = h; + this->s_ = s; + this->v_ = v; + } + } +} + +#endif // ! MLN_VALUE_HSV_HH Index: trunk/milena/sandbox/vigouroux/color/my_yiq.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/my_yiq.hh (revision 0) +++ trunk/milena/sandbox/vigouroux/color/my_yiq.hh (revision 1734) @@ -0,0 +1,69 @@ +// #include <mln/value/ops.hh> + +// #include <mln/value/concept/vectorial.hh> +// #include <mln/value/int_u.hh> +// #include <mln/metal/vec.hh> + +#ifndef MLN_VALUE_YIQ_HH +# define MLN_VALUE_YIQ_HH + +namespace mln +{ + namespace value + { + template <unsigned n> + struct yiq + { + public: + /// Constructor without argument. + yiq<n>(); + + /// Constructor from component values. + yiq<n>(double y, double i, double q); + + /// Access to component values. + double y() const { return this->y_; } + double i() const { return this->i_; } + double q() const { return this->q_; } + + /// Set component values. + void y(double y) + { + this->y_ = y; + } + void i(double i) + { + this->i_ = i; + } + void q(double q) + { + mln_precondition(q >= 0); + this->q_ = q; + } + + private: + double y_; + double i_; + double q_; + }; + + template <unsigned n> + inline + yiq<n>::yiq() + :y_(0), i_(0), q_(0) + { + } + + template <unsigned n> + inline + yiq<n>::yiq(double y, double i, double q) + { + mln_precondition(q >= 0); + this->y_ = y; + this->i_ = i; + this->q_ = q; + } + } +} + +#endif // ! MLN_VALUE_YIQ_HH Index: trunk/milena/sandbox/vigouroux/color/rgb_to_hsi.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/rgb_to_hsi.hh (revision 1733) +++ trunk/milena/sandbox/vigouroux/color/rgb_to_hsi.hh (revision 1734) @@ -16,10 +16,15 @@ doit(const struct value::rgb<8> rgb) const { struct value::hsi<8> hsi; + double alpha; + double beta; - hsi.h(0); // not yet implemented - hsi.s(0); // not yet implemented - hsi.i(0); // not yet implemented + alpha = rgb.red() - 1 / 2 * (rgb.green() + rgb.blue()); + beta = sqrt(3) / 2 * (rgb.green() - rgb.blue()); + + hsi.h(atan2(beta / alpha)); + hsi.s(sqrt(alpha * alpha + beta * beta)); + hsi.i((rgb.red() + rgb.green() + rgb.blue()) / 3); return (hsi); }

16 years, 2 months

milena r1733: Add a constructor to plain image type

by Matthieu Garrigues

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2008-02-16 Matthieu Garrigues <garrigues(a)lrde.epita.fr> Add a constructor to plain image type. * mln/core/plain.hh: (plain::plain()) New. * tests/decorated_image.cc: Add a todo, this test doesn't work * tests/plain.cc: Explain the use of plain image. --- mln/core/plain.hh | 8 ++++++++ tests/decorated_image.cc | 1 + tests/plain.cc | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 42 insertions(+) Index: trunk/milena/tests/plain.cc =================================================================== --- trunk/milena/tests/plain.cc (revision 1732) +++ trunk/milena/tests/plain.cc (revision 1733) @@ -35,6 +35,10 @@ #include <mln/value/int_u8.hh> #include <mln/level/compare.hh> +#include <mln/level/fill.hh> + + +#include <mln/debug/println.hh> #include <mln/io/pgm/load.hh> #include <mln/io/pgm/save.hh> @@ -74,4 +78,33 @@ mln_assertion(ima == ima2); } + + { + image2d<int_u8> lena(12,12); + level::fill(lena, 42); + + point2d p1(0,0); + point2d p2(5,4); + + image2d< image2d<int_u8> > ima(2,2); + level::fill(ima, lena); + // The 4 pixels of ima share the same data (holded by lena). + // Then this update will affect the 4 pixels of ima. + ima(p1)(p2) = 0; + // ima(0,0)(p2) == ima(0,1)(p2) == ima(1,0)(p2) == ima(1,1)(p2) == 0 + + image2d< plain< image2d<int_u8> > > ima_plain(2,2); + level::fill(ima_plain, plain< image2d<int_u8> >(lena)); + // The 4 pixels of ima_plain are instances of plain< + // image2d<int_u8> >. So each of them hold their own data. Then + // this update will affect just one pixel at the coordinate 0,0 of + // ima_plain. + ima_plain(p1)(p2) = 0; + // ima_plain(0,0)(p2) == 0 + // ima_plain(0,1)(p2) == 0 + // ima_plain(1,0)(p2) == 0 + // ima_plain(1,1)(p2) == 0 + + } + } Index: trunk/milena/tests/decorated_image.cc =================================================================== --- trunk/milena/tests/decorated_image.cc (revision 1732) +++ trunk/milena/tests/decorated_image.cc (revision 1733) @@ -28,6 +28,7 @@ /*! \file tests/decorated_image.cc * * \brief Tests on mln::decorated_image. + * \todo Make this test work. */ #include <mln/core/image2d.hh> Index: trunk/milena/mln/core/plain.hh =================================================================== --- trunk/milena/mln/core/plain.hh (revision 1732) +++ trunk/milena/mln/core/plain.hh (revision 1733) @@ -89,6 +89,7 @@ /// Constructors. plain(const I& ima); + plain(); /// Read-only access of pixel value at point site \p p. /// Mutable access is only OK for reading (not writing). @@ -128,6 +129,13 @@ this->data_ = new internal::data_< plain >(ima); } + + template <typename I> + inline + plain::plain() + { + } + template <typename I> inline plain&

16 years, 2 months

1732: Add a test applying a full WST-based segmentation chain on a line graph.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena I know I should probably move the tests related to the WST to tests/morpho. Please recall this to me if I forget to do it. TIA. Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add a test applying a full WST-based segmentation chain on a line graph. * tests/core/lena_line_graph_image_wst.cc: New test. * tests/core/graph_image_wst.cc: Fix Doxygen header. * tests/core/Makefile.am (check_PROGRAMS): Add lena_line_graph_image_wst. (lena_line_graph_image_wst_SOURCES) (lena_line_graph_image_wst_CXXFLAGS): New. * tests/morpho/Makefile.am (meyer_wst_long_CXXFLAGS): Append -ggdb. core/Makefile.am | 5 core/graph_image_wst.cc | 4 core/lena_line_graph_image_wst.cc | 249 ++++++++++++++++++++++++++++++++++++++ morpho/Makefile.am | 2 4 files changed, 257 insertions(+), 3 deletions(-) Index: tests/core/lena_line_graph_image_wst.cc --- tests/core/lena_line_graph_image_wst.cc (revision 0) +++ tests/core/lena_line_graph_image_wst.cc (revision 0) @@ -0,0 +1,249 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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/core/line_graph_image.cc +/// \brief Tests on the Watershed Transform on a mln::line_graph_image. + +#include <vector> + +#include <mln/core/image2d.hh> +#include <mln/core/point2d.hh> +#include <mln/core/window2d.hh> +#include <mln/core/neighb2d.hh> + +#include <mln/core/line_graph_image.hh> +#include <mln/core/line_graph_elt_neighborhood.hh> +#include <mln/core/line_graph_neighborhood_piter.hh> + +#include <mln/morpho/gradient.hh> +#include <mln/morpho/closing_area.hh> +#include <mln/morpho/meyer_wst.hh> + +#include <mln/value/int_u8.hh> +// #include <mln/value/int_u16.hh> +#include <mln/value/rgb8.hh> +#include <mln/literal/black.hh> +#include <mln/literal/colors.hh> + +#include <mln/io/pgm/load.hh> +#include <mln/io/ppm/save.hh> + +#include <mln/math/max.hh> +#include <mln/math/abs.hh> + +#include "tests/data.hh" + + + +int main() +{ + using namespace mln; + using value::int_u8; +// using value::int_u16; + using value::rgb8; + + /*--------. + | Input. | + `--------*/ + + typedef int_u8 input_val_t; + image2d<input_val_t> input; +// io::pgm::load(input, MLN_IMG_DIR "/small.pgm"); + io::pgm::load(input, MLN_IMG_DIR "/tiny.pgm"); + + /* FIXME: Don't compute a gradient on the image2d input. Instead, + have the values of the line graph image /behaves/ as the gradient + of the input, i.e., edges should hold the absolute difference + between gray levels. + */ + image2d<input_val_t> gradient = + morpho::gradient (input, convert::to_window(c4())); + + // Simplify the input image. + image2d<input_val_t> work(input.domain()); +// morpho::closing_area(gradient, c4(), 50, work); + morpho::closing_area(gradient, c4(), 10, work); + + /*-------------. + | Line graph. | + `-------------*/ + + // FIXME: Inlined conversion, to be reifed into a routine. + + util::graph<point2d> g; + + // Points. + /* FIXME: The need for such a structure during the conversion + exhibits the lack of a service from util::graph (or a another, + missing tool) regarding the retrieval of node ids from + points. */ + std::map<point2d, util::node_id> points; + util::node_id id = 0; + + // Nodes. + std::vector<int> node_values; + mln_fwd_piter_(image2d<input_val_t>) p(work.domain()); + for_all (p) + { + g.add_node (p); + node_values.push_back (work(p)); + /* FIXME: ``Guessing'' the id of the point just being inserted + is bad. utill:graph<N,E>::add_node should return this + id. */ + points[p] = id; + ++id; + } + + // Edges. + window2d next_c4_win; + next_c4_win.insert(0, 1).insert(1, 0); + std::vector<int> edge_values; + mln_fwd_qiter_(window2d) q(next_c4_win, p); + for_all (p) + for_all (q) + if (work.has(q)) + { + g.add_edge(points[p], points[q]); + // FIXME: Keep this valuation function? + edge_values.push_back(math::max(work(p), work(q))); + } + + // Line graph point set. + p_line_graph<point2d> plg(g); + + // Line graph image. + /* FIXME: Shouldn't we use `input_val_t' instead of plain `int' as value + type here? */ + typedef line_graph_image<point2d, int> ima_t; + ima_t lg_ima(plg, node_values, edge_values); + + /*------. + | WST. | + `------*/ + + typedef line_graph_elt_neighborhood<point2d> nbh_t; + nbh_t nbh; + + // Perform a Watershed Transform. + typedef int_u8 wst_val_t; + wst_val_t nbasins; + typedef line_graph_image<point2d, wst_val_t> wst_ima_t; + wst_ima_t wshed = morpho::meyer_wst(lg_ima, nbh, nbasins); + std::cout << "nbasins = " << nbasins << std::endl; + + /*---------. + | Output. | + `---------*/ + + // FIXME: Inlined conversion, to be reifed into a routine. + + // Save the result in gray levels (data) + color (wshed). + + // Data. + typedef rgb8 output_val_t; + typedef image2d<output_val_t> output_t; + point2d output_pmin = input.domain().pmin(); + point2d output_pmax(input.domain().pmax()[0] * 2, + input.domain().pmax()[1] * 2); + output_t output(box2d(output_pmin, output_pmax)); + level::fill(output, literal::black); + // Reuse the piter on INPUT. + for_all(p) + { + // Equivalent of P in OUTPUT. + point2d q(p[0] * 2, p[1] * 2); + input_val_t v = input(p); + /* FIXME: Use a conversion function from input_val_t to + output_val_t instead of an explicit construction. */ + output(q) = output_val_t(v, v, v); + } + // Interpolate missing points in OUTPUT. + mln_piter_(output_t) p_out(output.domain()); +// mln_niter_(neighb2d) n_out(c4(), p_out); + for_all(p_out) + { + // Process points on even rows and odd columns + if (p_out[0] % 2 == 0 && p_out[1] % 2 == 1) + output(p_out) = (output(p_out + left) + output(p_out + right)) / 2; + // Process points on odd rows and even columns + if (p_out[0] % 2 == 1 && p_out[1] % 2 == 0) + output(p_out) = (output(p_out + up) + output(p_out + down)) / 2; + // Process points on odd rows and odd columns + if (p_out[0] % 2 == 1 && p_out[1] % 2 == 1) + output(p_out) = + (output(p_out + make::dpoint2d(-1, -1)) + + output(p_out + make::dpoint2d(-1, +1)) + + output(p_out + make::dpoint2d(+1, -1)) + + output(p_out + make::dpoint2d(+1, +1))) / 4; + } + // Draw the watershed. + /* FIXME: We should draw the watershed on another image and + superimpose it on OUTPUT instead of drawing it directly into + OUTPUT. */ + mln_piter_(wst_ima_t) pw(wshed.domain()); + for_all(pw) + { + if (wshed(pw) == 0) + { + mln_point_(wst_ima_t) pp(pw); + // Equivalent of the line (edge) PP in OUTPUT. + int row1 = pp.first()[0] * 2; + int col1 = pp.first()[1] * 2; + int row2 = pp.second()[0] * 2; + int col2 = pp.second()[1] * 2; + point2d q((row1 + row2) / 2, (col1 + col2) / 2); + // Print the watershed in red. + output(q) = literal::red; + } + } + // Fill the holes, so that the watershed looks connected. + /* FIXME: This approach is bad: it creates thick lines of watershed. + We should probably solve this when we ``paint'' the watershed + over the ``doubled'' image. + + A better approach is probably to iterate over the set of nodes, + and ``connect'' edges according to patterns (vertically or + horizontally connected egdes member of the watershed, etc.). */ + // Reuse the piter on OUTPUT. + for_all (p_out) + // Only handle points on odd rows and columns. + if (p_out[0] % 2 == 1 && p_out[1] % 2 == 1) + { + // Count the number of adjacent watershed points. If there are + // two or more, consider, create a watershed point. + /* FIXME: Iterating over a c4 window would be more elegant, of + course. */ + unsigned nwsheds = + (output.has(p_out + up ) && output(p_out + up ) == literal::red) + + (output.has(p_out + down ) && output(p_out + down ) == literal::red) + + (output.has(p_out + left ) && output(p_out + right) == literal::red) + + (output.has(p_out + right) && output(p_out + left ) == literal::red); + if (nwsheds >= 2) + output(p_out) = literal::red; + } + io::ppm::save(output, "out.ppm"); +} Index: tests/core/graph_image_wst.cc --- tests/core/graph_image_wst.cc (revision 1719) +++ tests/core/graph_image_wst.cc (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/// \file tests/core/graph_image.cc -/// \brief Tests on mln::graph_image. +/// \file tests/core/graph_image_wst.cc +/// \brief Tests on the Watershed Transform on a mln::graph_image. #include <vector> Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 1731) +++ tests/core/Makefile.am (working copy) @@ -10,6 +10,7 @@ initialize \ graph_elt_window \ graph_image \ + lena_line_graph_image_wst \ line_graph_elt_window \ line_graph_image \ line_graph_image_wst \ @@ -51,4 +52,8 @@ t_image_SOURCES = t_image.cc tr_image_SOURCES = tr_image.cc +# FIXME: We should isolate this test, as it takes a long time. +lena_line_graph_image_wst_SOURCES = lena_line_graph_image_wst.cc +lena_line_graph_image_wst_CXXFLAGS = -O3 -ggdb + TESTS = $(check_PROGRAMS) Index: tests/morpho/Makefile.am --- tests/morpho/Makefile.am (revision 1731) +++ tests/morpho/Makefile.am (working copy) @@ -35,6 +35,6 @@ meyer_wst_SOURCES = meyer_wst.cc # FIXME: We should isolate this test, as it takes a long time. meyer_wst_long_SOURCES = meyer_wst_long.cc -meyer_wst_long_CXXFLAGS = -O3 +meyer_wst_long_CXXFLAGS = -O3 -ggdb TESTS = $(check_PROGRAMS)

16 years, 2 months

1731: Have mln::rgb's operators work better.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Have mln::rgb's operators work better. * mln/value/rgb.hh (rgb<n>::operator metal::vec<3, int>): New conversion operator. (operator+(const rgb<n>&, const rgb<n>&)) (operator-(const rgb<n>&, const rgb<n>&)) (operator*(const rgb<n>&, const mln::value::scalar_<S>&)) (operator/(const rgb<n>&, const mln::value::scalar_<S>&)): Use mln::rgb's interop type instead of mln::rgb directly. (operator+(const typename rgb<n>::interop&, const rgb<n>&)) (operator+(const rgb<n>&, const typename rgb<n>::interop&)) (operator-(const typename rgb<n>::interop&, const rgb<n>&)) (operator-(const rgb<n>&, const typename rgb<n>::interop&)) (operator*(const mln::value::scalar_<S>&, const rgb<n>&)): New operators. Remove dead code. * tests/value/rgb8.cc: Exercise more operators. mln/value/rgb.hh | 138 ++++++++++++++++++++++++++++++++++++++-------------- tests/value/rgb8.cc | 22 ++++++-- 2 files changed, 120 insertions(+), 40 deletions(-) Index: mln/value/rgb.hh --- mln/value/rgb.hh (revision 1730) +++ mln/value/rgb.hh (working copy) @@ -184,11 +184,15 @@ rgb<n>(const metal::vec<3, unsigned>& rhs); rgb<n>(const metal::vec<3, int_u<n> >& rhs); + // Conversion to the interoperation type. + operator metal::vec<3, int>() const { return this->v_; } + // Conversion to the sum type. operator metal::vec<3, float>() const { return this->v_; } /// \{ Constructors with literals. rgb<n>(const literal::white_t&); rgb<n>(const literal::black_t&); + rgb<n>(const literal::blue_t&); rgb<n>(const literal::red_t&); rgb<n>(const literal::green_t&); @@ -217,37 +221,70 @@ std::istream& operator>>(std::istream& istr, rgb<n>& c); - // FIXME: Cannot work for i negative; add traits! + /* FIXME: We should not need to define these operators, thanks to + Milena's global operator resolution mechanism based on + mln::Object. See what prevent us to use this mechanism. */ + + /* FIXME: Cannot work for i negative; add traits! (2008-02-16, + Roland: What does this comment mean?) */ /// Addition. + /// { template <unsigned n> - rgb<n> + typename rgb<n>::interop operator+(const rgb<n>& lhs, const rgb<n>& rhs); - /// Substraction. template <unsigned n> - rgb<n> + typename rgb<n>::interop + operator+(const typename rgb<n>::interop& lhs, const rgb<n>& rhs); + + template <unsigned n> + typename rgb<n>::interop + operator+(const rgb<n>& lhs, const typename rgb<n>::interop& rhs); + /// \} + + /// Subtraction. + /// \{ + template <unsigned n> + typename rgb<n>::interop operator-(const rgb<n>& lhs, const rgb<n>& rhs); - /// Multiplication. + template <unsigned n> + typename rgb<n>::interop + operator-(const typename rgb<n>::interop& lhs, const rgb<n>& rhs); + + template <unsigned n> + typename rgb<n>::interop + operator-(const rgb<n>& lhs, const typename rgb<n>::interop& rhs); + /// \} + + /// Product. + /// \{ template <unsigned n, typename S> inline - rgb<n> + typename rgb<n>::interop operator*(const rgb<n>& lhs, const mln::value::scalar_<S>& s); template <unsigned n, typename S> inline - rgb<n> - operator*(const rgb<n>& lhs, const mln::value::scalar_<S>& s); + typename rgb<n>::interop + operator*(const mln::value::scalar_<S>& s, const rgb<n>& lhs); + /// \} /// Division. + /// \{ template <unsigned n, typename S> inline - rgb<n> + typename rgb<n>::interop operator/(const rgb<n>& lhs, const mln::value::scalar_<S>& s); + /// \} # ifndef MLN_INCLUDE_ONLY + /*---------------. + | Construction. | + `---------------*/ + template <unsigned n> inline rgb<n>::rgb() @@ -349,59 +386,90 @@ template <unsigned n> const rgb<n> rgb<n>::zero(0,0,0); + /*------------. + | Operators. | + `------------*/ + + template <unsigned n> + inline + typename rgb<n>::interop + operator+(const rgb<n>& lhs, const rgb<n>& rhs) + { + typename rgb<n>::interop tmp(lhs.to_interop() + rhs.to_interop()); + return tmp; + } + template <unsigned n> inline - rgb<n> + typename rgb<n>::interop + operator+(const rgb<n>& lhs, const typename rgb<n>::interop& rhs) + { + typename rgb<n>::interop tmp(lhs.to_interop() + rhs); + return tmp; + } + + template <unsigned n> + inline + typename rgb<n>::interop + operator+(const typename rgb<n>::interop& lhs, const rgb<n>& rhs) + { + typename rgb<n>::interop tmp(lhs + rhs.to_interop()); + return tmp; + } + + template <unsigned n> + inline + typename rgb<n>::interop operator-(const rgb<n>& lhs, const rgb<n>& rhs) { - rgb<n> tmp(lhs.to_equiv() - rhs.to_equiv()); + typename rgb<n>::interop tmp(lhs.to_interop() - rhs.to_interop()); return tmp; } template <unsigned n> inline - rgb<n> - operator+(const rgb<n>& lhs, const rgb<n>& rhs) + typename rgb<n>::interop + operator-(const rgb<n>& lhs, const typename rgb<n>::interop& rhs) { - rgb<n> tmp(lhs.to_equiv() + rhs.to_equiv()); + typename rgb<n>::interop tmp(lhs.to_interop() - rhs); return tmp; } -// template <unsigned n> -// inline -// rgb<n> -// operator*(const rgb<n>& lhs, int i) -// { -// rgb<n> tmp(lhs.to_equiv() * i); -// return tmp; -// } + template <unsigned n> + inline + typename rgb<n>::interop + operator-(const typename rgb<n>::interop& lhs, const rgb<n>& rhs) + { + typename rgb<n>::interop tmp(lhs - rhs.to_interop()); + return tmp; + } template <unsigned n, typename S> inline - rgb<n> + typename rgb<n>::interop operator*(const rgb<n>& lhs, const mln::value::scalar_<S>& s) { - rgb<n> tmp(lhs.to_equiv() * s.to_equiv()); + typename rgb<n>::interop tmp(lhs.to_interop() * s.to_equiv()); return tmp; } template <unsigned n, typename S> inline - rgb<n> - operator/(const rgb<n>& lhs, const mln::value::scalar_<S>& s) + typename rgb<n>::interop + operator*(const mln::value::scalar_<S>& s, const rgb<n>& lhs) { - rgb<n> tmp(lhs.to_equiv() / s.to_equiv()); + typename rgb<n>::interop tmp(s.to_equiv() * lhs.to_interop()); return tmp; } -// template <unsigned n> -// inline -// rgb<n> -// operator/(const rgb<n>& lhs, int i) -// { -// rgb<n> tmp(lhs.to_equiv() / i); -// return tmp; -// } + template <unsigned n, typename S> + inline + typename rgb<n>::interop + operator/(const rgb<n>& lhs, const mln::value::scalar_<S>& s) + { + typename rgb<n>::interop tmp(lhs.to_interop() / s.to_equiv()); + return tmp; + } template <unsigned n> inline Index: tests/value/rgb8.cc --- tests/value/rgb8.cc (revision 1730) +++ tests/value/rgb8.cc (working copy) @@ -50,16 +50,28 @@ v.blue() = 2; rgb8 c(0, 1, 2); - // FIXME: Does not compile because we lack ops! - // mln_sum_(rgb8) sum; - // sum + c; - // c = c + c; + // Exercise some operators. + rgb8 c1(200,100,0); + rgb8 c2(100,200,50); + c1 + c2; + c1 - c2; + /* FIXME: Doesn't work. Calls an operator* triggering an overflow + error. We have to check where `interop' types should be used + instead of `equiv' types to avoid such a behavior. */ +// 3 * c1; +// c1 * 3; + c1 / 5; + + mln_sum_(rgb8) sum = literal::zero; + sum = sum + c; + c = c + c; std::cout << c << std::endl; std::cout << v << std::endl; + std::cout << sum << std::endl; mln_assertion(c == c); - mln_assertion(c == v); + mln_assertion(c == 2 * v); v.green() = 255; std::cout << v << std::endl;

16 years, 2 months

milena r1730: corrections for compilation

by Caroline Vigouroux

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2008-02-14 Caroline Vigouroux <vigour_c(a)epita.fr> corrections for compilation. * my_cmy.hh: . * rgb_to_cmy.hh: . * rgb_to_hsi.hh: . * tests.cc: . --- my_cmy.hh | 4 ++-- rgb_to_cmy.hh | 4 ++-- rgb_to_hsi.hh | 18 +++++++++--------- tests.cc | 6 ++++++ 4 files changed, 19 insertions(+), 13 deletions(-) Index: trunk/milena/sandbox/vigouroux/color/rgb_to_cmy.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/rgb_to_cmy.hh (revision 1729) +++ trunk/milena/sandbox/vigouroux/color/rgb_to_cmy.hh (revision 1730) @@ -16,7 +16,7 @@ struct value::cmy<8> doit(const struct value::rgb<8> rgb) const { - struct value::cmy cmy; + struct value::cmy<8> cmy; cmy.c(1 - rgb.red()); cmy.m(1 - rgb.green()); @@ -29,7 +29,7 @@ struct f_cmy_to_rgb { struct value::rgb<8> - doit(const struct value::cmy cmy) const + doit(const struct value::cmy<8> cmy) const { int red; int green; Index: trunk/milena/sandbox/vigouroux/color/tests.cc =================================================================== --- trunk/milena/sandbox/vigouroux/color/tests.cc (revision 1729) +++ trunk/milena/sandbox/vigouroux/color/tests.cc (revision 1730) @@ -9,6 +9,12 @@ #include "rgb_to_yuv.hh" #include "my_yuv.hh" +#include "rgb_to_cmy.hh" +#include "my_cmy.hh" + +#include "rgb_to_hsi.hh" +#include "my_hsi.hh" + int main() { using namespace mln; Index: trunk/milena/sandbox/vigouroux/color/my_cmy.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/my_cmy.hh (revision 1729) +++ trunk/milena/sandbox/vigouroux/color/my_cmy.hh (revision 1730) @@ -45,14 +45,14 @@ template <unsigned n> inline - yuv::cmy() + cmy<n>::cmy() :c_(0), m_(0), y_(0) { } template <unsigned n> inline - cmy::cmy(double c, double m, double y) + cmy<n>::cmy(double c, double m, double y) { mln_precondition(c >= 0); mln_precondition(m >= 0); Index: trunk/milena/sandbox/vigouroux/color/rgb_to_hsi.hh =================================================================== --- trunk/milena/sandbox/vigouroux/color/rgb_to_hsi.hh (revision 1729) +++ trunk/milena/sandbox/vigouroux/color/rgb_to_hsi.hh (revision 1730) @@ -12,14 +12,14 @@ namespace convert { struct f_rgb_to_hsi { - struct value::hsi + struct value::hsi<8> doit(const struct value::rgb<8> rgb) const { - struct value::hsi hsi; + struct value::hsi<8> hsi; - hsi.h(0.299 * rgb.red() + 0.587 * rgb.green() + 0.114 * rgb.blue()); - hsi.s(0.436 * (rgb.blue() - yuv.y()) / (1 - 0.114)); - hsi.i(0.615 * (rgb.red() - yuv.y()) / (1 - 0.299)); + hsi.h(0); // not yet implemented + hsi.s(0); // not yet implemented + hsi.i(0); // not yet implemented return (hsi); } @@ -28,13 +28,13 @@ struct f_hsi_to_rgb { struct value::rgb<8> - doit(const struct value::hsi hsi) const + doit(const struct value::hsi<8> hsi) const { struct value::rgb<8> rgb; - rgb.red() = yuv.y() + 1.13983 * yuv.v(); - rgb.green() = yuv.y() - 0.39465 * yuv.u() - 0.58060 * yuv.v(); - rgb.blue() = yuv.y() + 2.03211 * yuv.u(); + rgb.red() = 0; // not yet implemented + rgb.green() = 0; // not yet implemented + rgb.blue() = 0; // not yet implemented return (rgb); }

16 years, 2 months

1729: Exercise mln::line_graph_image more.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Exercise mln::line_graph_image more. * tests/core/line_graph_image.cc: Perform additional morphological tests (erosion and dilation on a line graph-based image). line_graph_image.cc | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) Index: tests/core/line_graph_image.cc --- tests/core/line_graph_image.cc (revision 1728) +++ tests/core/line_graph_image.cc (working copy) @@ -118,6 +118,23 @@ } std::cout << std::endl; + /*-------------------------. + | Processing graph images. | + `-------------------------*/ + + line_graph_image<point2d, int> ima_dil = morpho::dilation(ima, win); + // Manual iteration over the domain of IMA_DIL. + mln_piter_(ima_t) p_dil(ima_dil.domain()); + for_all (p_dil) + std::cout << "ima_dil (" << p_dil << ") = " << ima_dil(p_dil) << std::endl; + std::cout << std::endl; + + line_graph_image<point2d, int> ima_ero = morpho::erosion(ima, win); + // Manual iteration over the domain of IMA_ERO. + mln_piter_(ima_t) p_ero(ima_ero.domain()); + for_all (p_ero) + std::cout << "ima_ero (" << p_ero << ") = " << ima_ero(p_ero) << std::endl; + // /* FIXME: When implementing convert::to_line_graph_image, don't // forget to give a second argument defaulting to something like

16 years, 2 months

1728: Have Meyer's Watershed Transform work on line graph-based images.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena There's still a lot of work to do here (mainly clean up). But we should do that after we revamp the types associated to images (sites, etc.). Anyway, we now have a watershed transform working on images based on line graphs, and it's very cool! :) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Have Meyer's Watershed Transform work on line graph-based images. * mln/morpho/extrema_components.hh, * mln/morpho/level_components.hh: New. Ressurect and adjust those files from a revision 1700, since mln::labeling::regional_minima (needed by Meyer's WST) doesn't work (yet) on image which are not point-wise accessible. * mln/util/greater_psite.hh: New. Clone and modified from mln/util/greater_point.hh. * mln/morpho/meyer_wst.hh (morpho::meyer_wst): s/point/psite/. Use morpho::minima_components instead of level::regional_minima, since the latter doesn't work on non point-wise accessible images. * tests/core/line_graph_image_wst.cc: New test. * tests/core/Makefile.am (check_PROGRAMS): Add line_graph_image_wst. (line_graph_image_wst_SOURCES): New. mln/morpho/extrema_components.hh | 16 ++-- mln/morpho/level_components.hh | 18 +++- mln/morpho/meyer_wst.hh | 28 ++++--- mln/util/greater_psite.hh | 34 ++++---- tests/core/Makefile.am | 2 tests/core/line_graph_image_wst.cc | 141 +++++++++++++++++-------------------- 6 files changed, 126 insertions(+), 113 deletions(-) Index: mln/morpho/extrema_components.hh --- mln/morpho/extrema_components.hh (revision 1719) +++ mln/morpho/extrema_components.hh (working copy) @@ -75,7 +75,7 @@ template <typename DestValue, typename I, typename W> mln_ch_value(I, DestValue) minima_components(const Image& input, const Window<W>& win, - unsigned& nminima); + DestValue& nminima); /// \brief Like the 3-argument version of mln::moprho::minima_components, /// without the out argument \c nminima. @@ -108,7 +108,7 @@ template <typename DestValue, typename I, typename W> mln_ch_value(I, DestValue) maxima_components(const Image& input, const Window<W>& win, - unsigned& nmaxima); + DestValue& nmaxima); /// \brief Like the 3-argument version of mln::moprho::maxima_components, /// without the out argument \c nmaxima. @@ -126,7 +126,7 @@ template <typename DestValue, typename Cmp, typename I, typename W> mln_ch_value(I, DestValue) extrema_components(const Image& input_, const Window<W>& win_, - unsigned& nextrema) + DestValue& nextrema) { /* FIXME: Errors due to a too small DestValue type should be @@ -170,6 +170,7 @@ mln_qiter(W) q(win, p); for_all(q) + { if (input.has(q) and cmp(input(q), input(p))) { extrema.erase(comp); @@ -178,6 +179,7 @@ } } } + } // Update nextrema. nextrema = extrema.size(); @@ -212,7 +214,7 @@ template <typename DestValue, typename I, typename W> mln_ch_value(I, DestValue) minima_components(const Image& input, const Window<W>& win, - unsigned& nminima) + DestValue& nminima) { /* FIXME: Ensure the input image has scalar values. */ typedef std::less< mln_value(I) > cmp_t; @@ -224,7 +226,7 @@ minima_components(const Image& input, const Window<W>& win) { // Dummy value. - unsigned nminima; + DestValue nminima; return minima_components<DestValue>(input, win, nminima); } @@ -232,7 +234,7 @@ template <typename DestValue, typename I, typename W> mln_ch_value(I, DestValue) maxima_components(const Image& input, const Window<W>& win, - unsigned& nmaxima) + DestValue& nmaxima) { /* FIXME: Ensure the input image has scalar values. */ typedef std::greater< mln_value(I) > cmp_t; @@ -244,7 +246,7 @@ maxima_components(const Image& input, const Window<W>& win) { // Dummy value. - unsigned nmaxima; + DestValue nmaxima; return maxima_components<DestValue>(input, win, nmaxima); } Index: mln/morpho/level_components.hh --- mln/morpho/level_components.hh (revision 1719) +++ mln/morpho/level_components.hh (working copy) @@ -99,13 +99,23 @@ const W& win = exact(win_); mln_ch_value(I, DestValue) labels(input.domain()); - mln_ch_value(I, bool) processed(input.domain()); + /* FIXME: Yet another KLUDGE, this time required by the + specialization std::vector<bool>, which prevents forming + (mutable) reference to any of its elements. This creates + errors later with images using std::vector<bool> to store + their data (e.g., line_graph_image<P, V>). + + Alas, we cannot prevent the compiler to use this + specialization. Our workaround is simply... to use integers + instead of booleans. */ +// mln_ch_value(I, bool) processed(input.domain()); + mln_ch_value(I, int) processed(input.domain()); level::fill (processed, false); DestValue cur_label = mln_min(DestValue); - typedef mln_point(I) point_type; - std::queue<point_type> queue; + typedef mln_psite(I) psite_type; + std::queue<psite_type> queue; mln_piter(I) p(input.domain()); for_all(p) @@ -116,7 +126,7 @@ queue.push(p); while (!queue.empty()) { - point_type s = queue.front(); + psite_type s = queue.front(); queue.pop(); mln_qiter(W) q(win, s); for_all(q) Index: mln/util/greater_psite.hh --- mln/util/greater_psite.hh (revision 1719) +++ mln/util/greater_psite.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_UTIL_GREATER_POINT_HH -# define MLN_UTIL_GREATER_POINT_HH +#ifndef MLN_UTIL_GREATER_PSITE_HH +# define MLN_UTIL_GREATER_PSITE_HH # include <mln/core/concept/image.hh> @@ -35,55 +35,55 @@ namespace util { - /** \brief A ``greater than'' functor comparing points w.r.t. the + /** \brief A ``greater than'' functor comparing psites w.r.t. the values they refer to in an image. This functor used in useful to implement ordered queues of - points. */ + psites. */ template <typename I> - class greater_point + class greater_psite { public: - typedef mln_point(I) point; + typedef mln_psite(I) psite; - greater_point(const Image& ima); + greater_psite(const Image& ima); /// Is \a x greater than \a y? - bool operator()(const point& x, const point& y); + bool operator()(const psite& x, const psite& y); private: const I& ima_; }; - /// Helper to build a mln::util::greater_point. + /// Helper to build a mln::util::greater_psite. /* FIXME: To be moved into mln/make/? */ template <typename I> - greater_point - make_greater_point(const Image& ima); + greater_psite + make_greater_psite(const Image& ima); # ifndef MLN_INCLUDE_ONLY template <typename I> - greater_point::greater_point(const Image& ima) + greater_psite::greater_psite(const Image& ima) : ima_ (exact(ima)) { } template <typename I> bool - greater_point::operator()(const mln_point(I)& x, const mln_point(I)& y) + greater_psite::operator()(const mln_psite(I)& x, const mln_psite(I)& y) { return ima_(x) > ima_(y); } template <typename I> - greater_point - make_greater_point(const Image& ima) + greater_psite + make_greater_psite(const Image& ima) { - return greater_point(ima); + return greater_psite(ima); } # endif // ! MLN_INCLUDE_ONLY @@ -92,4 +92,4 @@ } // end of namespace mln -#endif // ! MLN_UTIL_GREATER_POINT_HH +#endif // ! MLN_UTIL_GREATER_PSITE_HH Index: mln/morpho/meyer_wst.hh --- mln/morpho/meyer_wst.hh (revision 1727) +++ mln/morpho/meyer_wst.hh (working copy) @@ -43,9 +43,11 @@ # include <mln/trait/ch_value.hh> -# include <mln/util/greater_point.hh> +# include <mln/util/greater_psite.hh> # include <mln/morpho/includes.hh> -# include <mln/labeling/regional_minima.hh> +// FIXME: See below. +// # include <mln/labeling/regional_minima.hh> +# include <mln/morpho/extrema_components.hh> @@ -112,15 +114,23 @@ const marker unmarked = mln_min(marker); // Initialize the output with the markers (minima components). + /* FIXME: labeling::regional_minima doesn't work on non + point-accessible images! We temporarily reuse the old + morpho::minima_components routine to work-around this + limitation. As soon as labeling::regional_minima work, get rid of + - mln/morpho/level_components.hh, and + - mln/morpho/extrema_components.hh. */ +// mln_ch_value(I, marker) markers = +// labeling::regional_minima (input, nbh, nbasins); mln_ch_value(I, marker) markers = - labeling::regional_minima (input, nbh, nbasins); + minima_components(input, convert::to_window(nbh), nbasins); // Ordered queue. - typedef mln_point(I) point; + typedef mln_psite(I) psite; typedef - std::priority_queue< point, std::vector<point>, util::greater_point > + std::priority_queue< psite, std::vector<psite>, util::greater_psite > ordered_queue_type; - ordered_queue_type queue(util::make_greater_point(input)); + ordered_queue_type queue(util::make_greater_psite(input)); // Insert every neighbor P of every marked area in a // hierarchical queue, with a priority level corresponding to @@ -136,12 +146,12 @@ break; } - /* Until the queue is empty, extract a point P from the + /* Until the queue is empty, extract a psite P from the hierarchical queue, at the highest priority level, that is, the lowest level. */ while (!queue.empty()) { - point p = queue.top(); + psite p = queue.top(); queue.pop(); // Last seen marker adjacent to P. marker adjacent_marker = unmarked; @@ -161,7 +171,7 @@ single_adjacent_marker_p = false; break; } - /* If the neighborhood of P contains only points with the + /* If the neighborhood of P contains only psites with the same label, then P is marked with this label, and its neighbors that are not yet marked are put into the hierarchical queue. */ Index: tests/core/line_graph_image_wst.cc --- tests/core/line_graph_image_wst.cc (revision 1719) +++ tests/core/line_graph_image_wst.cc (working copy) @@ -25,17 +25,17 @@ // reasons why the executable file might be covered by the GNU General // Public License. -/// \file tests/core/graph_image.cc -/// \brief Tests on mln::graph_image. +/// \file tests/core/line_graph_image.cc +/// \brief Tests on the Watershed Transform on a mln::line_graph_image. #include <vector> #include <mln/core/point2d.hh> #include <mln/core/line_graph_image.hh> -#include <mln/core/line_graph_elt_window.hh> -#include <mln/core/line_graph_window_piter.hh> +#include <mln/core/line_graph_elt_neighborhood.hh> +#include <mln/core/line_graph_neighborhood_piter.hh> -#include <mln/morpho/dilation.hh> +#include <mln/morpho/meyer_wst.hh> #include <mln/draw/graph.hh> #include <mln/debug/iota.hh> @@ -46,48 +46,58 @@ { using namespace mln; - /*--------. - | Graph. | - `--------*/ - - // Points associated to nodes. - std::vector<point2d> points; - points.push_back(make::point2d(0,0)); // Point associated to node 0. - points.push_back(make::point2d(2,2)); // Point associated to node 1. - points.push_back(make::point2d(0,4)); // Point associated to node 2. - points.push_back(make::point2d(4,3)); // Point associated to node 3. - points.push_back(make::point2d(4,4)); // Point associated to node 4. + /*-------------. + | Line graph. | + `-------------*/ + + /* Actually this graph is from Jean Cousty's PhD dissertation, page 76. + + 0 1 2 3 (rows) + ,------------------------ + | 0 10 5 + 0 | o-----o-----o-----o + | | | | | + | 2| 4| 6| 0| + | | | | | + 1 | o-----o-----o-----o + 3 5 2 + (cols) - // Edges. + In G, nodes and egdes are numbered following in the classical + foward order. */ util::graph<point2d> g; - // Populate the graph with nodes. - for (unsigned i = 0; i < points.size(); ++i) - g.add_node (points[i]); - // Populate the graph with edges. - g.add_edge(0, 1); - g.add_edge(1, 2); - g.add_edge(1, 3); - g.add_edge(3, 4); - g.add_edge(4, 2); - - /*-------. - | Graph. | - `-------*/ - p_line_graph<point2d> plg(g); + // Nodes. + std::vector<int> node_values; + // We don't really care about values on nodes, because the algorithm + // won't see them. So all are set to 0. + g.add_node (make::point2d(0, 0)); node_values.push_back (0); // Node 0. + g.add_node (make::point2d(0, 1)); node_values.push_back (0); // Node 1. + g.add_node (make::point2d(0, 2)); node_values.push_back (0); // Node 2. + g.add_node (make::point2d(0, 3)); node_values.push_back (0); // Node 3. + + g.add_node (make::point2d(1, 0)); node_values.push_back (0); // Node 4. + g.add_node (make::point2d(1, 1)); node_values.push_back (0); // Node 5. + g.add_node (make::point2d(1, 2)); node_values.push_back (0); // Node 6. + g.add_node (make::point2d(1, 3)); node_values.push_back (0); // Node 7. - /*-------------------. - | Line graph image. | - `-------------------*/ - - // Values ("empty" vectors). - std::vector<int> node_values(5); - std::vector<int> edge_values(5); - // FIXME: hand-made iota's. - for (unsigned i = 0; i < node_values.size(); ++i) - node_values[i] = i; - for (unsigned i = 0; i < edge_values.size(); ++i) - edge_values[i] = i; + // Edges. + std::vector<int> edge_values; + g.add_edge (0, 1); edge_values.push_back (0); + g.add_edge (1, 2); edge_values.push_back (10); + g.add_edge (2, 3); edge_values.push_back (5); + + g.add_edge (0, 4); edge_values.push_back (2); + g.add_edge (1, 5); edge_values.push_back (4); + g.add_edge (2, 6); edge_values.push_back (6); + g.add_edge (3, 7); edge_values.push_back (0); + + g.add_edge (4, 5); edge_values.push_back (3); + g.add_edge (5, 6); edge_values.push_back (5); + g.add_edge (6, 7); edge_values.push_back (2); + + // Line graph point set. + p_line_graph<point2d> plg(g); // Line graph image. /* FIXME: We probably don't want to build line_graph_images by hand; @@ -103,40 +113,19 @@ mln_piter_(ima_t) p(ima.domain()); for_all (p) std::cout << "ima (" < win_t; - win_t win; - mln_qiter_(win_t) q(win, p); - for_all (p) - { - std::cout << "neighbors of " << p << " (" << ima(p) << "), " - << "including the site itself:" << std::endl; - for_all (q) - std::cout << " " << q << " (level = " << ima(q) << ")" - << std::endl; - } std::cout << std::endl; + typedef line_graph_elt_neighborhood<point2d> nbh_t; + nbh_t nbh; -// /* FIXME: When implementing convert::to_line_graph_image, don't -// forget to give a second argument defaulting to something like -// fun::vv2v::max(). This second argument is a functor used to -// compute the values of the edges of the line graph image. */ -// image2d ima; // = ... -// lg_ima_t lg_ima = convert::to_line_graph_image (ima); - -// // Image2d representation. -// image2d<value_t> out = convert::to_image2d (lg_ima); -// io::pgm::save(out, "out.pgm"); - -// /* FIXME: Then, add some real processing on the line graph image -// before converting to an image2d: -// - erosion/dilation, -// - Beucher's gradient, -// - Meyer's WST (on the gradient of LG_IMA?), -// - attribute filters (see my notes on Laurent's remarks about -// attributes), -// - etc. -// Creating seperate tests for all these would be wise. */ + typedef unsigned wst_val_t; + wst_val_t nbasins; + typedef line_graph_image<point2d, wst_val_t> wst_ima_t; + wst_ima_t wshed = morpho::meyer_wst(ima, nbh, nbasins); + std::cout << "nbasins = " << nbasins << std::endl; + + // Manual iteration over the domain of WSHED. + mln_piter_(wst_ima_t) pw(wshed.domain()); + for_all (pw) + std::cout << "wshed (" << pw << ") = " << wshed(pw) << std::endl; } Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 1727) +++ tests/core/Makefile.am (working copy) @@ -12,6 +12,7 @@ graph_image \ line_graph_elt_window \ line_graph_image \ + line_graph_image_wst \ mono_obased_rle_image \ mono_rle_image \ obased_rle_image \ @@ -35,6 +36,7 @@ graph_image_SOURCES = graph_image.cc line_graph_elt_window_SOURCES = line_graph_elt_window.cc line_graph_image_SOURCES = line_graph_image.cc +line_graph_image_wst_SOURCES = line_graph_image_wst.cc mono_obased_rle_image_SOURCES = mono_obased_rle_image.cc mono_rle_image_SOURCES = mono_rle_image.cc obased_rle_image_SOURCES = obased_rle_image.cc

16 years, 2 months

1727: Improve the construction of graph-based images.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Improve the construction of graph-based images. * mln/core/graph_image.hh (internal::data_< graph_image<P,V> >::pg_): Make it const. (internal::data_< graph_image<P,V> >::data_): Adjust ctor. (graph_image<P,V>::data_values): Rename as... (graph_image<P,V>::node_values): ...this. (graph_image<P,V>::graph_image(const p_graph&, const std::vector<V>&) (graph_image<P,V>::init_(const p_graph&, const std::vector<V>&): Adjust. (graph_image<P,V>::graph_image(const p_graph&)): New ctor. * mln/draw/graph.hh (draw::graph(Image&, const graph_image<P,V>&, mln_value(I))): Adjust. * mln/core/line_graph_image.hh (internal::data_< line_graph_image<P,V> >::pg_): Make it const. (internal::data_< line_graph_image<P,V> >::data_): Adjust ctor. (line_graph_image<P,V>::data_values): Rename as... (line_graph_image<P,V>::node_values): ...this. (line_graph_image<P,V>::edge_values): New accessor. (line_graph_image(const p_graph&, const std::vector<V>&) (init_(const p_graph&, const std::vector<V>&): Adjust. (line_graph_image(const p_graph&)): New ctor. core/graph_image.hh | 61 ++++++++++++++++++------------- core/line_graph_image.hh | 92 +++++++++++++++++++++++++++++------------------ draw/graph.hh | 2 - 3 files changed, 95 insertions(+), 60 deletions(-) Index: mln/core/graph_image.hh --- mln/core/graph_image.hh (revision 1726) +++ mln/core/graph_image.hh (working copy) @@ -53,10 +53,15 @@ template <typename P, typename V> struct data_< graph_image<P, V> > { - data_(p_graph& g, std::vector<V>& val); + data_(const p_graph& g, const std::vector<V>& val); std::vector<V> val_; - p_graph& pg_; + /* The graph point set is handled by address, so that we can + check the compatibility of images w.r.t. to their point + sites. We could use a safer (and more complex) facility to + ensure (memory) equality of line graph point sets, but using + addresses is simple and efficient enough for the moment. */ + const p_graph& pg_; }; } // end of namespace mln::internal @@ -112,11 +117,14 @@ typedef graph_image< tag::psite_, tag::value_<V> > skeleton; /// Constructors. - graph_image(p_graph& g, std::vector<V>& val); + /// \{ graph_image(); + graph_image(const p_graph& g); + graph_image(const p_graph& g, const std::vector<V>& val); + /// \} /// Initialize an empty image. - void init_(p_graph& g, std::vector<V>& val); + void init_(const p_graph& g, const std::vector<V>& val); /// Read-only access of pixel value at point site \p p. const V& operator()(const graph_psite& p) const; @@ -124,13 +132,19 @@ /// Read-write access of pixel value at point site \p p. V& operator()(const graph_psite& p); - /// Give the set of values of the image. + /// Accessors. + /// \{ + /// Return the domain of psites od the image. + const p_graph& domain() const; + /// Return the domain of values of the image. const vset& values() const; - // FIXME: Keep this name? - const std::vector<V>& data_values () const; + /// Return the array of values associated to the nodes. + const std::vector<V>& node_values() const; + /// \} - const p_graph& domain() const; + /* FIXME: Do we want to provide these two methods? (at least, in + the interface of the class? */ /// Return the point of the first node adjacent to the edge with /// id \a e. @@ -157,16 +171,7 @@ void init_(tag::image_t, graph_image<P, V>& target, const graph_image<P, V>& model) { - /* FIXME: Unfortunately, we cannot simply use - - target.init_(model.domain(), model.data_values ()); - - here, since domain() and data_values() return const data, and - init_ expects non mutable data. These constness problems exist - also in graph_psite (see uses of const_cast<>). Hence the - inelegant use of const_cast<>'s. */ - target.init_(const_cast<p_graph&> (model.domain()), - const_cast<std::vector<V>&> (model.data_values ())); + target.init_(model.domain(), model.node_values ()); } /*-------. @@ -177,7 +182,8 @@ { template <typename P, typename V> inline - data_< graph_image<P, V> >::data_(p_graph& g, std::vector<V>& val) + data_< graph_image<P, V> >::data_(const p_graph& g, + const std::vector<V>& val) : val_ (val), pg_ (g) { @@ -191,21 +197,28 @@ template <typename P, typename V> inline - graph_image<P, V>::graph_image(p_graph& g, std::vector<V>& val) + graph_image<P, V>::graph_image() { - init_(g, val); } template <typename P, typename V> inline - graph_image<P, V>::graph_image() + graph_image<P, V>::graph_image(const p_graph& g) { + init_(g, std::vector<V>(g.npoints())); + } + + template <typename P, typename V> + inline + graph_image<P, V>::graph_image(const p_graph& g, const std::vector<V>& val) + { + init_(g, val); } template <typename P, typename V> inline void - graph_image<P, V>::init_(p_graph& g, std::vector<V>& val) + graph_image<P, V>::init_(const p_graph& g, const std::vector<V>& val) { /* FIXME: We leak memory here: calling init_ twice loses the previous content pointed by data_. @@ -250,7 +263,7 @@ template <typename P, typename V> inline const std::vector<V>& - graph_image<P, V>::data_values () const + graph_image<P, V>::node_values() const { return this->data_->val_; } Index: mln/draw/graph.hh --- mln/draw/graph.hh (revision 1726) +++ mln/draw/graph.hh (working copy) @@ -120,7 +120,7 @@ line (exact(ima), gi.node1(l), gi.node2(l), link_v); // Draw the points (nodes). for (size_t p = 0; p < gi.domain().npoints(); ++p) - exact(ima)(gi.domain().gr_.node_data(p)) = gi.data_values()[p]; + exact(ima)(gi.domain().gr_.node_data(p)) = gi.node_values()[p]; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/line_graph_image.hh --- mln/core/line_graph_image.hh (revision 1726) +++ mln/core/line_graph_image.hh (working copy) @@ -67,12 +67,17 @@ template <typename P, typename V> struct data_< line_graph_image<P, V> > { - data_(p_line_graph& g, - std::vector<V>& node_val, std::vector<V>& edge_val); + data_(const p_line_graph& g, + const std::vector<V>& node_val, const std::vector<V>& edge_val); std::vector<V> node_val_; std::vector<V> edge_val_; - p_line_graph& plg_; + /* The line graph point set is handled by address, so that we + can check the compatibility of images w.r.t. to their point + sites. We could use a safer (and more complex) facility to + ensure (memory) equality of line graph point sets, but using + addresses is simple and efficient enough for the moment. */ + const p_line_graph& plg_; }; } // end of namespace mln::internal @@ -130,13 +135,18 @@ typedef line_graph_image< tag::psite_, tag::value_<V> > skeleton; /// Constructors. - line_graph_image(p_line_graph& g, - std::vector<V>& node_val, std::vector<V>& edge_val); + /// \{ line_graph_image(); + line_graph_image(const p_line_graph& g); + line_graph_image(const p_line_graph& g, + const std::vector<V>& node_val, + const std::vector<V>& edge_val); + /// \} /// Initialize an empty image. - void init_(p_line_graph& g, - std::vector<V>& node_val, std::vector<V>& edge_val); + void init_(const p_line_graph& g, + const std::vector<V>& node_val, + const std::vector<V>& edge_val); /// Read-only access of pixel value at point site \p p. const V& operator()(const line_graph_psite& p) const; @@ -144,15 +154,21 @@ /// Read-write access of pixel value at point site \p p. V& operator()(const line_graph_psite& p); - /// Give the set of values of the image. + /// Accessors. + /// \{ + /// Return the domain of psites od the image. + const p_line_graph& domain() const; + /// Return the domain of values of the image. const vset& values() const; - // FIXME: Keep this name? - const std::vector<V>& data_values() const; - - const p_line_graph& domain() const; + /// Return the array of values associated to the edges. + const std::vector<V>& edge_values() const; + /// Return the array of values associated to the nodes. + const std::vector<V>& node_values() const; + /// \} - // FIXME: Do we want to provide these two methods? + /* FIXME: Do we want to provide these two methods? (at least, in + the interface of the class? */ /// Return the point of the first node adjacent to the edge with /// id \a e. @@ -181,16 +197,7 @@ line_graph_image<P, V>& target, const line_graph_image<P, V>& model) { - /* FIXME: Unfortunately, we cannot simply use - - target.init_(model.domain(), model.data_values()); - - here, since domain() and data_values() return const data, and - init_ expects non mutable data. These constness problems exist - also in line_graph_psite (see uses of const_cast<>). Hence the - inelegant use of const_cast<>'s. */ - target.init_(const_cast<p_line_graph&>(model.domain()), - const_cast<std::vector<V>&>(model.data_values())); + target.init_(model.domain(), model.node_values(), model.edge_values()); } /*-------. @@ -201,9 +208,9 @@ { template <typename P, typename V> inline - data_< line_graph_image<P, V> >::data_(p_line_graph& g, - std::vector<V>& node_val, - std::vector<V>& edge_val) + data_< line_graph_image<P, V> >::data_(const p_line_graph& g, + const std::vector<V>& node_val, + const std::vector<V>& edge_val) : node_val_(node_val), edge_val_(edge_val), plg_(g) @@ -218,25 +225,32 @@ template <typename P, typename V> inline - line_graph_image<P, V>::line_graph_image(p_line_graph& g, - std::vector<V>& node_val, - std::vector<V>& edge_val) + line_graph_image<P, V>::line_graph_image() { - init_(g, node_val, edge_val); } template <typename P, typename V> inline - line_graph_image<P, V>::line_graph_image() + line_graph_image<P, V>::line_graph_image(const p_line_graph& g) + { + init_(g, std::vector<V>(g.npoints()), std::vector<V>(g.nlines())); + } + + template <typename P, typename V> + inline + line_graph_image<P, V>::line_graph_image(const p_line_graph& g, + const std::vector<V>& node_val, + const std::vector<V>& edge_val) { + init_(g, node_val, edge_val); } template <typename P, typename V> inline void - line_graph_image<P, V>::init_(p_line_graph& g, - std::vector<V>& node_val, - std::vector<V>& edge_val) + line_graph_image<P, V>::init_(const p_line_graph& g, + const std::vector<V>& node_val, + const std::vector<V>& edge_val) { /* FIXME: We leak memory here: calling init_ twice loses the previous content pointed by data_. @@ -282,13 +296,21 @@ template <typename P, typename V> inline const std::vector<V>& - line_graph_image<P, V>::data_values() const + line_graph_image<P, V>::edge_values() const { return this->data_->edge_val_; } template <typename P, typename V> inline + const std::vector<V>& + line_graph_image<P, V>::node_values() const + { + return this->data_->node_val_; + } + + template <typename P, typename V> + inline const p_line_graph& line_graph_image<P, V>::domain() const {

16 years, 2 months

1726: Improve the robustness of psites on graphs.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Improve the robustness of psites on graphs. * mln/core/graph_psite.hh, mln/core/line_graph_psite.hh (to_psite): New method. (operator=): Don't copy the point set from the argument. Instead, ensure that that point set in compatible with the point set of the psite. graph_psite.hh | 19 ++++++++++++++++--- line_graph_psite.hh | 19 ++++++++++++++++--- 2 files changed, 32 insertions(+), 6 deletions(-) Index: mln/core/graph_psite.hh --- mln/core/graph_psite.hh (revision 1725) +++ mln/core/graph_psite.hh (working copy) @@ -58,10 +58,14 @@ /// \{ graph_psite(const p_graph& pg_, unsigned id); graph_psite(const self_& rhs); + /// \pre This psite must have the same graph point set as \a rhs. self_& operator= (const self_& rhs); /// \} - /// Access to point/psite. + /// Access to psite. + const self_& to_psite() const; + + /// Access to point. /// \{ operator P() const; const point& to_point() const; @@ -107,14 +111,23 @@ { if (&rhs == this) return *this; - // FIXME: Could we get rid of this cast? - const_cast< p_graph& >(pg_) = rhs.pg_; + // Assigning a psite from a graph point set to a psite from + // another graph point set is meaningless. + mln_assertion(&pg_ == &rhs.pg_); id_ = rhs.id_; return *this; } template<typename P> inline + const graph_psite& + graph_psite::to_psite() const + { + return *this; + } + + template<typename P> + inline graph_psite::operator P() const { return pg_.gr_.node_data(id_); Index: mln/core/line_graph_psite.hh --- mln/core/line_graph_psite.hh (revision 1725) +++ mln/core/line_graph_psite.hh (working copy) @@ -62,10 +62,14 @@ /// \{ line_graph_psite(const p_line_graph& plg_, unsigned id); line_graph_psite(const self_& rhs); + /// \pre This psite must have the same graph point set as \a rhs. self_& operator= (const self_& rhs); /// \} - /// Access to point/psite. + /// Access to psite. + const self_& to_psite() const; + + /// Access to point. /// \{ operator point() const; const point& to_point() const; @@ -142,8 +146,9 @@ { if (&rhs == this) return *this; - // FIXME: Could we get rid of this cast? - const_cast< p_line_graph& >(plg_) = rhs.plg_; + // Assigning a psite from a line graph point set to a psite from + // another line graph point set is meaningless. + mln_assertion(&plg_ == &rhs.plg_); id_ = rhs.id_; update_(); return *this; @@ -167,6 +172,14 @@ template<typename P> inline + const line_graph_psite& + line_graph_psite::to_psite() const + { + return *this; + } + + template<typename P> + inline const point_pair& line_graph_psite::to_point() const {

16 years, 2 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches February 2008