Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add pset and pvec point sets. * tests/sort_points.cc: New. * tests/pset.cc: New. * tests/histo.cc: Update. * mln/histo/sort.hh: Rename as... * mln/level/sort_points.hh: ...this new file. (sort_points): New overload. * mln/histo/data.hh (vec): Rename as... (vect): ...this. * mln/core/dpoints_piter.hh: Update. * mln/core/pvec.hh: New. * mln/core/pset.hh: New. * mln/core/internal/set_of.hh: Update. * mln/accu/histo.hh: Update. * mln/accu/bbox.hh: New. mln/accu/bbox.hh | 134 ++++++++++++++++++ mln/accu/histo.hh | 4 mln/core/dpoints_piter.hh | 2 mln/core/internal/set_of.hh | 6 mln/core/pset.hh | 162 ++++++++++++++++++++++ mln/core/pvec.hh | 323 ++++++++++++++++++++++++++++++++++++++++++++ mln/histo/data.hh | 4 mln/level/sort_points.hh | 158 +++++++++++++++++++++ tests/histo.cc | 6 tests/pset.cc | 59 ++++++++ tests/sort_points.cc | 56 +++++++ 11 files changed, 901 insertions(+), 13 deletions(-) Index: tests/sort_points.cc --- tests/sort_points.cc (revision 0) +++ tests/sort_points.cc (revision 0) @@ -0,0 +1,56 @@ +// 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/histo.cc + * + * \brief Tests on mln::accu::histo<S> and mln::histo::data<S>. + */ + +#include <iterator> + +#include <mln/core/image2d_b.hh> +#include <mln/value/int_u8.hh> + +#include <mln/debug/iota.hh> +#include <mln/level/sort_points.hh> + + + +int main() +{ + using namespace mln; + using value::int_u8; + + 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; + +} Index: tests/pset.cc --- tests/pset.cc (revision 0) +++ tests/pset.cc (revision 0) @@ -0,0 +1,59 @@ +// 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/pset.cc + * + * \brief Tests on mln::pset. + */ + +#include <iterator> + +#include <mln/core/point2d.hh> +#include <mln/core/pset.hh> + + + +int main() +{ + using namespace mln; + + pset<point2d> ps; + ps + .insert(make::point2d(6, 9)) + .insert(make::point2d(4, 2)) + .insert(make::point2d(4, 2)) + .insert(make::point2d(5, 1)); + mln_assertion(ps.npoints() = 3); + + std::cout << ps.bbox() << std::endl; + + std::copy(ps.vect().begin(), ps.vect().end(), + std::ostream_iterator<point2d>(std::cout, " ")); + std::cout << std::endl; + + +} Index: tests/histo.cc --- tests/histo.cc (revision 1037) +++ tests/histo.cc (working copy) @@ -38,7 +38,6 @@ #include <mln/debug/iota.hh> #include <mln/accu/histo.hh> #include <mln/histo/compute.hh> -#include <mln/histo/sort.hh> @@ -65,11 +64,6 @@ debug::iota(ima); histo::data< value::set<int_u8> > h = histo::compute(ima); std::cout << h << std::endl; - - std::vector<point2d> vec = histo::sort_points_decreasing(ima); - std::copy(vec.begin(), vec.end(), - std::ostream_iterator<point2d>(std::cout, " ")); - std::cout << std::endl; } } Index: mln/histo/data.hh --- mln/histo/data.hh (revision 1037) +++ mln/histo/data.hh (working copy) @@ -60,7 +60,7 @@ std::size_t operator()(const value& v) const; std::size_t& operator()(const value& v); - const std::vector<std::size_t>& vec() const; + const std::vector<std::size_t>& vect() const; const S& vset() const; std::size_t operator[](unsigned i) const; @@ -124,7 +124,7 @@ template <typename S> const std::vector<std::size_t>& - data<S>::vec() const + data<S>::vect() const { return h_; } Index: mln/core/dpoints_piter.hh --- mln/core/dpoints_piter.hh (revision 1037) +++ mln/core/dpoints_piter.hh (working copy) @@ -118,7 +118,7 @@ template <typename Dps, typename Pref> dpoints_fwd_piter<D>::dpoints_fwd_piter(const Dps& dps, const Generalized_Point<Pref>& p_ref) - : dps_(exact(dps).vec()), + : dps_(exact(dps).vect()), p_ref_(* internal::force_exact<Pref>(p_ref).pointer_()) { invalidate(); Index: mln/core/pvec.hh --- mln/core/pvec.hh (revision 0) +++ mln/core/pvec.hh (revision 0) @@ -0,0 +1,323 @@ +// 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_CORE_PVEC_HH +# define MLN_CORE_PVEC_HH + +/*! \file mln/core/pvec.hh + * + * \brief Definition of a point set class based on std::vector. + */ + +# include <vector> + +# include <mln/core/concept/point_set.hh> +# include <mln/core/internal/fixme.hh> +# include <mln/accu/bbox.hh> + + +namespace mln +{ + + // Fwd decls. + template <typename P> struct pvec_fwd_piter_; + template <typename P> struct pvec_bkd_piter_; + + + /*! \brief Point set class based on std::vector. + * + * This is a multi-set of points. + * + * \warning We have some troubles with point set comparison based on + * a call to npoints(). FIXME: Explain! + */ + template <typename P> + class pvec : public Point_Set< pvec > + { + public: + + /// Point associated type. + typedef mln_point(P) point; + + /// Point_Site associated type. + typedef P psite; + + /// Forward Point_Iterator associated type. + typedef pvec_fwd_piter_ fwd_piter; + + /// Backward Point_Iterator associated type. + typedef internal::fixme bkd_piter; + + /// Constructor. + pvec(); + + /// Constructor from a vector \p vect. + pvec(const std::vector& vect); + + /// Test is \p p belongs to this point set. + bool has(const P& p) const; + + /// Give the number of points. + std::size_t npoints() const; + + /// Give the exact bounding box. + const box_<point>& bbox() const; + + /// Append a point \p p. + pvec& append(const P& p); + + /// Clear this set. + void clear(); + + /// Return the corresponding std::vector of points. + const std::vector& vect() const; + + /// Return the \p i-th point. + const P& operator[](unsigned i) const; + + protected: + + std::vector vect_; + mutable accu::bbox bb_; + mutable bool bb_needs_update_; + + void update_bb_(); + // FIXME: Add invariant bb_.is_valid() <=> npoints() != 0 + }; + + + + /*! \brief Forward iterator on points of a pvec. + * + */ + template <typename P> + struct pvec_fwd_piter_ + { + enum { dim = P::dim }; + + /// Point_Site associated type. + typedef P psite; + + /// Point associated type. + typedef mln_point(P) point; + + /// Dpoint associated type. + typedef mln_dpoint(P) dpoint; + + /// Coordinate associated type. + typedef mln_coord(P) coord; + + /// Coordinate associated type. + template <typename S> + pvec_fwd_piter_(const Point_Set<S>& s); + + /// Give a hook to the point address. + const point* 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_; + point p_; + }; + + + + +# ifndef MLN_INCLUDE_ONLY + + + // pvec + + + template <typename P> + pvec::pvec() + { + bb_needs_update_ = false; + } + + template <typename P> + pvec::pvec(const std::vector& vect) + : vect_(vect) + { + bb_needs_update_ = true; + } + + template <typename P> + void + pvec::update_bb_() + { + bb_.clear(); + for (unsigned i = 0; i < vect_.size(); ++i) + bb_.take(vect_[i]); + bb_needs_update_ = false; + } + + template <typename P> + bool + pvec::has(const P& p) const + { + for (unsigned i = 0; i < vect_.size(); ++i) + if (vect_[i] = p) + return true; + return false; + } + + template <typename P> + std::size_t + pvec::npoints() const + { + return vect_.size(); + } + + template <typename P> + const box_<mln_point(P)>& + pvec::bbox() const + { + mln_precondition(npoints() != 0); + if (bb_needs_update_) + update_bb_(); + return bb_.to_value(); + } + + template <typename P> + pvec& + pvec::append(const P& p) + { + vect_.push_back(p); + return *this; + } + + template <typename P> + void + pvec::clear() + { + vect_.clear(); + bb_needs_update_ = false; + } + + template <typename P> + const std::vector& + pvec::vect() const + { + return vect_; + } + + template <typename P> + const P& + pvec::operator[](unsigned i) const + { + mln_precondition(i < npoints()); + return vect_[i]; + } + + + + // pvec_fwd_piter_ + + + template <typename P> + template <typename S> + pvec_fwd_piter_::pvec_fwd_piter_(const Point_Set<S>& s) + : vect_(exact(s).vect()) + { + invalidate(); + } + + template <typename P> + const mln_point(P)* + pvec_fwd_piter_::pointer_() const + { + return & p_; + } + + template <typename P> + mln_coord(P) + pvec_fwd_piter_::operator[](unsigned i) const + { + mln_precondition(i < dim); + mln_precondition(is_valid()); + return p_[i]; + } + + template <typename P> + bool + pvec_fwd_piter_::is_valid() const + { + return i < vect_.size(); + } + + template <typename P> + void + pvec_fwd_piter_::invalidate() + { + i = vect_.size(); + } + + template <typename P> + void + pvec_fwd_piter_::start() + { + i = 0; + } + + template <typename P> + void + pvec_fwd_piter_::next_() + { + ++i; + } + + template <typename P> + pvec_fwd_piter_::operator P() const + { + mln_precondition(is_valid()); + return p_; + } + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + + +#endif // ! MLN_CORE_PVEC_HH Index: mln/core/pset.hh --- mln/core/pset.hh (revision 0) +++ mln/core/pset.hh (revision 0) @@ -0,0 +1,162 @@ +// 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_CORE_PSET_HH +# define MLN_CORE_PSET_HH + +/*! \file mln/core/pset.hh + * + * \brief Definition of a point set class based on std::set. + */ + +# include <mln/core/concept/point_set.hh> +# include <mln/core/internal/set_of.hh> +# include <mln/accu/bbox.hh> +# include <mln/core/pvec.hh> + + +namespace mln +{ + + /*! \brief Point set class based on std::set. + * + * This is a mathematical set of points (not a multi-set). The + * parameter \p P shall be a Point type. + * + * \todo Test if \p P being a Point_Site is ok. + */ + template <typename P> + class pset : public Point_Set< pset >, + private internal::set_of_ + { + typedef internal::set_of_ super_; + + public: + + /// Point associated type. + typedef mln_point(P) point; + + /// Point_Site associated type. + typedef P psite; + + /// Forward Point_Iterator associated type. + typedef pvec_fwd_piter_ fwd_piter; + + /// Backward Point_Iterator associated type. + typedef internal::fixme bkd_piter; + + /// Constructor. + pset(); + + /// Test is \p p belongs to this point set. + bool has(const P& p) const; + + /// Return the corresponding std::vector of points. + using super_::vect; + + /// Give the number of points. + std::size_t npoints() const; + + /// Insert a point \p p. + pset& insert(const P& p); + + /// Return the \p i-th point. + const P& operator[](unsigned i) const; + + /// Clear this set. + void clear(); + + /// Give the exact bounding box. + const box_<point>& bbox() const; + + protected: + + accu::bbox bb_; + // FIXME: Add invariant bb_.is_valid() <=> npoints() != 0 + }; + + +# ifndef MLN_INCLUDE_ONLY + + template <typename P> + pset::pset() + { + } + + template <typename P> + bool + pset::has(const P& p) const + { + return this->super_::has(p); + } + + template <typename P> + std::size_t + pset::npoints() const + { + return this->super_::nelements(); + } + + template <typename P> + pset& + pset::insert(const P& p) + { + this->super_::insert(p); + bb_.take(p); + return *this; + } + + template <typename P> + const P& + pset::operator[](unsigned i) const + { + mln_precondition(i < npoints()); + return this->super_::element(i); + } + + template <typename P> + void + pset::clear() + { + this->super_::clear(); + bb_.init(); + } + + template <typename P> + const box_<mln_point(P)>& + pset::bbox() const + { + mln_precondition(npoints() != 0); + return bb_.to_value(); + } + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + + +#endif // ! MLN_CORE_PSET_HH Index: mln/core/internal/set_of.hh --- mln/core/internal/set_of.hh (revision 1037) +++ mln/core/internal/set_of.hh (working copy) @@ -59,6 +59,8 @@ * * The parameter \c E is the element type, which shall not be * const-qualified. + * + * \todo Add a remove method. */ template <typename E> class set_of_ @@ -123,7 +125,7 @@ * * \return An array (std::vector) of elements. */ - const std::vector<E>& vec() const; + const std::vector<E>& vect() const; protected: @@ -245,7 +247,7 @@ template <typename E> const std::vector<E>& - set_of_<E>::vec() const + set_of_<E>::vect() const { if (needs_update_) update_(); Index: mln/core/concept/point_iterator.hh Index: mln/core/concept/point_site.hh Index: mln/level/sort_points.hh --- mln/level/sort_points.hh (revision 0) +++ mln/level/sort_points.hh (revision 0) @@ -0,0 +1,158 @@ +// 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_LEVEL_SORT_POINTS_HH +# define MLN_LEVEL_SORT_POINTS_HH + +/*! \file mln/level/sort_points.hh + * + * \brief Sort_Points the contents of an image into another one. + */ + +# include <vector> +# include <utility> +# include <algorithm> + +# include <mln/core/concept/image.hh> +# include <mln/histo/compute.hh> + + +namespace mln +{ + + namespace level + { + + /*! Sort points the image \p input through a function \p f to set + * the \p output image. + * + * \param[in] input The input image. + * + * \pre \p input.has_data + */ + template <typename I> + std::vector<mln_point(I)> sort_points(const Image& input); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I> + struct value_point_less_ + { + const I& ima_; + + value_point_less_(const I& ima) + : ima_(ima) + { + } + + bool operator()(const mln_point(I)& lhs, + const mln_point(I)& rhs) const + { + return ima_(lhs) < ima_(rhs) || (ima_(lhs) = ima_(rhs) + && lhs < rhs); + } + }; + + template <typename I> + std::vector<mln_point(I)> + sort_points(metal::false_, // general case + const Image& input_) + { + const I& input = exact(input_); + + std::vector<mln_point(I)> vec; + vec.reserve(input.npoints()); + + mln_fwd_piter(I) p(input.domain()); + for_all(p) + vec.push_back(p); + + std::sort(vec.begin(), vec.end(), + value_point_less_(input)); + return vec; + } + + template <typename I> + std::vector<mln_point(I)> + sort_points(metal::true_, // low quantization + const Image& input_) + { + const I& input = exact(input_); + + 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[0] = 0; + for (unsigned i = 1; i != n; ++i) + loc[i] = loc[i-1] + h[i-1]; + + /* + MEMO. Decreasing case is: + 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()); + mln_fwd_piter(I) p(input.domain()); + for_all(p) + vec[loc[vset.index_of(input(p))]++] = p; + + return vec; + } + + } // end of namespace mln::level::impl + + + template <typename I> + std::vector<mln_point(I)> + sort_points(const Image& input) + { + mln_precondition(exact(input).has_data()); + return impl::sort_points(mln_is_value_lowq(I)(), exact(input)); + } + + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::level + +} // end of namespace mln + + +#endif // ! MLN_LEVEL_SORT_POINTS_HH Index: mln/accu/histo.hh --- mln/accu/histo.hh (revision 1037) +++ mln/accu/histo.hh (working copy) @@ -67,7 +67,7 @@ std::size_t nvalues() const; std::size_t sum() const; - const std::vector<std::size_t>& vec() const; + const std::vector<std::size_t>& vect() const; const S& vset() const; @@ -160,7 +160,7 @@ template <typename S> const std::vector<std::size_t>& - histo<S>::vec() const + histo<S>::vect() const { return h_; } Index: mln/accu/bbox.hh --- mln/accu/bbox.hh (revision 0) +++ mln/accu/bbox.hh (revision 0) @@ -0,0 +1,134 @@ +// 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_ACCU_BBOX_HH +# define MLN_ACCU_BBOX_HH + +/*! \file mln/accu/bbox.hh + * + * \brief Define an accumulator that computes a bbox. + */ + +# include <mln/core/concept/accumulator.hh> +# include <mln/core/box.hh> + + +namespace mln +{ + + namespace accu + { + + + /*! Generic bbox accumulator class. + * + * The parameter \c P is the type of points. + */ + template <typename P> + struct bbox : public Accumulator< bbox > + { + typedef P value; + + bbox(); + void take(const P& p); + void init(); + + operator box_() const; + const box_& to_value() const; + + bool is_valid() const; + + protected: + + bool is_valid_; + box_ b_; + }; + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename P> + bbox::bbox() + { + init(); + } + + template <typename P> + void bbox::take(const P& p) + { + if (! is_valid_) + { + b_.pmin() = p; + b_.pmax() = p; + is_valid_ = true; + return; + } + for (unsigned i = 0; i < P::dim; ++i) + if (p[i] < b_.pmin()[i]) + b_.pmin()[i] = p[i]; + else if (p[i] > b_.pmax()[i]) + b_.pmax()[i] = p[i]; + } + + template <typename P> + void + bbox::init() + { + is_valid_ = false; + } + + template <typename P> + bbox::operator box_() const + { + mln_precondition(is_valid_); + return b_; + } + + template <typename P> + const box_& + bbox::to_value() const + { + mln_precondition(is_valid_); + return b_; + } + + template <typename P> + bool + bbox::is_valid() const + { + return is_valid_; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::accu + +} // end of namespace mln + + +#endif // ! MLN_ACCU_BBOX_HH

17 years, 5 months

1037: Add int_s, an histogram class, and distributed sort.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add int_s, an histogram class, and distributed sort. * tests/int_s8.cc: New. * tests/int_u8.cc: Augment. * mln/histo/sort.hh: New. * mln/histo/data.hh: New. * mln/histo/compute.hh: New. * mln/accu/histo.hh: Fix doc. * mln/accu/median.hh: Fix doc. * mln/value/int_s8.hh: New. * mln/value/int_u16.hh: New. * mln/value/int_u8.hh: New. * mln/value/int_s.hh: New. * mln/value/int_u.hh (zero, one): New. (encoding_): Move to... * mln/value/internal/encoding.hh: ...this new file. * tests/median.cc, * tests/fast_median.cc, * tests/main.cc, * tests/hmedian.cc, * tests/erosion.cc, * tests/naive_median.cc, * tests/vset.cc, * tests/histo.cc, * mln/io/save_pgm.hh, * mln/io/load_pgm.hh: Update. mln/accu/histo.hh | 2 mln/accu/median.hh | 2 mln/histo/compute.hh | 95 +++++++++++++++++++++++ mln/histo/data.hh | 149 +++++++++++++++++++++++++++++++++++++ mln/histo/sort.hh | 147 ++++++++++++++++++++++++++++++++++++ mln/io/load_pgm.hh | 2 mln/io/save_pgm.hh | 2 mln/value/int_s.hh | 163 +++++++++++++++++++++++++++++++++++++++++ mln/value/int_s8.hh | 55 +++++++++++++ mln/value/int_u.hh | 79 ++++++++++++------- mln/value/int_u16.hh | 55 +++++++++++++ mln/value/int_u8.hh | 55 +++++++++++++ mln/value/internal/encoding.hh | 86 +++++++++++++++++++++ tests/erosion.cc | 2 tests/fast_median.cc | 2 tests/histo.cc | 26 ++++++ tests/hmedian.cc | 2 tests/int_s8.cc | 51 ++++++++++++ tests/int_u8.cc | 9 ++ tests/main.cc | 9 +- tests/median.cc | 2 tests/naive_median.cc | 2 tests/vset.cc | 2 23 files changed, 951 insertions(+), 48 deletions(-) Index: tests/median.cc --- tests/median.cc (revision 1036) +++ tests/median.cc (working copy) @@ -36,7 +36,7 @@ #include <mln/io/load_pgm.hh> #include <mln/io/save_pgm.hh> -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> #include <mln/level/median.hh> #include <mln/level/approx/median.hh> Index: tests/int_s8.cc --- tests/int_s8.cc (revision 0) +++ tests/int_s8.cc (revision 0) @@ -0,0 +1,51 @@ +// 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/int_s.cc + * + * \brief Tests on mln::value::int_s. + */ + +#include <mln/value/int_s.hh> + + +int main() +{ + using namespace mln; + using value::int_s; + + { + int_s<7> i = 3; + i = 2; + mln_assertion(i = 2); + mln_assertion(i != 3); + + mln_assertion(-i = -2); + mln_assertion(-3 * i = -6); + } + +} Index: tests/int_u8.cc --- tests/int_u8.cc (revision 1036) +++ tests/int_u8.cc (working copy) @@ -30,7 +30,7 @@ * \brief Tests on mln::value::int_u8. */ -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> @@ -39,6 +39,7 @@ using namespace mln; using value::int_u8; + { int_u8 i = 3; i = 2; mln_assertion(i = 2); @@ -47,3 +48,9 @@ mln_assertion(-i = -2); mln_assertion(-3 * i = -6); } + + { + int_u8 i = 128; + std::cout < #include <mln/io/save_pgm.hh> -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> #include <mln/debug/iota.hh> #include <mln/debug/println.hh> #include <mln/level/fast_median.hh> Index: tests/main.cc --- tests/main.cc (revision 1036) +++ tests/main.cc (working copy) @@ -39,13 +39,12 @@ #include <mln/morpho/erosion.hh> #include <mln/morpho/Rd.hh> +#include <mln/value/int_u8.hh> -typedef unsigned char int_u8; - -// static int_u8 cos_sin(const mln::point2d& p) +// static value::int_u8 cos_sin(const mln::point2d& p) // { -// return (int_u8)(255 * std::cos(float(p.row())) * std::sin(float(p.col()))); +// return (value::int_u8)(255 * std::cos(float(p.row())) * std::sin(float(p.col()))); // } @@ -54,7 +53,7 @@ using namespace mln; const unsigned size = 1000; - image2d_b<int_u8> f(size, size); + image2d_b<value::int_u8> f(size, size); morpho::Rd(f, f, c8()); } Index: tests/hmedian.cc --- tests/hmedian.cc (revision 1036) +++ tests/hmedian.cc (working copy) @@ -36,7 +36,7 @@ #include <mln/io/load_pgm.hh> #include <mln/io/save_pgm.hh> -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> #include <mln/level/median.hh> #include <mln/level/compare.hh> Index: tests/erosion.cc --- tests/erosion.cc (revision 1036) +++ tests/erosion.cc (working copy) @@ -36,7 +36,7 @@ #include <mln/io/load_pgm.hh> #include <mln/io/save_pgm.hh> -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> #include <mln/level/fill.hh> #include <mln/morpho/erosion.hh> Index: tests/naive_median.cc --- tests/naive_median.cc (revision 1036) +++ tests/naive_median.cc (working copy) @@ -36,7 +36,7 @@ #include <mln/io/load_pgm.hh> #include <mln/io/save_pgm.hh> -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> #include <mln/level/naive/median.hh> Index: tests/vset.cc --- tests/vset.cc (revision 1036) +++ tests/vset.cc (working copy) @@ -30,7 +30,7 @@ * \brief Tests on mln::value::set_<T>. */ -#include <mln/value/int_u.hh> +#include <mln/value/int_u8.hh> #include <mln/value/set.hh> Index: tests/histo.cc --- tests/histo.cc (revision 1036) +++ tests/histo.cc (working copy) @@ -27,17 +27,27 @@ /*! \file tests/histo.cc * - * \brief Tests on mln::value::histo<S>. + * \brief Tests on mln::accu::histo<S> and mln::histo::data<S>. */ +#include <iterator> + +#include <mln/core/image2d_b.hh> +#include <mln/value/int_u8.hh> + +#include <mln/debug/iota.hh> #include <mln/accu/histo.hh> +#include <mln/histo/compute.hh> +#include <mln/histo/sort.hh> int main() { using namespace mln; + using value::int_u8; + { accu::histo< value::set<bool> > h; for (unsigned i = 0; i < 5; ++i) @@ -49,3 +59,17 @@ mln_assertion(h[0] * 10 + h[1] = 51); mln_assertion(h(false) * 10 + h(true) = 51); } + + { + image2d_b<int_u8> ima(3, 3); + debug::iota(ima); + histo::data< value::set<int_u8> > h = histo::compute(ima); + std::cout << h << std::endl; + + std::vector<point2d> vec = histo::sort_points_decreasing(ima); + std::copy(vec.begin(), vec.end(), + std::ostream_iterator<point2d>(std::cout, " ")); + std::cout << std::endl; + } + +} Index: mln/histo/sort.hh --- mln/histo/sort.hh (revision 0) +++ mln/histo/sort.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_HISTO_SORT_HH +# define MLN_HISTO_SORT_HH + +/*! \file mln/histo/sort.hh + * + * \brief Routine to sort an histogram. + */ + +# include <vector> + +# include <mln/core/concept/image.hh> +# include <mln/histo/compute.hh> + + +namespace mln +{ + + namespace histo + { + + /// Sort points of image \p input by decreasing values. + template <typename I> + std::vector<mln_point(I)> sort_points_decreasing(const Image& input); + + /// Sort points of image \p input by increasing values. + template <typename I> + std::vector<mln_point(I)> sort_points_increasing(const Image& input); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I> + std::vector<mln_point(I)> + sort_points_decreasing(const Image& input_) + { + const I& input = exact(input_); + + typedef mln_vset(I) S; + const S& vset = input.values(); + const unsigned n = vset.nvalues(); + + // h + histo::data<S> h = 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()); + mln_fwd_piter(I) p(input.domain()); + for_all(p) + vec[loc[vset.index_of(input(p))]++] = p; + + return vec; + } + + template <typename I> + std::vector<mln_point(I)> + sort_points_increasing(const Image& input_) + { + const I& input = exact(input_); + + typedef mln_vset(I) S; + const S& vset = input.values(); + const unsigned n = vset.nvalues(); + + // h + histo::data<S> h = compute(input); + + // preparing output data + std::vector<unsigned> loc(vset.nvalues()); + loc[0] = 0; + for (unsigned i = 1; i != n; ++i) + loc[i] = loc[i-1] + h[i-1]; + + // 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; + + return vec; + } + + } // end of namespace mln::histo::impl + + + template <typename I> + std::vector<mln_point(I)> + sort_points_decreasing(const Image& input) + { + mln_precondition(exact(input).has_data()); + mln_precondition(exact(input).values().nvalues() > 1); // FIXME + return impl::sort_points_decreasing(exact(input)); + } + + + template <typename I> + std::vector<mln_point(I)> + sort_points_increasing(const Image& input) + { + mln_precondition(exact(input).has_data()); + mln_precondition(exact(input).values().nvalues() > 1); // FIXME + return impl::sort_points_increasing(exact(input)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::histo + +} // end of namespace mln + + +#endif // ! MLN_HISTO_SORT_HH Index: mln/histo/data.hh --- mln/histo/data.hh (revision 0) +++ mln/histo/data.hh (revision 0) @@ -0,0 +1,149 @@ +// 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_HISTO_DATA_HH +# define MLN_HISTO_DATA_HH + +/*! \file mln/histo/data.hh + * + * \brief Define a generic histogram class. + */ + +# include <vector> +# include <algorithm> + +# include <mln/core/concept/value_set.hh> + + +namespace mln +{ + + namespace histo + { + + + /*! Generic histogram class over a value set with type \c S. + */ + template <typename S> + struct data + { + typedef mln_value(S) value; + + data(const Value_Set<S>& s); + + void clear(); + + std::size_t operator()(const value& v) const; + std::size_t& operator()(const value& v); + + const std::vector<std::size_t>& vec() const; + const S& vset() const; + std::size_t operator[](unsigned i) const; + + protected: + + const S& s_; + std::vector<std::size_t> h_; + }; + + + template <typename S> + std::ostream& operator<<(std::ostream& ostr, const data<S>& h); + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename S> + data<S>::data(const Value_Set<S>& s) + : s_(exact(s)), + h_(s_.nvalues(), 0) + { + clear(); + } + + template <typename S> + void + data<S>::clear() + { + std::fill(h_.begin(), h_.end(), 0); + } + + template <typename S> + std::size_t + data<S>::operator()(const value& v) const + { + return h_[s_.index_of(v)]; + } + + template <typename S> + std::size_t& + data<S>::operator()(const value& v) + { + return h_[s_.index_of(v)]; + } + + template <typename S> + const S& + data<S>::vset() const + { + return s_; + } + + template <typename S> + std::size_t + data<S>::operator[](unsigned i) const + { + mln_precondition(i < s_.nvalues()); + return h_[i]; + } + + template <typename S> + const std::vector<std::size_t>& + data<S>::vec() const + { + return h_; + } + + template <typename S> + std::ostream& operator<<(std::ostream& ostr, const data<S>& h) + { + mln_viter(S) v(h.vset()); + for_all(v) + if (h(v) != 0) + ostr << v << ':' << h(v) << ' '; + return ostr; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::histo + +} // end of namespace mln + + +#endif // ! MLN_HISTO_DATA_HH Index: mln/histo/compute.hh --- mln/histo/compute.hh (revision 0) +++ mln/histo/compute.hh (revision 0) @@ -0,0 +1,95 @@ +// 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_HISTO_COMPUTE_HH +# define MLN_HISTO_COMPUTE_HH + +/*! \file mln/histo/compute.hh + * + * \brief Routine to compute an histogram. + */ + +# include <mln/core/concept/image.hh> +# include <mln/histo/data.hh> + + +namespace mln +{ + + namespace histo + { + + /// Compute the histogram of image \p input. + template <typename I> + data<mln_vset(I)> compute(const Image& input); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename I> + data<mln_vset(I)> compute(const Image& input_) + { + const I& input = exact(input_); + data<mln_vset(I)> h(input.values()); + mln_piter(I) p(input.domain()); + for_all(p) + ++h(input(p)); + return h; + } + + template <typename I> + data<mln_vset(I)> compute(const Fast_Image& input_) + { + const I& input = exact(input_); + data<mln_vset(I)> h(input.values()); + mln_pixter(const I) p(input); + for_all(p) + ++h(*p); + return h; + } + + } // end of namespace mln::histo::impl + + + template <typename I> + data<mln_vset(I)> compute(const Image& input) + { + mln_precondition(exact(input).has_data()); + return impl::compute(exact(input)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::histo + +} // end of namespace mln + + +#endif // ! MLN_HISTO_COMPUTE_HH Index: mln/io/save_pgm.hh --- mln/io/save_pgm.hh (revision 1036) +++ mln/io/save_pgm.hh (working copy) @@ -33,7 +33,7 @@ # include <fstream> # include <mln/core/image2d_b.hh> -# include <mln/value/int_u.hh> +# include <mln/value/int_u8.hh> namespace mln Index: mln/io/load_pgm.hh --- mln/io/load_pgm.hh (revision 1036) +++ mln/io/load_pgm.hh (working copy) @@ -34,7 +34,7 @@ # include <string> # include <mln/core/image2d_b.hh> -# include <mln/value/int_u.hh> +# include <mln/value/int_u8.hh> namespace mln Index: mln/accu/histo.hh --- mln/accu/histo.hh (revision 1036) +++ mln/accu/histo.hh (working copy) @@ -30,7 +30,7 @@ /*! \file mln/accu/histo.hh * - * \brief Define a couple of generic histogram classes. + * \brief Define a generic histogram accumulator class. */ # include <vector> Index: mln/accu/median.hh --- mln/accu/median.hh (revision 1036) +++ mln/accu/median.hh (working copy) @@ -30,7 +30,7 @@ /*! \file mln/accu/median.hh * - * \brief Define FIXME + * \brief Define a generic median accumulator class. */ # include <mln/core/concept/accumulator.hh> Index: mln/value/int_s8.hh --- mln/value/int_s8.hh (revision 0) +++ mln/value/int_s8.hh (revision 0) @@ -0,0 +1,55 @@ +// 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_S8_HH +# define MLN_VALUE_INT_S8_HH + +/*! \file mln/value/int_s8.hh + * + * \brief Define the alias value::int_s8. + */ + +# include <mln/value/int_s.hh> + + +namespace mln +{ + + namespace value + { + + + /// Alias for signed 8 bit integers. + typedef int_s<8> int_s8; + + + } // end of namespace mln::value + +} // end of namespace mln + + +#endif // ! MLN_VALUE_INT_S8_HH Index: mln/value/int_u16.hh --- mln/value/int_u16.hh (revision 0) +++ mln/value/int_u16.hh (revision 0) @@ -0,0 +1,55 @@ +// 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_U16_HH +# define MLN_VALUE_INT_U16_HH + +/*! \file mln/value/int_u16.hh + * + * \brief Define the alias value::int_u16. + */ + +# include <mln/value/int_u.hh> + + +namespace mln +{ + + namespace value + { + + + /// Alias for unsigned 16 bit integers. + typedef int_u<16> int_u16; + + + } // end of namespace mln::value + +} // end of namespace mln + + +#endif // ! MLN_VALUE_INT_U16_HH Index: mln/value/int_u8.hh --- mln/value/int_u8.hh (revision 0) +++ mln/value/int_u8.hh (revision 0) @@ -0,0 +1,55 @@ +// 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_U8_HH +# define MLN_VALUE_INT_U8_HH + +/*! \file mln/value/int_u8.hh + * + * \brief Define the alias value::int_u8. + */ + +# include <mln/value/int_u.hh> + + +namespace mln +{ + + namespace value + { + + + /// Alias for unsigned 8 bit integers. + typedef int_u<8> int_u8; + + + } // end of namespace mln::value + +} // end of namespace mln + + +#endif // ! MLN_VALUE_INT_U8_HH Index: mln/value/int_s.hh --- mln/value/int_s.hh (revision 0) +++ mln/value/int_s.hh (revision 0) @@ -0,0 +1,163 @@ +// 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_S_HH +# define MLN_VALUE_INT_S_HH + +/*! \file mln/value/int_s.hh + * + * \brief Define a generic class for signed integers. + */ + +# 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/value/set.hh> +# include <mln/debug/format.hh> + + +namespace mln +{ + + namespace value + { + + + /*! \brief Signed integer value class. + * + * The parameter is \c n the number of encoding bits. + */ + template <unsigned n> + struct int_s + : public internal::value_like_< typename internal::encoding_int_s_<n>::ret, + int_s<n> > + { + protected: + typedef internal::value_like_< typename internal::encoding_int_s_<n>::ret, + int_s<n> > super; + + public: + + /// Encoding associated type. + typedef typename super::enc enc; + + /// Constructor without argument. + int_s(); + + /// Constructor from an integer. + int_s(int i); + + /// Negation. + int_s<n> operator-() const; + + /// Zero value. + static const int_s<n> zero; + + /// Unit value. + static const int_s<n> one; + }; + + + + template <unsigned n> + struct props< int_s<n> > + { + static const int_s<n> max; // = 2^(n-1) - 1 + static const int_s<n> min; // = - max + static const std::size_t card = metal::pow<2, n>::value; + static const unsigned nbits = n; + typedef data_kind kind; + }; + + + // Safety. + template <> struct int_s<0>; + template <> struct int_s<1>; + + + + /*! \brief Print an signed integer \p i into the output stream \p ostr. + * + * \param[in,out] ostr An output stream. + * \param[in] i An signed integer. + * + * \return The modified output stream \p ostr. + */ + template <unsigned n> + std::ostream& operator<<(std::ostream& ostr, const int_s<n>& i); + + +# ifndef MLN_INCLUDE_ONLY + + template <unsigned n> + int_s<n>::int_s() + { + } + + template <unsigned n> + int_s<n>::int_s(int i) + { + mln_precondition(i >= mln_min(enc)); + mln_precondition(i <= mln_max(enc)); + this->v_ = enc(i); + } + + template <unsigned n> + int_s<n> int_s<n>::operator-() const + { + return - this->v_; + } + + template <unsigned n> + const int_s<n> int_s<n>::zero = 0; + + template <unsigned n> + const int_s<n> int_s<n>::one = 1; + + template <unsigned n> + const int_s<n> + props< int_s<n> >::min = 1 - metal::pow<2, n - 1>::value; + + template <unsigned n> + const int_s<n> + props< int_s<n> >::max = metal::pow<2, n - 1>::value - 1; + + template <unsigned n> + std::ostream& operator<<(std::ostream& ostr, const int_s<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_S_HH Index: mln/value/int_u.hh --- mln/value/int_u.hh (revision 1036) +++ mln/value/int_u.hh (working copy) @@ -35,8 +35,10 @@ # 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/value/set.hh> +# include <mln/debug/format.hh> namespace mln @@ -46,25 +48,18 @@ { - namespace internal - { - template <unsigned n> struct encoding_; - template <> struct encoding_<8> { typedef unsigned char ret; }; - } - - /*! \brief Unsigned integer value class. * * The parameter is \c n the number of encoding bits. */ template <unsigned n> - struct int_u_ - : public internal::value_like_< typename internal::encoding_<n>::ret, - int_u_<n> > + struct int_u + : public internal::value_like_< typename internal::encoding_int_u_<n>::ret, + int_u<n> > { protected: - typedef internal::value_like_< typename internal::encoding_<n>::ret, - int_u_<n> > super; + typedef internal::value_like_< typename internal::encoding_int_u_<n>::ret, + int_u<n> > super; public: @@ -72,60 +67,82 @@ typedef typename super::enc enc; /// Constructor without argument. - int_u_(); + int_u(); /// Constructor from an integer. - int_u_(int i); + int_u(int i); + + /// Zero value. + static const int_u<n> zero; + + /// Unit value. + static const int_u<n> one; }; + // Safety. + template <> struct int_u<0>; + template <> struct int_u<1>; + template <unsigned n> - struct props< int_u_<n> > : public props< typename internal::encoding_<n>::ret > + struct props< int_u<n> > { - static const unsigned nbits = n; static const std::size_t card = metal::pow<2, n>::value; + static const int_u<n> min; // = 0 + static const int_u<n> max; // = card - 1 + static const unsigned nbits = n; + typedef data_kind kind; }; - /// Alias for unsigned 8bit integers. - typedef int_u_<8> int_u8; - - /// Alias for the set of unsigned 8bit integers. - typedef set<int_u8> int_u8_set; - - - - /*! \brief Print an int_u8 \p i into the output stream \p ostr. + /*! \brief Print an unsigned integer \p i into the output stream \p ostr. * * \param[in,out] ostr An output stream. - * \param[in] i An int_u8. + * \param[in] i An unsigned integer. * * \return The modified output stream \p ostr. */ - std::ostream& operator<<(std::ostream& ostr, const int_u8& i); + template <unsigned n> + std::ostream& operator<<(std::ostream& ostr, const int_u<n>& i); # ifndef MLN_INCLUDE_ONLY template <unsigned n> - int_u_<n>::int_u_() + int_u<n>::int_u() { } template <unsigned n> - int_u_<n>::int_u_(int i) + int_u<n>::int_u(int i) { mln_precondition(i >= 0); mln_precondition(i <= mln_max(enc)); this->v_ = enc(i); } - std::ostream& operator<<(std::ostream& ostr, const int_u8& i) + template <unsigned n> + const int_u<n> int_u<n>::zero = 0; + + template <unsigned n> + const int_u<n> int_u<n>::one = 1; + + + template <unsigned n> + const int_u<n> + props< int_u<n> >::min = 0; + + template <unsigned n> + const int_u<n> + props< int_u<n> >::max = metal::pow<2, n>::value - 1; + + template <unsigned n> + std::ostream& operator<<(std::ostream& ostr, const int_u<n>& i) { - return ostr << unsigned(i.to_equiv()); + return ostr << debug::format(i.to_equiv()); } # endif // ! MLN_INCLUDE_ONLY Index: mln/value/internal/encoding.hh --- mln/value/internal/encoding.hh (revision 0) +++ mln/value/internal/encoding.hh (revision 0) @@ -0,0 +1,86 @@ +// 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_INTERNAL_ENCODING_HH +# define MLN_VALUE_INTERNAL_ENCODING_HH + +/*! \file mln/value/internal/encoding.hh + * + * \brief Define some information about how to encode some value types. + */ + + +namespace mln +{ + + namespace value + { + + namespace internal + { + + template <unsigned n> struct encoding_int_u_; + + template <> struct encoding_int_u_<8> { typedef unsigned char ret; }; + template <> struct encoding_int_u_<16> { typedef unsigned short ret; }; + template <> struct encoding_int_u_<32> { typedef unsigned int ret; }; // FIXME!!! + template <> struct encoding_int_u_<64> { typedef unsigned long ret; }; // FIXME!!! + + template <> struct encoding_int_u_<99> { typedef void ret; }; // stopper + + template <unsigned n> + struct encoding_int_u_ + { + typedef typename encoding_int_u_<n+1>::ret ret; + }; + + + + template <unsigned n> struct encoding_int_s_; + + template <> struct encoding_int_s_<8> { typedef signed char ret; }; + template <> struct encoding_int_s_<16> { typedef signed short ret; }; + template <> struct encoding_int_s_<32> { typedef signed int ret; }; // FIXME!!! + template <> struct encoding_int_s_<64> { typedef signed long ret; }; // FIXME!!! + + template <> struct encoding_int_s_<99> { typedef void ret; }; // stopper + + template <unsigned n> + struct encoding_int_s_ + { + typedef typename encoding_int_s_<n+1>::ret ret; + }; + + + } // end of namespace mln::value::internal + + } // end of namespace mln::value + +} // end of namespace mln + + +#endif // ! MLN_VALUE_INTERNAL_ENCODING_HH

17 years, 5 months

1036: Make value::set works for any type.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Make value::set works for any type. * mln/value/set.hh: Rename as... * mln/value/internal/iterable_set.hh: ...this. (the): Remove. (E): New. * mln/value/set.hh: New. * tests/vset.cc, * tests/histo.cc, * TODO, * mln/core/macros.hh, * mln/core/trait/is_lowq.hh, * mln/core/fimage.hh, * mln/core/image2d_b.hh, * mln/level/naive/median.hh, * mln/level/was.median.hh, * mln/level/fast_median.hh, * mln/level/transform.hh, * mln/level/median.hh, * mln/accu/histo.hh, * mln/accu/median.hh, * mln/accu/median_alt.hh, * mln/value/props.hh, * mln/value/cast.hh, * mln/value/int_u.hh: Update. TODO | 2 mln/accu/histo.hh | 68 +++++++++------------------ mln/accu/median.hh | 47 ++++--------------- mln/accu/median_alt.hh | 4 - mln/core/fimage.hh | 4 - mln/core/image2d_b.hh | 2 mln/core/macros.hh | 5 +- mln/core/trait/is_lowq.hh | 6 +- mln/level/fast_median.hh | 2 mln/level/median.hh | 5 +- mln/level/naive/median.hh | 2 mln/level/transform.hh | 2 mln/level/was.median.hh | 4 - mln/value/cast.hh | 6 +- mln/value/int_u.hh | 8 --- mln/value/internal/iterable_set.hh | 57 ++++++++++------------- mln/value/props.hh | 13 +---- mln/value/set.hh | 91 +++++++++++-------------------------- tests/histo.cc | 22 +------- tests/vset.cc | 32 ++++++------- 20 files changed, 138 insertions(+), 244 deletions(-) Index: tests/vset.cc --- tests/vset.cc (revision 1035) +++ tests/vset.cc (working copy) @@ -35,29 +35,31 @@ -int main() +template <typename T> +void test() { - using namespace mln; - - typedef bool T; - // typedef value::int_u8 T; - // typedef short T; - - typedef value::set_<T> S; + typedef mln::value::set<T> S; S s; - { - S::fwd_viter v(s); + mln_fwd_viter(S) v(s); for_all(v) std::cout << v << ' '; std::cout << std::endl; - } - { - S::bkd_viter v(s); - for_all(v) - std::cout << v << ' '; + mln_bkd_viter(S) w(s); + for_all(w) + std::cout << w << ' '; std::cout << std::endl; } + + +int main() +{ + using namespace mln; + + test<bool>(); +// test<unsigned char>(); +// test<unsigned short>(); +// test<value::int_u8>(); } Index: tests/histo.cc --- tests/histo.cc (revision 1035) +++ tests/histo.cc (working copy) @@ -30,7 +30,6 @@ * \brief Tests on mln::value::histo<S>. */ -#include <mln/value/int_u.hh> #include <mln/accu/histo.hh> @@ -38,11 +37,8 @@ int main() { using namespace mln; - using namespace mln::value; - using namespace mln::accu; - - histo_on_type<bool> h; + accu::histo< value::set<bool> > h; for (unsigned i = 0; i < 5; ++i) h.take(false); @@ -50,18 +46,6 @@ h.take(true); h.untake(true); - std::cout << h << std::endl; - std::cout << h[0] * 10 + h[1] << std::endl; - std::cout << h(false) * 10 + h(true) << std::endl; - - h.init(); - std::cout << h << std::endl; - - - // ... - - - typedef value::set_<int_u8> S; - histo_on_set<S> h_u8(S::the()); - std::cout << h_u8 << std::endl; + mln_assertion(h[0] * 10 + h[1] = 51); + mln_assertion(h(false) * 10 + h(true) = 51); } Index: TODO --- TODO (revision 1035) +++ TODO (working copy) @@ -18,7 +18,6 @@ value::proxy to dispatch read/write + the corresponding image type a mean_value object { sum; count } and operator+ t_image to "transpose" the 0 and the i-th coordinates -image defined by f/pset ** extensions @@ -35,7 +34,6 @@ * clean-up -accu::histo and median: remove inheritance select_function in fun::internal::selector_p2? etc. Index: mln/core/macros.hh --- mln/core/macros.hh (revision 1035) +++ mln/core/macros.hh (working copy) @@ -149,7 +149,10 @@ # define mln_value(T) typename T::value /// Shortcut to the kind of values for an image with type \c I. -# define mln_value_kind(T) typename mln::value::props< mln_value(I) >::kind +# define mln_value_kind(I) typename mln::value::props< mln_value(I) >::kind + +/// Shortcut to test if the values of an image with type \c I are lowly quantifized. +# define mln_is_value_lowq(I) typename mln::trait::is_lowq< mln_value(I) >::ret /// Shortcut to access the type of value set (vset) associated to T. # define mln_vset(T) typename T::vset Index: mln/core/trait/is_lowq.hh --- mln/core/trait/is_lowq.hh (revision 1035) +++ mln/core/trait/is_lowq.hh (working copy) @@ -37,7 +37,7 @@ # include <mln/value/props.hh> -# define mln_is_lowq(I) typename mln::trait::is_lowq::ret +# define mln_is_lowq(T) typename mln::trait::is_lowq< T >::ret @@ -50,10 +50,10 @@ // FIXME: Doc! - template <typename I> + template <typename T> struct is_lowq { - typedef typename metal::bool_<( mln_card(mln_value(I)) != 0 )>::type ret; + typedef typename metal::bool_<( mln_card(T) != 0 )>::type ret; }; Index: mln/core/fimage.hh --- mln/core/fimage.hh (revision 1035) +++ mln/core/fimage.hh (working copy) @@ -63,7 +63,7 @@ typedef void lvalue; // FIXME /// Value set associated type. - typedef mln::value::set_<mln_result(F)> vset; + typedef mln::value::set<mln_result(F)> vset; /// Constructor. @@ -156,7 +156,7 @@ } template <typename F, typename S> - const mln::value::set_<mln_result(F)>& + const mln::value::set<mln_result(F)>& fimage<F,S>::values() const { return vset::the(); Index: mln/core/image2d_b.hh --- mln/core/image2d_b.hh (revision 1035) +++ mln/core/image2d_b.hh (working copy) @@ -119,7 +119,7 @@ }; /// Value_Set associated type. - typedef mln::value::set_<T> vset; + typedef mln::value::set<T> vset; /// Constructor without argument. Index: mln/level/naive/median.hh --- mln/level/naive/median.hh (revision 1035) +++ mln/level/naive/median.hh (working copy) @@ -78,7 +78,7 @@ { mln_piter(I) p(input.domain()); mln_qiter(W) q(win, p); - accu::median_on<mln_value(I)> med; + accu::median<mln_vset(I)> med(input.values()); for_all(p) { Index: mln/level/was.median.hh --- mln/level/was.median.hh (revision 1035) +++ mln/level/was.median.hh (working copy) @@ -72,7 +72,7 @@ q_bp(win_bkd_plus, p), q_bm(win_bkd_minus, p), q_top(win_top, p), q_bot(win_bot, p); - accu::median_on<mln_value(I)> med; + accu::median<mln_vset(I)> med(input.values()); // initialization @@ -146,7 +146,7 @@ int& row = p.row(); int& col = p.col(); - accu::median_on<mln_value(I)> med; + accu::median<mln_vset(I)> med(input.values()); for (row = input.min_row(); row <= max_row; ++row) { Index: mln/level/fast_median.hh --- mln/level/fast_median.hh (revision 1035) +++ mln/level/fast_median.hh (working copy) @@ -84,7 +84,7 @@ win_bot = win - (win + up), win_top = (win + up) - win; - accu::median_on<mln_value(I)> med; + accu::median<mln_vset(I)> med(input.values()); // initialization Index: mln/level/transform.hh --- mln/level/transform.hh (revision 1035) +++ mln/level/transform.hh (working copy) @@ -120,7 +120,7 @@ void transform(const Image& input, const Function_v2v<F>& f, Image<O>& output) { mln_precondition(exact(output).domain() >= exact(input).domain()); - impl::transform(mln_is_lowq(I)(), + impl::transform(mln_is_value_lowq(I)(), exact(input), exact(f), exact(output)); } Index: mln/level/median.hh --- mln/level/median.hh (revision 1035) +++ mln/level/median.hh (working copy) @@ -80,10 +80,10 @@ // aux data + accu::median<mln_vset(I)> med; mln_point(I) p; window2d win_fp, win_fm, win_bp, win_bm, win_dp, win_dm; mln_qiter(W) q_fp, q_fm, q_bp, q_bm, q_dp, q_dm; - accu::median_on<mln_value(I)> med; // ctor @@ -94,6 +94,7 @@ win(exact(win_)), output(exact(output_)), // 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), @@ -171,7 +172,7 @@ coord& row = p.row(); coord& col = p.col(); - accu::median_on<mln_value(I)> med; + accu::median<mln_vset(I)> med(input.values()); for (row = input.min_row(); row <= max_row; ++row) { Index: mln/accu/histo.hh --- mln/accu/histo.hh (revision 1035) +++ mln/accu/histo.hh (working copy) @@ -51,9 +51,10 @@ /*! Generic histogram class over a value set with type \c S. */ template <typename S> - struct histo_on_set : public Accumulator< histo_on_set<S> > + struct histo : public Accumulator< histo<S> > { - histo_on_set(const Value_Set<S>& s); + histo(const Value_Set<S>& s); + histo(); typedef mln_value(S) value; @@ -79,41 +80,32 @@ template <typename S> - std::ostream& operator<<(std::ostream& ostr, const histo_on_set<S>& h); - - - - - /*! Generic histogram class over the set of values of type \c T. - * - * \todo Inheritance is badly formed since this concrete class - * derives from another concrete class. - */ - template <typename T> - struct histo_on_type : public histo_on_set< value::set_<T> > - { - histo_on_type(); - }; + std::ostream& operator<<(std::ostream& ostr, const histo<S>& h); # ifndef MLN_INCLUDE_ONLY - - // histo_on_set<S> - template <typename S> - histo_on_set<S>::histo_on_set(const Value_Set<S>& s) + histo<S>::histo(const Value_Set<S>& s) : s_(exact(s)), - h_(exact(s).nvalues(), 0), + h_(s_.nvalues(), 0), + sum_(0) + { + } + + template <typename S> + histo<S>::histo() + : s_(S::the()), + h_(s_.nvalues(), 0), sum_(0) { } template <typename S> void - histo_on_set<S>::take(const value& v) + histo<S>::take(const value& v) { ++h_[s_.index_of(v)]; ++sum_; @@ -121,7 +113,7 @@ template <typename S> void - histo_on_set<S>::untake(const value& v) + histo<S>::untake(const value& v) { mln_precondition(h_[s_.index_of(v)] > 0); mln_precondition(sum_ > 0); @@ -131,7 +123,7 @@ template <typename S> void - histo_on_set<S>::init() + histo<S>::init() { std::fill(h_.begin(), h_.end(), 0); sum_ = 0; @@ -139,14 +131,14 @@ template <typename S> std::size_t - histo_on_set<S>::operator()(const value& v) const + histo<S>::operator()(const value& v) const { return h_[s_.index_of(v)]; } template <typename S> std::size_t - histo_on_set<S>::operator[](std::size_t i) const + histo<S>::operator[](std::size_t i) const { mln_precondition(i < s_.nvalues()); return h_[i]; @@ -154,54 +146,42 @@ template <typename S> std::size_t - histo_on_set<S>::nvalues() const + histo<S>::nvalues() const { return s_.nvalues(); } template <typename S> std::size_t - histo_on_set<S>::sum() const + histo<S>::sum() const { return sum_; } template <typename S> const std::vector<std::size_t>& - histo_on_set<S>::vec() const + histo<S>::vec() const { return h_; } template <typename S> const S& - histo_on_set<S>::vset() const + histo<S>::vset() const { return s_; } template <typename S> - std::ostream& operator<<(std::ostream& ostr, const histo_on_set<S>& h) + std::ostream& operator<<(std::ostream& ostr, const histo<S>& h) { mln_viter(S) v(h.vset()); for_all(v) if (h(v) != 0) ostr << v << ':' << h(v) << ' '; - ostr << std::endl; return ostr; } - - // histo_on_type<T> - - template <typename T> - histo_on_type<T>::histo_on_type() - : histo_on_set< value::set_<T> >(value::set_<T>::the()) - { - } - - - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::accu Index: mln/accu/median.hh --- mln/accu/median.hh (revision 1035) +++ mln/accu/median.hh (working copy) @@ -53,6 +53,7 @@ typedef mln_value(S) value; median(const Value_Set<S>& s); + median(); void take(const value& v); void untake(const value& v); @@ -63,20 +64,11 @@ operator mln_value(S) () const; value to_value() const; - const histo_on_set<S>& histo() const; - - // FIXME: remove - void debug__() const - { - std::cout << " i = " << i_ - << " v = " << v_ - << " s = " << sum_minus_ << " ; " << h_[i_] << " ; " << sum_plus_ << " = " << h_.sum() - << std::endl; - } + const accu::histo<S>& histo() const; protected: - mutable histo_on_set<S> h_; + mutable accu::histo<S> h_; const S& s_; // derived from h_ mutable std::size_t sum_minus_, sum_plus_; @@ -92,24 +84,8 @@ }; - /*! Generic median class over the set of values of type \c T. - * - * \todo Inheritance is badly formed since this concrete class - * derives from another concrete class. - */ - template <typename T> - struct median_on : public median< value::set_<T> > - { - median_on() - : median< value::set_<T> >(value::set_<T>::the()) - { - } - }; - - # ifndef MLN_INCLUDE_ONLY - template <typename S> median<S>::median(const Value_Set<S>& s) : h_(s), @@ -118,6 +94,13 @@ init(); } + template <typename S> + median<S>::median() + : h_(), + s_(h_.vset()) + { + init(); + } template <typename S> void @@ -134,7 +117,6 @@ valid_ = false; } - template <typename S> void median<S>::untake(const value& v) @@ -151,7 +133,6 @@ valid_ = false; } - template <typename S> void median<S>::update_() const @@ -177,7 +158,6 @@ } } - template <typename S> void median<S>::go_minus_() const @@ -194,7 +174,6 @@ v_ = s_[i_]; } - template <typename S> void median<S>::go_plus_() const @@ -211,7 +190,6 @@ v_ = s_[i_]; } - template <typename S> void median<S>::init() @@ -224,7 +202,6 @@ valid_ = true; } - template <typename S> median<S>::operator mln_value(S) () const { @@ -241,7 +218,7 @@ } template <typename S> - const histo_on_set<S>& + const accu::histo<S>& median<S>::histo() const { return h_; @@ -250,11 +227,9 @@ template <typename S> std::ostream& operator<<(std::ostream& ostr, const median<S>& m) { - m.debug__(); return ostr << m.to_value(); } - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::accu Index: mln/accu/median_alt.hh --- mln/accu/median_alt.hh (revision 1035) +++ mln/accu/median_alt.hh (working copy) @@ -86,10 +86,10 @@ template <typename T> - struct median_alt_on : public median_alt< value::set_<T> > + struct median_alt_on : public median_alt< value::set<T> > { median_alt_on() - : median_alt< value::set_<T> >(value::set_<T>::the()) + : median_alt< value::set<T> >(value::set<T>::the()) { } }; Index: mln/value/props.hh --- mln/value/props.hh (revision 1035) +++ mln/value/props.hh (working copy) @@ -65,19 +65,14 @@ { - /*! Class that defines the properties of the value type \c T. + /*! Class that defines the properties (by default) of any value + * type \c T. */ template <typename T> struct props { - /// Minimum value for type \c T. - static const T min; - - /// Maximum value for type \c T. - static const T max; - - /// Number of values for type \c T. - static const std::size_t card; + typedef data_kind kind; + static const std::size_t card = 0; }; Index: mln/value/cast.hh --- mln/value/cast.hh (revision 1035) +++ mln/value/cast.hh (working copy) @@ -47,7 +47,7 @@ * */ template <typename T, typename I> - struct cast_image : public 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; @@ -65,7 +65,7 @@ typedef void lvalue; // FIXME /// Value set associated type. - typedef mln::value::set_<T> vset; + typedef mln::value::set<T> vset; /// Constructor. @@ -159,7 +159,7 @@ } template <typename T, typename I> - const mln::value::set_<T>& + const mln::value::set<T>& cast_image<T,I>::values() const { return vset::the(); Index: mln/value/set.hh --- mln/value/set.hh (revision 1035) +++ mln/value/set.hh (working copy) @@ -33,8 +33,8 @@ * \brief Define some basic sets of values from value types. */ -# include <mln/core/concept/value_set.hh> -# include <mln/value/props.hh> +# include <mln/value/internal/iterable_set.hh> +# include <mln/core/trait/is_lowq.hh> namespace mln @@ -43,41 +43,41 @@ namespace value { - // Fwd decls. - template <typename S> struct fwd_viter_; - template <typename S> struct bkd_viter_; + // Fwd decl. + template <typename T> struct set; - /*! Class that defines the set of values of type \c T. - * - * This is an exhaustive value set over \c T. - */ - template <typename T> - struct set_ : public Value_Set< set_<T> > + + namespace internal { - /// Value associated type. - typedef T value; - /// Forward Value_Iterator associated type. - typedef fwd_viter_< set_<T> > fwd_viter; + template <typename T, typename lowq = metal::false_ > + struct run_set_selector_ // no inheritance + {}; - /// Backward Value_Iterator associated type. - typedef bkd_viter_< set_<T> > bkd_viter; + template <typename T> + struct run_set_selector_< T, metal::true_ > // lowq so iterable + : + public iterable_set< T, mln::value::set<T> > + {}; - /// Test if \p v belongs to this set: always true! - bool has(const T& v) const; + template <typename T> + struct set_selector_ : public run_set_selector_< T, mln_is_lowq(T) > + {}; - /// Give the \p i-th value. - T operator[](std::size_t i) const; + } // end of namespace mln::value::internal - /// Give the index of value \p v in this set. - std::size_t index_of(const T& v) const; - /// Give the number of values. - std::size_t nvalues() const; + /*! Class that defines the set of values of type \c T. + * + * This is the exhaustive set of values obtainable from type \c T. + */ + template <typename T> + struct set : public internal::set_selector_<T> + { /// Return a singleton. - static const set_<T>& the(); + static const set<T>& the(); }; @@ -85,39 +85,10 @@ # ifndef MLN_INCLUDE_ONLY template <typename T> - bool - set_<T>::has(const T&) const - { - return true; - } - - template <typename T> - T - set_<T>::operator[](std::size_t i) const + const set<T>& + set<T>::the() { - mln_precondition(i < nvalues()); - return mln_min(T) + i; - } - - template <typename T> - std::size_t - set_<T>::index_of(const T& v) const - { - return v - mln_min(T); - } - - template <typename T> - std::size_t - set_<T>::nvalues() const - { - return mln_card(T); - } - - template <typename T> - const set_<T>& - set_<T>::the() - { - static set_<T> the_; + static set<T> the_; return the_; } @@ -125,11 +96,7 @@ } // end of namespace mln::value - } // end of namespace mln -# include <mln/value/viter.hh> - - #endif // ! MLN_VALUE_SET_HH Index: mln/value/int_u.hh --- mln/value/int_u.hh (revision 1035) +++ mln/value/int_u.hh (working copy) @@ -33,10 +33,10 @@ * \brief Define a generic class for unsigned integers. */ -# include <mln/core/concept/value.hh> # include <mln/metal/math.hh> # include <mln/value/internal/value_like.hh> # include <mln/value/props.hh> +# include <mln/value/set.hh> namespace mln @@ -89,15 +89,11 @@ }; - // Fwd decl. - template <typename T> struct vset_; - - /// Alias for unsigned 8bit integers. typedef int_u_<8> int_u8; /// Alias for the set of unsigned 8bit integers. - typedef vset_<int_u8> int_u8_set; + typedef set<int_u8> int_u8_set; Index: mln/value/internal/iterable_set.hh --- mln/value/internal/iterable_set.hh (revision 1035) +++ mln/value/internal/iterable_set.hh (working copy) @@ -25,12 +25,12 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_VALUE_SET_HH -# define MLN_VALUE_SET_HH +#ifndef MLN_VALUE_INTERNAL_ITERABLE_SET_HH +# define MLN_VALUE_INTERNAL_ITERABLE_SET_HH -/*! \file mln/value/set.hh +/*! \file mln/value/internal/iterable_set.hh * - * \brief Define some basic sets of values from value types. + * \brief Define the iterable value set derived from a type. */ # include <mln/core/concept/value_set.hh> @@ -48,83 +48,76 @@ template <typename S> struct bkd_viter_; + namespace internal + { + /*! Class that defines the set of values of type \c T. * - * This is an exhaustive value set over \c T. + * This is the exhaustive iterable_set of values obtainable from type \c T. */ - template <typename T> - struct set_ : public Value_Set< set_<T> > + template <typename T, typename E> + struct iterable_set : public Value_Set<E> { /// Value associated type. typedef T value; /// Forward Value_Iterator associated type. - typedef fwd_viter_< set_<T> > fwd_viter; + typedef fwd_viter_<E> fwd_viter; /// Backward Value_Iterator associated type. - typedef bkd_viter_< set_<T> > bkd_viter; + typedef bkd_viter_<E> bkd_viter; - /// Test if \p v belongs to this set: always true! + /// Test if \p v belongs to this iterable_set: always true! bool has(const T& v) const; /// Give the \p i-th value. T operator[](std::size_t i) const; - /// Give the index of value \p v in this set. + /// Give the index of value \p v in this iterable_set. std::size_t index_of(const T& v) const; /// Give the number of values. std::size_t nvalues() const; - - /// Return a singleton. - static const set_<T>& the(); }; # ifndef MLN_INCLUDE_ONLY - template <typename T> + template <typename T, typename E> bool - set_<T>::has(const T&) const + iterable_set<T,E>::has(const T&) const { return true; } - template <typename T> + template <typename T, typename E> T - set_<T>::operator[](std::size_t i) const + iterable_set<T,E>::operator[](std::size_t i) const { mln_precondition(i < nvalues()); return mln_min(T) + i; } - template <typename T> + template <typename T, typename E> std::size_t - set_<T>::index_of(const T& v) const + iterable_set<T,E>::index_of(const T& v) const { return v - mln_min(T); } - template <typename T> + template <typename T, typename E> std::size_t - set_<T>::nvalues() const + iterable_set<T,E>::nvalues() const { return mln_card(T); } - template <typename T> - const set_<T>& - set_<T>::the() - { - static set_<T> the_; - return the_; - } - # endif // ! MLN_INCLUDE_ONLY - } // end of namespace mln::value + } // end of namespace mln::value::internal + } // end of namespace mln::value } // end of namespace mln @@ -132,4 +125,4 @@ # include <mln/value/viter.hh> -#endif // ! MLN_VALUE_SET_HH +#endif // ! MLN_VALUE_INTERNAL_ITERABLE_SET_HH

17 years, 5 months

1035: Handle constness properly in pixel iterators.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Handle constness properly in pixel iterators. * mln/core/trait/qlf_value.hh: New. * mln/core/internal/pixel_iterator_base.hh (qualified_value): Move and rename as... * mln/core/trait/qlf_value.hh (qlf_value): ...this. * doc/Doxyfile.in: Update. * mln/core/macros.hh (mln_qlf_value): New. Add space. * mln/core/pixter2d_b.hh (eor_): Update type. (image): New. * mln/core/dpoints_pixter.hh (value_ref_): Update type. * mln/core/internal/pixel_impl.hh (value_): Remove; obsolete. (image): New. * mln/core/fimage.hh: Fix warning. * mln/core/concept/generalized_pixel.hh (image): New. (address_): Update type. (todo): New. (ctor): Re-activate check. * mln/core/concept/fast_image.hh (offset): New; factor code. (buffer): New overload. * mln/core/concept/doc/generalized_pixel.hh (image): New. (address_): Update type. * mln/core/concept/doc/fast_image.hh (offset): Remove; factored. * mln/core/image2d_b.hh (offset): Remove; factored. (buffer): New. * mln/level/assign.hh: Fix doc. * mln/value/cast.hh: Fix warning. * TODO: Update. TODO | 1 doc/Doxyfile.in | 1 mln/core/concept/doc/fast_image.hh | 9 ---- mln/core/concept/doc/generalized_pixel.hh | 5 +- mln/core/concept/fast_image.hh | 41 ++++++++++++++++-- mln/core/concept/generalized_pixel.hh | 15 +++++- mln/core/dpoints_pixter.hh | 5 -- mln/core/fimage.hh | 6 +- mln/core/image2d_b.hh | 22 ++++------ mln/core/internal/pixel_impl.hh | 12 ++--- mln/core/internal/pixel_iterator_base.hh | 23 +--------- mln/core/macros.hh | 3 + mln/core/pixter2d_b.hh | 6 +- mln/core/trait/qlf_value.hh | 65 ++++++++++++++++++++++++++++++ mln/level/assign.hh | 2 mln/value/cast.hh | 6 +- 16 files changed, 152 insertions(+), 70 deletions(-) Index: doc/Doxyfile.in --- doc/Doxyfile.in (revision 1034) +++ doc/Doxyfile.in (working copy) @@ -1055,6 +1055,7 @@ "mln_fwd_viter(T)=typename T::fwd_viter" \ "mln_bkd_viter(T)=typename T::bkd_viter" \ "mln_value(T)=typename T::value" \ + "mln_qlf_value(T)=typename T::qlf_value" \ "mln_vset(T)=typename T::vset" \ "mln_rvalue(T)=typename T::rvalue" \ "mln_lvalue(T)=typename T::lvalue" \ Index: TODO --- TODO (revision 1034) +++ TODO (working copy) @@ -30,6 +30,7 @@ * renaming mlc into metal ++ look for "same_grid" etc. * clean-up Index: mln/core/macros.hh --- mln/core/macros.hh (revision 1034) +++ mln/core/macros.hh (working copy) @@ -121,6 +121,9 @@ // q +/// Shortcut to access the qualified (const or mutable) value type associated to T. +# define mln_qlf_value(T) typename mln::trait::qlf_value< T >::ret + /// Shortcut to access the qiter type associated to T. # define mln_qiter(T) typename T::fwd_qiter Index: mln/core/trait/qlf_value.hh --- mln/core/trait/qlf_value.hh (revision 0) +++ mln/core/trait/qlf_value.hh (revision 0) @@ -0,0 +1,65 @@ +// 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_CORE_TRAIT_QLF_VALUE_HH +# define MLN_CORE_TRAIT_QLF_VALUE_HH + +/*! \file mln/core/trait/qlf_value.hh + * + * \brief Definition of the qlf_value image trait. + */ + +# include <mln/core/macros.hh> + + +namespace mln +{ + + namespace trait + { + + + template <typename I> + struct qlf_value + { + typedef mln_value(I) ret; + }; + + + template <typename I> + struct qlf_value< const I > + { + typedef const mln_value(I) ret; + }; + + + } // end of namespace mln::trait + +} // end of namespace mln + + +#endif // ! MLN_CORE_TRAIT_QLF_VALUE_HH Index: mln/core/fimage.hh --- mln/core/fimage.hh (revision 1034) +++ mln/core/fimage.hh (working copy) @@ -82,8 +82,8 @@ /// Read-only access of pixel value at point site \p p. mln_result(F) operator()(const psite& p) const; - /// Read-write access of pixel value at point site \p p. - void operator()(const psite& p); + /// Read-write access is present but disabled. + void operator()(const psite&); /// Give the set of values of the image. const vset& values() const; @@ -150,7 +150,7 @@ template <typename F, typename S> void - fimage<F,S>::operator()(const psite& p) + fimage<F,S>::operator()(const psite&) { mln_invariant(0); // FIXME: Turn into a compile-time error... } Index: mln/core/pixter2d_b.hh --- mln/core/pixter2d_b.hh (revision 1034) +++ mln/core/pixter2d_b.hh (working copy) @@ -45,10 +45,12 @@ class fwd_pixter2d_b : public internal::pixel_iterator_base_< I, fwd_pixter2d_b > { typedef internal::pixel_iterator_base_< I, fwd_pixter2d_b > super_; - typedef typename super_::value_ value_; public: + /// Image type. + typedef I image; + /*! \brief Constructor. * * \param[in] image Image to iterate over its pixels. @@ -67,7 +69,7 @@ unsigned row_offset_; /// End of the current row. - value_* eor_; + mln_qlf_value(I)* eor_; }; Index: mln/core/dpoints_pixter.hh --- mln/core/dpoints_pixter.hh (revision 1034) +++ mln/core/dpoints_pixter.hh (working copy) @@ -58,9 +58,6 @@ typedef typename internal::pixel_impl_< I, dpoints_fwd_pixter > super_; public: - /// Using super value type. - typedef typename super_::value_ value_; - /*! \brief Constructor. * * \param[in] image Image subject to iteration. @@ -111,7 +108,7 @@ unsigned i_; /// reference pixel / point in the image - value_** value_ref_; + mln_qlf_value(I)** value_ref_; // or: const mln_point(I)* p_ref_; Index: mln/core/internal/pixel_impl.hh --- mln/core/internal/pixel_impl.hh (revision 1034) +++ mln/core/internal/pixel_impl.hh (working copy) @@ -53,6 +53,9 @@ { public: + /// Image type. + typedef I image; + /// Image value type. typedef mln_value(I) value; @@ -62,9 +65,6 @@ /// Image rvalue type. typedef mln_rvalue(I) rvalue; - /// Qualified value type. - typedef value value_; - /// pixel iterator value. lvalue operator*(); @@ -102,15 +102,15 @@ { public: + /// Image type. + typedef const I image; + /// Image value type. typedef mln_value(I) value; /// Image rvalue type. typedef mln_rvalue(I) rvalue; - /// Qualified value type. - typedef const value value_; - /// Get the pixel iterator value. rvalue operator*() const; Index: mln/core/internal/pixel_iterator_base.hh --- mln/core/internal/pixel_iterator_base.hh (revision 1034) +++ mln/core/internal/pixel_iterator_base.hh (working copy) @@ -35,6 +35,7 @@ # include <mln/core/concept/pixel_iterator.hh> # include <mln/core/internal/pixel_impl.hh> +# include <mln/core/trait/qlf_value.hh> namespace mln @@ -44,21 +45,6 @@ { - template <typename I> - struct qualified_value - { - typedef mln_value(I) ret; - }; - - - template <typename I> - struct qualified_value< const I > - { - typedef const mln_value(I) ret; - }; - - - /*! \brief A base class for pixel iterators. * */ @@ -79,16 +65,13 @@ /// Test if the iterator is valid. bool is_valid() const; - /// Qualified (const or not) value type. - typedef typename qualified_value::ret value_; - protected: /// Beginning of the image. - value_* boi_; + mln_qlf_value(I)* boi_; /// End of the image (past-the-end). - value_* eoi_; + mln_qlf_value(I)* eoi_; /// Constructor. pixel_iterator_base_(I& image); Index: mln/core/concept/generalized_pixel.hh --- mln/core/concept/generalized_pixel.hh (revision 1034) +++ mln/core/concept/generalized_pixel.hh (working copy) @@ -35,6 +35,7 @@ # include <mln/core/concept/object.hh> # include <mln/core/internal/force_exact.hh> +# include <mln/core/trait/qlf_value.hh> namespace mln @@ -52,6 +53,8 @@ * * \see mln::doc::Generalized_Pixel for a complete documentation of this * class contents. + * + * \todo (later) Add an access to the targetted image. */ template <typename E> struct Generalized_Pixel @@ -59,9 +62,10 @@ /* typedef value; typedef rvalue; + typedef image; rvalue operator*() const; - value** address_() const; + mln_qlf_value(image)** address_() const; */ protected: Generalized_Pixel(); @@ -75,11 +79,14 @@ { typedef mln_value(E) value; typedef mln_rvalue(E) rvalue; + rvalue (E::*m1)() const = & E::operator*; m1 = 0; - // FIXME: Activate (so add qualif_value): -// value** (E::*m2)() const = & E::address_; -// m2 = 0; + + typedef mln_image(E) image; + + mln_qlf_value(image)** (E::*m2)() const = & E::address_; + m2 = 0; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/concept/fast_image.hh --- mln/core/concept/fast_image.hh (revision 1034) +++ mln/core/concept/fast_image.hh (working copy) @@ -33,6 +33,8 @@ */ # include <mln/core/concept/image.hh> +# include <mln/core/concept/generalized_point.hh> +# include <mln/core/trait/qlf_value.hh> namespace mln @@ -50,15 +52,28 @@ unsigned border(); int offset(const dpoint& dp) const; - unsigned offset(const point& p) const; point point_at_offset(unsigned o) const; + mln_qlf_value(E)* buffer(); const value* buffer() const; rvalue operator[](unsigned o) const; lvalue operator[](unsigned o); */ + + /*! \brief Give the offset of the point \p p. + * + * \param[in] p A generalized point. + * + * \warning This method is final. + * + * \pre The image has to be initialized and to own the point \p p. + * \post p = point_at_offset(result) + */ + template <typename P> + unsigned offset(const Generalized_Point& p) const; + protected: Fast_Image(); }; @@ -67,6 +82,22 @@ # ifndef MLN_INCLUDE_ONLY template <typename E> + template <typename P> + unsigned + Fast_Image<E>::offset(const Generalized_Point& p_) const + { + // FIXME: check that P is mln_point(E) + const E& this_ = exact(this); + const P& p = internal::force_exact(p_); + mln_precondition(this_->has_data()); + mln_precondition(this_->owns_(p)); + + unsigned o = & this_->operator()(p) - this_->buffer(); + mln_postcondition(p = this_->point_at_offset(o)); + return o; + } + + template <typename E> Fast_Image<E>::Fast_Image() { typedef mln_point(E) point; @@ -77,15 +108,15 @@ int (E::*m1)(const dpoint&) const = & E::offset; m1 = 0; - unsigned (E::*m2)(const point&) const = & E::offset; + point (E::*m2)(unsigned) const = & E::point_at_offset; m2 = 0; - point (E::*m3)(unsigned) const = & E::point_at_offset; + unsigned (E::*m3)() const = & E::border; m3 = 0; - unsigned (E::*m4)() const = & E::border; - m4 = 0; typedef mln_value(E) value; + mln_qlf_value(E)* (E::*m4)() = & E::buffer; + m4 = 0; const value* (E::*m5)() const = & E::buffer; m5 = 0; Index: mln/core/concept/doc/generalized_pixel.hh --- mln/core/concept/doc/generalized_pixel.hh (revision 1034) +++ mln/core/concept/doc/generalized_pixel.hh (working copy) @@ -47,6 +47,9 @@ struct Generalized_Pixel { + /// Image associated type (with possible const qualification). + typedef void image; + /// Value associated type. typedef void value; @@ -67,7 +70,7 @@ * * \return A pointer to the value address. */ - value** address_() const; + mln_qlf_value(ima)** address_() const; protected: Generalized_Pixel(); Index: mln/core/concept/doc/fast_image.hh --- mln/core/concept/doc/fast_image.hh (revision 1034) +++ mln/core/concept/doc/fast_image.hh (working copy) @@ -58,15 +58,6 @@ int offset(const dpoint& dp); - /*! \brief Give the offset of the point \p p. - * - * \param[in] p A point. - * - * \pre The image has to own the point \p p. - */ - unsigned offset(const point& p); - - /*! \brief Give the point at offset \p o. * * \param[in] o An offset. Index: mln/core/image2d_b.hh --- mln/core/image2d_b.hh (revision 1034) +++ mln/core/image2d_b.hh (working copy) @@ -192,15 +192,15 @@ /// Give the offset corresponding to the delta-point \p dp. int offset(const dpoint2d& dp) const; - /// Give the offset corresponding to the point \p p. - unsigned offset(const point2d& p) const; - /// Give the point corresponding to the offset \p o. point2d point_at_offset(unsigned o) const; /// Give a hook to the value buffer. const T* buffer() const; + /// Give a hook to the value buffer. + T* buffer(); + private: @@ -411,21 +411,19 @@ } template <typename T> - int - image2d_b<T>::offset(const dpoint2d& dp) const + T* + image2d_b<T>::buffer() { mln_precondition(this->has_data()); - int o = dp[0] * vb_.len(1) + dp[1]; - return o; + return buffer_; } template <typename T> - unsigned - image2d_b<T>::offset(const point2d& p) const + int + image2d_b<T>::offset(const dpoint2d& dp) const { - mln_precondition(this->owns_(p)); - unsigned o = & this->operator()(p) - this->buffer_; - mln_postcondition(p = point_at_offset(o)); + mln_precondition(this->has_data()); + int o = dp[0] * vb_.len(1) + dp[1]; return o; } Index: mln/level/assign.hh --- mln/level/assign.hh (revision 1034) +++ mln/level/assign.hh (working copy) @@ -44,7 +44,7 @@ /*! Assignment of image \p target with image \p data. * - * \param[out] output The image to be assigned. + * \param[out] target The image to be assigned. * \param[in] data The auxiliary image. * * \pre target.domain = data.domain Index: mln/value/cast.hh --- mln/value/cast.hh (revision 1034) +++ mln/value/cast.hh (working copy) @@ -84,8 +84,8 @@ /// Read-only access of pixel value at point site \p p. T operator()(const psite& p) const; - /// Read-write access of pixel value at point site \p p. - void operator()(const psite& p); + /// Read-write access is present but disabled. + void operator()(const psite&); /// Give the set of values of the image. const vset& values() const; @@ -153,7 +153,7 @@ template <typename T, typename I> void - cast_image<T,I>::operator()(const psite& p) + cast_image<T,I>::operator()(const psite&) { mln_invariant(0); // FIXME: Turn into a compile-time error... }

17 years, 5 months

1034: Add some morphers and handle constness in pixterators.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add some morphers and handle constness in pixterators. Add new morphers. * tests/cast_image.cc: New. * tests/assign.cc: New. * tests/fimage.cc: New. * mln/core/fimage.hh: New. * mln/level/assign.hh: New. * mln/value/cast.hh: New. * mln/core/safe.hh: Rename as... * mln/core/safe_image.hh: ...this. * tests/safe_image.cc: Update. * mln/core/vec.hh: Rename as... * mln/metal/vec.hh: ...this. Handle constness in pixel iterators. * mln/core/internal/pixel_impl.hh (value_): New. (address): Update. * mln/core/internal/pixel_iterator_base.hh (qualified_value, value_): New. * mln/core/pixter2d_b.hh (value_): Update. * mln/core/dpoints_pixter.hh (value_): Update. * mln/core/internal/image_adaptor.hh (vset, values): Fix missing. * mln/core/concept/generalized_pixel.hh (ctor): Comment check on address. * mln/core/concept/pixel_iterator.hh (ctor): Comment check on lvalue and op*. * mln/core/concept/fast_image.hh (offset): Fix missing const. * mln/core/image2d_b.hh: Likewise. * mln/core/concept/doc/image.hh: Cosmetic changes. * mln/level/fast_median.hh (input): Update. * TODO: Update. TODO | 2 mln/core/concept/doc/image.hh | 2 mln/core/concept/fast_image.hh | 8 - mln/core/concept/generalized_pixel.hh | 5 mln/core/concept/pixel_iterator.hh | 9 - mln/core/dpoints_pixter.hh | 10 - mln/core/fimage.hh | 170 ++++++++++++++++++++++++++++++ mln/core/image2d_b.hh | 14 +- mln/core/internal/image_adaptor.hh | 16 ++ mln/core/internal/pixel_impl.hh | 12 +- mln/core/internal/pixel_iterator_base.hh | 20 +++ mln/core/pixter2d_b.hh | 3 mln/core/safe.hh | 7 - mln/level/assign.hh | 103 ++++++++++++++++++ mln/level/fast_median.hh | 10 - mln/metal/vec.hh | 11 + mln/value/cast.hh | 175 +++++++++++++++++++++++++++++++ tests/assign.cc | 48 ++++++++ tests/cast_image.cc | 48 ++++++++ tests/fimage.cc | 44 +++++++ tests/safe_image.cc | 2 21 files changed, 681 insertions(+), 38 deletions(-) Index: tests/cast_image.cc --- tests/cast_image.cc (revision 0) +++ tests/cast_image.cc (revision 0) @@ -0,0 +1,48 @@ +// 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/cast_image.cc + * + * \brief Tests on mln::value::cast_image. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/fun/chess.hh> +#include <mln/level/fill.hh> +#include <mln/debug/println.hh> +#include <mln/value/cast.hh> + + +int main() +{ + using namespace mln; + + image2d_b<bool> ima(8, 8); + level::fill(ima, fun::chess); + debug::println(ima); + debug::println( value::cast<int>(ima) ); +} Index: tests/safe_image.cc --- tests/safe_image.cc (revision 1033) +++ tests/safe_image.cc (working copy) @@ -31,7 +31,7 @@ */ #include <mln/core/image2d_b.hh> -#include <mln/core/safe_image.hh> +#include <mln/core/safe.hh> #include <mln/level/paste.hh> Index: tests/assign.cc --- tests/assign.cc (revision 0) +++ tests/assign.cc (revision 0) @@ -0,0 +1,48 @@ +// 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/assign.cc + * + * \brief Tests on mln::level::assign. + */ + +#include <mln/core/image2d_b.hh> +#include <mln/level/assign.hh> +#include <mln/level/compare.hh> +#include <mln/debug/iota.hh> + + +int main() +{ + using namespace mln; + + const unsigned size = 1000; + image2d_b<int> rhs(size, size), lhs(rhs.domain()); + debug::iota(rhs); + level::assign(lhs, rhs); + mln_assertion(lhs = rhs); +} Index: tests/fimage.cc --- tests/fimage.cc (revision 0) +++ tests/fimage.cc (revision 0) @@ -0,0 +1,44 @@ +// 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/fimage.cc + * + * \brief Tests on mln::fimage. + */ + +#include <mln/core/fimage.hh> +#include <mln/core/box2d.hh> +#include <mln/fun/chess.hh> +#include <mln/debug/println.hh> + + +int main() +{ + using namespace mln; + + debug::println( fun::chess | make::box2d(8, 8) ); +} Index: TODO --- TODO (revision 1033) +++ TODO (working copy) @@ -17,7 +17,6 @@ value::proxy to dispatch read/write + the corresponding image type a mean_value object { sum; count } and operator+ -value_cast<T>(image) t_image to "transpose" the 0 and the i-th coordinates image defined by f/pset @@ -45,6 +44,5 @@ fast versions of level::fill and level::paste histogram class sorting points w.r.t. their value (array of offsets, psites, points) -border::* and no-op versions if not fast image arith::inplace_plus et al. linear:: for convolutions Index: mln/core/fimage.hh --- mln/core/fimage.hh (revision 0) +++ mln/core/fimage.hh (revision 0) @@ -0,0 +1,170 @@ +// 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_CORE_FIMAGE_HH +# define MLN_CORE_FIMAGE_HH + +/*! \file mln/core/fimage.hh + * + * \brief Definition of an image class FIXME + */ + +# include <mln/core/internal/image_base.hh> +# include <mln/core/concept/function.hh> +# include <mln/value/set.hh> + + +namespace mln +{ + + /*! \brief FIXME + * + */ + template <typename F, typename S> + struct fimage : public internal::image_base_< S, fimage<F,S> > + { + /// Point_Site associated type. + typedef mln_psite(S) psite; + + /// Point_Set associated type. + typedef S pset; + + /// Value associated type. + typedef mln_result(F) value; + + /// Return type of read-only access. + typedef mln_result(F) rvalue; + + /// Return type of read-write access. + typedef void lvalue; // FIXME + + /// Value set associated type. + typedef mln::value::set_<mln_result(F)> vset; + + + /// Constructor. + fimage(const Function_p2v<F>& f, const Point_Set<S>& ps); + + + /// Test if this image has been initialized. + bool has_data() const; + + /// Test if a pixel value is accessible at \p p. + bool owns_(const psite& p) const; + + /// Give the definition domain. + const S& domain() const; + + /// Read-only access of pixel value at point site \p p. + mln_result(F) operator()(const psite& p) const; + + /// Read-write access of pixel value at point site \p p. + void operator()(const psite& p); + + /// Give the set of values of the image. + const vset& values() const; + + /// Change value type. FIXME! + template <typename U> + struct change_value + { + typedef void ret; + }; + + protected: + F f_; + S pset_; + }; + + + + template <typename F, typename S> + fimage<F,S> + operator | (const Function_p2v<F>& f, const Point_Set<S>& ps) + { + fimage<F,S> tmp(f, ps); + return tmp; + } + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename F, typename S> + fimage<F,S>::fimage(const Function_p2v<F>& f, const Point_Set<S>& ps) + : f_(exact(f)), + pset_(exact(ps)) + { + } + + template <typename F, typename S> + bool fimage<F,S>::has_data() const + { + return true; + } + + template <typename F, typename S> + bool fimage<F,S>::owns_(const psite& p) const + { + return pset_.has(p); + } + + template <typename F, typename S> + const S& + fimage<F,S>::domain() const + { + return pset_; + } + + template <typename F, typename S> + mln_result(F) + fimage<F,S>::operator()(const psite& p) const + { + mln_precondition(pset_.has(p)); + return f_(p); + } + + template <typename F, typename S> + void + fimage<F,S>::operator()(const psite& p) + { + mln_invariant(0); // FIXME: Turn into a compile-time error... + } + + template <typename F, typename S> + const mln::value::set_<mln_result(F)>& + fimage<F,S>::values() const + { + return vset::the(); + } + +# endif // ! MLN_INCLUDE_ONLY + +} // end of namespace mln + + +#endif // ! MLN_CORE_FIMAGE_HH Index: mln/core/pixter2d_b.hh --- mln/core/pixter2d_b.hh (revision 1033) +++ mln/core/pixter2d_b.hh (working copy) @@ -45,7 +45,8 @@ class fwd_pixter2d_b : public internal::pixel_iterator_base_< I, fwd_pixter2d_b > { typedef internal::pixel_iterator_base_< I, fwd_pixter2d_b > super_; - typedef mln_value(super_) value_; + typedef typename super_::value_ value_; + public: /*! \brief Constructor. Index: mln/core/dpoints_pixter.hh --- mln/core/dpoints_pixter.hh (revision 1033) +++ mln/core/dpoints_pixter.hh (working copy) @@ -55,11 +55,11 @@ class dpoints_fwd_pixter : public Pixel_Iterator< dpoints_fwd_pixter >, public internal::pixel_impl_< I, dpoints_fwd_pixter > { - typedef typename internal::pixel_impl_< I, dpoints_fwd_pixter > super; + typedef typename internal::pixel_impl_< I, dpoints_fwd_pixter > super_; public: /// Using super value type. - typedef mln_value(super) value; + typedef typename super_::value_ value_; /*! \brief Constructor. * @@ -111,7 +111,7 @@ unsigned i_; /// reference pixel / point in the image - value** value_ref_; + value_** value_ref_; // or: const mln_point(I)* p_ref_; @@ -135,7 +135,7 @@ dpoints_fwd_pixter::dpoints_fwd_pixter(I& image, const Dps& dps, const Generalized_Point<Pref>& p_ref) - : super(image) + : super_(image) { mln_precondition(image.has_data()); p_ref_ = internal::force_exact<Pref>(p_ref).pointer_(); @@ -149,7 +149,7 @@ dpoints_fwd_pixter::dpoints_fwd_pixter(I& image, const Dps& dps, const Generalized_Pixel<Pref>& p_ref) - : super(image) + : super_(image) { mln_precondition(image.has_data()); p_ref_ = 0; Index: mln/core/internal/pixel_impl.hh --- mln/core/internal/pixel_impl.hh (revision 1033) +++ mln/core/internal/pixel_impl.hh (working copy) @@ -62,6 +62,9 @@ /// Image rvalue type. typedef mln_rvalue(I) rvalue; + /// Qualified value type. + typedef value value_; + /// pixel iterator value. lvalue operator*(); @@ -105,13 +108,16 @@ /// Image rvalue type. typedef mln_rvalue(I) rvalue; + /// Qualified value type. + typedef const value value_; + /// Get the pixel iterator value. rvalue operator*() const; /// Address of the current iterator value/pixel. - value** address_() const; + const value** address_() const; protected: @@ -197,11 +203,11 @@ } template <typename I, typename E> - mln_value(I) ** + const mln_value(I) ** pixel_impl_<const I, E>::address_() const { mln_precondition(is_valid_()); - return (value**)(& this->value_ptr_); + return (const value**)(& this->value_ptr_); } #endif // ! MLN_INCLUDE_ONLY Index: mln/core/internal/pixel_iterator_base.hh --- mln/core/internal/pixel_iterator_base.hh (revision 1033) +++ mln/core/internal/pixel_iterator_base.hh (working copy) @@ -43,6 +43,22 @@ namespace internal { + + template <typename I> + struct qualified_value + { + typedef mln_value(I) ret; + }; + + + template <typename I> + struct qualified_value< const I > + { + typedef const mln_value(I) ret; + }; + + + /*! \brief A base class for pixel iterators. * */ @@ -51,7 +67,6 @@ public internal::pixel_impl_<I, E> { typedef internal::pixel_impl_<I, E> super_; - typedef mln_value(super_) value_; public: @@ -64,6 +79,9 @@ /// Test if the iterator is valid. bool is_valid() const; + /// Qualified (const or not) value type. + typedef typename qualified_value::ret value_; + protected: /// Beginning of the image. Index: mln/core/internal/image_adaptor.hh --- mln/core/internal/image_adaptor.hh (revision 1033) +++ mln/core/internal/image_adaptor.hh (working copy) @@ -51,12 +51,16 @@ typename S = mln_pset(I) > struct image_adaptor_ : public internal::image_base_< S, E > { + /// Point_Site associated type. typedef mln_psite(S) psite; /// Point_Set associated type. typedef S pset; + /// Value_Set associated type. + typedef mln_vset(I) vset; + /// Value associated type. typedef mln_value(I) value; @@ -66,6 +70,7 @@ /// Return type of read-write access. typedef mln_lvalue(I) lvalue; + /// Test if this image has been initialized. bool has_data() const; @@ -75,12 +80,16 @@ /// Give the definition domain. const S& domain() const; + /// Give the set of values. + const vset& values() const; + /// Read-only access of pixel value at point site \p p. rvalue operator()(const psite& p) const; /// Read-write access of pixel value at point site \p p. lvalue operator()(const psite& p); + protected: I& adaptee_; @@ -116,6 +125,13 @@ } template <typename I, typename E, typename S> + const mln_vset(I)& + image_adaptor_<I,E,S>::values() const + { + return adaptee_.values(); + } + + template <typename I, typename E, typename S> typename image_adaptor_<I,E,S>::rvalue image_adaptor_<I,E,S>::operator()(const psite& p) const { Index: mln/core/safe.hh --- mln/core/safe.hh (revision 1031) +++ mln/core/safe.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_CORE_SAFE_IMAGE_HH -# define MLN_CORE_SAFE_IMAGE_HH +#ifndef MLN_CORE_SAFE_HH +# define MLN_CORE_SAFE_HH # include <mln/core/internal/image_adaptor.hh> @@ -34,6 +34,7 @@ namespace mln { + // FIXME: Doc! template <typename I> struct safe_image : public internal::image_adaptor_< I, safe_image > @@ -100,4 +101,4 @@ } // end of namespace mln -#endif // ! MLN_CORE_SAFE_IMAGE_HH +#endif // ! MLN_CORE_SAFE_HH Index: mln/core/concept/generalized_pixel.hh --- mln/core/concept/generalized_pixel.hh (revision 1033) +++ mln/core/concept/generalized_pixel.hh (working copy) @@ -77,8 +77,9 @@ typedef mln_rvalue(E) rvalue; rvalue (E::*m1)() const = & E::operator*; m1 = 0; - value** (E::*m2)() const = & E::address_; - m2 = 0; + // FIXME: Activate (so add qualif_value): +// value** (E::*m2)() const = & E::address_; +// m2 = 0; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/concept/pixel_iterator.hh --- mln/core/concept/pixel_iterator.hh (revision 1033) +++ mln/core/concept/pixel_iterator.hh (working copy) @@ -54,8 +54,9 @@ public Generalized_Pixel<E> { /* - typedef lvalue; + only if the iterator is constructed on a mutable image: + typedef lvalue; lvalue operator*(); */ protected: @@ -68,9 +69,9 @@ template <typename E> Pixel_Iterator<E>::Pixel_Iterator() { - typedef mln_lvalue(E) lvalue; - lvalue (E::*m)() = & E::operator*; - m = 0; +// typedef mln_lvalue(E) lvalue; +// lvalue (E::*m)() = & E::operator*; +// m = 0; } #endif // ! MLN_INCLUDE_ONLY Index: mln/core/concept/fast_image.hh --- mln/core/concept/fast_image.hh (revision 1033) +++ mln/core/concept/fast_image.hh (working copy) @@ -49,8 +49,8 @@ /* unsigned border(); - int offset(const dpoint& dp); - unsigned offset(const point& p); + int offset(const dpoint& dp) const; + unsigned offset(const point& p) const; point point_at_offset(unsigned o) const; const value* buffer() const; @@ -75,9 +75,9 @@ typedef mln_fwd_pixter(E) fwd_pixter; typedef mln_bkd_pixter(E) bkd_pixter; - int (E::*m1)(const dpoint&) = & E::offset; + int (E::*m1)(const dpoint&) const = & E::offset; m1 = 0; - unsigned (E::*m2)(const point&) = & E::offset; + unsigned (E::*m2)(const point&) const = & E::offset; m2 = 0; point (E::*m3)(unsigned) const = & E::point_at_offset; m3 = 0; Index: mln/core/concept/doc/image.hh --- mln/core/concept/doc/image.hh (revision 1033) +++ mln/core/concept/doc/image.hh (working copy) @@ -41,6 +41,7 @@ template <typename E> struct Image : public Object<E> { + /*! \brief Value associated type. * * \invariant This type is neither qualified by const, nor by @@ -61,6 +62,7 @@ */ typedef void vset; + /*! \brief Test if the image have been initialized. */ bool has_data() const; Index: mln/core/image2d_b.hh --- mln/core/image2d_b.hh (revision 1033) +++ mln/core/image2d_b.hh (working copy) @@ -190,10 +190,10 @@ /// Fast Image method /// Give the offset corresponding to the delta-point \p dp. - int offset(const dpoint2d& dp); + int offset(const dpoint2d& dp) const; /// Give the offset corresponding to the point \p p. - unsigned offset(const point2d& p); + unsigned offset(const point2d& p) const; /// Give the point corresponding to the offset \p o. point2d point_at_offset(unsigned o) const; @@ -412,7 +412,7 @@ template <typename T> int - image2d_b<T>::offset(const dpoint2d& dp) + image2d_b<T>::offset(const dpoint2d& dp) const { mln_precondition(this->has_data()); int o = dp[0] * vb_.len(1) + dp[1]; @@ -421,7 +421,7 @@ template <typename T> unsigned - image2d_b<T>::offset(const point2d& p) + image2d_b<T>::offset(const point2d& p) const { mln_precondition(this->owns_(p)); unsigned o = & this->operator()(p) - this->buffer_; @@ -535,6 +535,12 @@ }; template <typename T, typename W> + struct fwd_qixter< const image2d_b<T>, W > + { + typedef dpoints_fwd_pixter< const image2d_b<T> > ret; + }; + + template <typename T, typename W> struct bkd_qixter< image2d_b<T>, W > { typedef internal::fixme ret; Index: mln/metal/vec.hh --- mln/metal/vec.hh (revision 1031) +++ mln/metal/vec.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_CORE_VEC_HH -# define MLN_CORE_VEC_HH +#ifndef MLN_CORE_METAL_VEC_HH +# define MLN_CORE_METAL_VEC_HH # include <mln/core/concept/object.hh> @@ -34,6 +34,9 @@ namespace mln { + namespace metal + { + template <unsigned n, typename T> struct vec : public Object< vec<n,T> > { @@ -56,7 +59,9 @@ T coord_[n]; }; + } // end of namespace mln::metal + } // end of namespace mln -#endif // ! MLN_CORE_VEC_HH +#endif // ! MLN_CORE_METAL_VEC_HH Index: mln/level/assign.hh --- mln/level/assign.hh (revision 0) +++ mln/level/assign.hh (revision 0) @@ -0,0 +1,103 @@ +// 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_LEVEL_ASSIGN_HH +# define MLN_LEVEL_ASSIGN_HH + +/*! \file mln/level/assign.hh + * + * \brief Assignment between a couple of images. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace level + { + + /*! Assignment of image \p target with image \p data. + * + * \param[out] output The image to be assigned. + * \param[in] data The auxiliary image. + * + * \pre target.domain = data.domain + * + * \todo Overload in impl:: for mixed (fast, non-fast). + * + * \todo Overload in impl:: for (fast, fast) if same value using memcpy. + */ + template <typename L, typename R> + void assign(Image<L>& target, const Image<R>& data); + + +# ifndef MLN_INCLUDE_ONLY + + namespace impl + { + + template <typename L, typename R> + void assign(Image<L>& target_, const Image<R>& data_) + { + L& target = exact(target_); + const R& data = exact(data_); + mln_piter(L) p(target.domain()); + for_all(p) + target(p) = data(p); + } + + template <typename L, typename R> + void assign(Fast_Image<L>& target_, const Fast_Image<R>& data_) + { + L& target = exact(target_); + const R& data = exact(data_); + mln_pixter(L) lhs(target); + mln_pixter(const R) rhs(data); + for_all_2(lhs, rhs) + *lhs = *rhs; + } + + } // end of namespace mln::level::impl + + + template <typename L, typename R> + void assign(Image<L>& target, const Image<R>& data) + { + mln_precondition(exact(data).domain() = exact(target).domain()); + impl::assign(exact(target), exact(data)); + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::level + +} // end of namespace mln + + +#endif // ! MLN_LEVEL_ASSIGN_HH Index: mln/level/fast_median.hh --- mln/level/fast_median.hh (revision 1033) +++ mln/level/fast_median.hh (working copy) @@ -54,7 +54,7 @@ * \pre \p input and \p output have to be initialized. */ template <typename I, typename W, typename O> - void fast_median(Image& input, const Window<W>& win, + void fast_median(const Image& input, const Window<W>& win, Image<O>& output); @@ -65,7 +65,7 @@ { template <typename I, typename W, typename O> - void fast_median(I& input, + void fast_median(const I& input, const W& win, O& output) { @@ -90,14 +90,14 @@ point2d p = input.domain().pmin() + up; - mln_qixter(I, window2d) + mln_qixter(const I, window2d) q_fp(input, win_fwd_plus, p), q_fm(input, win_fwd_minus, p), q_bp(input, win_bkd_plus, p), q_bm(input, win_bkd_minus, p), q_top(input, win_top, p), q_bot(input, win_bot, p); med.init(); { - mln_qixter(I, W) q(input, win, p); + mln_qixter(const I, W) q(input, win, p); for_all(q) med.take(*q); } @@ -154,7 +154,7 @@ // facade template <typename I, typename W, typename O> - void fast_median(Image& input, const Window<W>& win, + void fast_median(const Image& input, const Window<W>& win, Image<O>& output) { impl::fast_median(exact(input), exact(win), exact(output)); Index: mln/value/cast.hh --- mln/value/cast.hh (revision 0) +++ mln/value/cast.hh (revision 0) @@ -0,0 +1,175 @@ +// 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 an image class FIXME + */ + +# include <mln/core/concept/image.hh> +# include <mln/value/set.hh> + + +namespace mln +{ + + namespace value + { + + /*! \brief FIXME + * + */ + template <typename T, typename I> + struct cast_image : public internal::image_base_< mln_pset(I), cast_image<T,I> > + { + /// Point_Site associated type. + typedef mln_psite(I) psite; + + /// Point_Set associated type. + typedef mln_pset(I) pset; + + /// Value associated type. + typedef T value; + + /// Return type of read-only access. + typedef T rvalue; + + /// Return type of read-write access. + typedef void lvalue; // FIXME + + /// Value set associated type. + typedef mln::value::set_<T> vset; + + + /// Constructor. + cast_image(const Image& ima); + + + /// Test if this image has been initialized. + bool has_data() const; + + /// Test if a pixel value is accessible at \p p. + bool owns_(const psite& p) const; + + /// Give the definition domain. + const mln_pset(I)& domain() const; + + /// Read-only access of pixel value at point site \p p. + T operator()(const psite& p) const; + + /// Read-write access of pixel value at point site \p p. + void operator()(const psite& p); + + /// Give the set of values of the image. + const vset& values() const; + + /// Change value type. + template <typename U> + struct change_value + { + typedef mln_ch_value(I, U) ret; + }; + + protected: + const I& ima_; + }; + + + + template <typename T, typename I> + cast_image<T,I> + cast(const Image& ima) + { + mln_precondition(exact(ima).has_data()); + cast_image<T,I> tmp(ima); + return tmp; + } + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename T, typename I> + 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 + { + mln_invariant(ima_.has_data()); + return true; + } + + template <typename T, typename I> + 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 + { + return ima_.domain(); + } + + template <typename T, typename I> + T + cast_image<T,I>::operator()(const psite& p) const + { + mln_precondition(ima_.owns_(p)); + return ima_(p); + } + + template <typename T, typename I> + void + cast_image<T,I>::operator()(const psite& p) + { + mln_invariant(0); // FIXME: Turn into a compile-time error... + } + + template <typename T, typename I> + const mln::value::set_<T>& + 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

17 years, 5 months

1033: Configure new Makefiles.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Configure new Makefiles. * configure.ac (static/samples/mini-std/Makefile) (static/samples/mini-std/cpp/Makefile) (static/samples/mini-std/cpp2/Makefile): Configure them. configure.ac | 3 +++ 1 file changed, 3 insertions(+) Index: configure.ac --- configure.ac (revision 1032) +++ configure.ac (working copy) @@ -85,6 +85,9 @@ static/samples/Makefile static/samples/mini-oln/Makefile static/samples/mini-oln/concept-c++/Makefile + static/samples/mini-std/Makefile + static/samples/mini-std/cpp/Makefile + static/samples/mini-std/cpp2/Makefile milena/Makefile milena/doc/Makefile olena/Makefile

17 years, 5 months

1032: Adjust samples to the new interface of Static.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Adjust samples to the new interface of Static. * samples/mini-std/cpp/equipment.hh: No longer use stc_scoop_equipment_for_namespace. Include stc/scoop.hxx instead. Rename template parameters `E' to `Exact'. (stc_using, stc_using_from): Remove macros. * samples/mini-std/cpp/impl.hh: (morpher_container, primary_container): Adjust callers of stc_using_from. (morpher_container::delegatee): Rename methods as... (morpher_container::delegatee_): ...these. Adjust callers. * samples/mini-std/cpp/stack.hh, * samples/mini-std/cpp/value_cast.hh (impl_delegatee): Rename methods as... (impl_delegatee_): ...these. * samples/mini-std/cpp/concepts.hh, * samples/mini-std/cpp/impl.hh, * samples/mini-std/cpp/list.hh, * samples/mini-std/cpp/vector.hh, * samples/mini-std/cpp/deque.hh, * samples/mini-std/cpp/stack.hh, * samples/mini-std/cpp/value_cast.hh, * samples/mini-std/cpp/identity.hh, * samples/mini-std/cpp/fwddecls.hh Remove the `_type' suffix from all virtual types. Remove virtual types named `super_type' and replace them with a `super_trait_' class. Rename template parameters `E' to `Exact'. * samples/mini-oln/mini-oln.cc: Likewise. s/set_super_type/super_trait_/. * samples/mini-std/cpp2/mini-std.cc (LOGGER_BEGIN, LOGMETHODVOID, LOGMETHODARG, LOGGER_END): Wrap long lines in macros. (LOGMETHOD): Likewise. Add a space after the printed location. * samples/mini-std/Makefile.am, * samples/mini-std/cpp/Makefile.am: New. * samples/mini-std/cpp2/Makefile: Rename as... * samples/mini-std/cpp2/Makefile.am: ...this. (CPPFLAGS, .PHONY): Remove variables. (all, mini-std): Remove targets. (AM_CPPFLAGS, TESTS_CXXFLAGS, AM_CXXFLAGS) (check_PROGRAMS, mini_std_SOURCES, TESTS): New variables. * samples/Makefile.am (SUBDIRS): Add mini-std. Makefile.am | 2 mini-oln/mini-oln.cc | 214 +++++++++++++++++++++++---------------------- mini-std/Makefile.am | 5 + mini-std/README | 2 mini-std/cpp/Makefile.am | 22 ++++ mini-std/cpp/concepts.hh | 104 ++++++++++----------- mini-std/cpp/deque.hh | 11 +- mini-std/cpp/equipment.hh | 31 +++--- mini-std/cpp/fwddecls.hh | 42 ++++---- mini-std/cpp/identity.hh | 92 +++++++++---------- mini-std/cpp/impl.hh | 129 +++++++++++++++------------ mini-std/cpp/list.hh | 9 + mini-std/cpp/stack.hh | 18 ++- mini-std/cpp/value_cast.hh | 17 ++- mini-std/cpp/vector.hh | 9 + mini-std/cpp2/Makefile.am | 19 +++ 16 files changed, 405 insertions(+), 321 deletions(-) Index: samples/mini-oln/mini-oln.cc --- samples/mini-oln/mini-oln.cc (revision 1031) +++ samples/mini-oln/mini-oln.cc (working copy) @@ -41,26 +41,25 @@ // Helper macros. #define oln_type_of_(FromType, Alias) \ - find_vtype<FromType, oln::typedef_:: Alias##_type>::ret + find_vtype<FromType, oln::typedef_:: Alias>::ret #define oln_type_of(FromType, Alias) \ typename oln_type_of_(FromType, Alias) -// Add equipment -stc_scoop_equipment_for_namespace(oln) +// Add equipment. mlc_case_equipment_for_namespace(oln); // Virtual types declaration. namespace oln { - mlc_decl_typedef(point_type); - mlc_decl_typedef(iter_type); - mlc_decl_typedef(value_type); - mlc_decl_typedef(rvalue_type); - mlc_decl_typedef(lvalue_type); + mlc_decl_typedef(point); + mlc_decl_typedef(iter); + mlc_decl_typedef(value); + mlc_decl_typedef(rvalue); + mlc_decl_typedef(lvalue); - mlc_decl_typedef(nbh_type); - mlc_decl_typedef(niter_type); + mlc_decl_typedef(nbh); + mlc_decl_typedef(niter); } @@ -70,12 +69,20 @@ namespace oln { + + // --------------------- // + // Namespace equipment. // + // --------------------- // + +#include <stc/scoop.hxx> + + // ------- // // Point. // // ------- // - template <typename E> - struct Point : public stc::any<E> + template <typename Exact> + struct Point : public stc::any<Exact> { }; @@ -84,10 +91,10 @@ // Iterator. // // ---------- // - template <typename E> - struct Iterator : public stc::any<E> + template <typename Exact> + struct Iterator : public stc::any<Exact> { - typedef oln_type_of(E, point) point_t; + typedef oln_type_of(Exact, point) point_t; void start() { @@ -116,11 +123,11 @@ // Image. // // ------- // - template <typename E> - struct Image : public stc::any<E> + template <typename Exact> + struct Image : public stc::any<Exact> { - typedef oln_type_of(E, point) point_t; - typedef oln_type_of(E, rvalue) rvalue_t; + typedef oln_type_of(Exact, point) point_t; + typedef oln_type_of(Exact, rvalue) rvalue_t; rvalue_t operator ()(point_t& p) const { @@ -138,14 +145,14 @@ // Image2d. // // --------- // - template <typename E> - struct Image2d : public virtual Image<E> + template <typename Exact> + struct Image2d : public virtual Image<Exact> { - typedef oln_type_of(E, point) point_t; + typedef oln_type_of(Exact, point) point_t; // inherited from Image - // typedef oln_type_of(E, rvalue) rvalue_t; + // typedef oln_type_of(Exact, rvalue) rvalue_t; // rvalue_t& operator ()(point_t& p) // { @@ -168,14 +175,14 @@ // Image3d. // // --------- // - template <typename E> - struct Image3d : public virtual Image<E> + template <typename Exact> + struct Image3d : public virtual Image<Exact> { - typedef oln_type_of(E, point) point_t; + typedef oln_type_of(Exact, point) point_t; // inherited from Image - // typedef oln_type_of(E, rvalue) rvalue_t; + // typedef oln_type_of(Exact, rvalue) rvalue_t; // rvalue_t& operator ()(point_t& p) // { @@ -203,11 +210,11 @@ // Mutable_Image // // ------------- // - template <typename E> - struct Mutable_Image : public virtual Image<E> + template <typename Exact> + struct Mutable_Image : public virtual Image<Exact> { - typedef oln_type_of(E, point) point_t; - typedef oln_type_of(E, lvalue) lvalue_t; + typedef oln_type_of(Exact, point) point_t; + typedef oln_type_of(Exact, lvalue) lvalue_t; lvalue_t operator ()(point_t& p) { @@ -220,11 +227,11 @@ // Image_with_neighborhood. // // ------------------------- // - template <typename E> - struct Image_with_neighborhood : public virtual Image<E> + template <typename Exact> + struct Image_with_neighborhood : public virtual Image<Exact> { - typedef oln_type_of(E, nbh) nbh_t; - typedef oln_type_of(E, niter) niter_t; + typedef oln_type_of(Exact, nbh) nbh_t; + typedef oln_type_of(Exact, niter) niter_t; nbh_t nbh() const { @@ -252,24 +259,24 @@ struct point2d; struct point3d; - template <typename E> - struct case_<switch_image_base, E, 1> : - public mlc::where_ < mlc::eq_ <oln_type_of(E, point), point2d> > + template <typename Exact> + struct case_<switch_image_base, Exact, 1> : + public mlc::where_ < mlc::eq_ <oln_type_of(Exact, point), point2d> > { - typedef Image2d<E> ret; + typedef Image2d<Exact> ret; }; - template <typename E> - struct case_<switch_image_base, E, 2> : - public mlc::where_ < mlc::eq_ <oln_type_of(E, point), point3d> > + template <typename Exact> + struct case_<switch_image_base, Exact, 2> : + public mlc::where_ < mlc::eq_ <oln_type_of(Exact, point), point3d> > { - typedef Image3d<E> ret; + typedef Image3d<Exact> ret; }; - template <typename E> - struct default_case_<switch_image_base, E> + template <typename Exact> + struct default_case_<switch_image_base, Exact> { - typedef Image<E> ret; + typedef Image<Exact> ret; }; // ----------------- // @@ -279,17 +286,17 @@ // Tag. struct switch_image_base_mutable; - template <typename E> - struct case_<switch_image_base_mutable, E, 1> : - public mlc::where_ < mlc::is_found_< stc_vtype(oln, E, lvalue) > > + template <typename Exact> + struct case_<switch_image_base_mutable, Exact, 1> : + public mlc::where_ < stc_type_is_found(lvalue) > { - typedef Mutable_Image<E> ret; + typedef Mutable_Image<Exact> ret; }; - template <typename E> - struct default_case_<switch_image_base_mutable, E> + template <typename Exact> + struct default_case_<switch_image_base_mutable, Exact> { - typedef Image<E> ret; + typedef Image<Exact> ret; }; // ------------ // @@ -297,30 +304,31 @@ // ------------ // // Forward declaration. - template <typename E> struct image_base; + template <typename Exact> struct image_base; - template<typename E> - struct set_super_type< image_base<E> > + template<typename Exact> + struct super_trait_< image_base<Exact> > { typedef mlc::none ret; }; - template <typename E> - struct vtypes< image_base<E> > + template <typename Exact> + struct vtypes< image_base<Exact> > { - typedef stc::abstract point_type; - typedef stc::abstract iter_type; - typedef stc::abstract value_type; - typedef stc::abstract rvalue_type; - typedef stc::abstract lvalue_type; - - typedef mlc::none niter_type; - typedef mlc::none nbh_type; - }; - - template <typename E> - struct image_base : public virtual switch_<switch_image_base, E>::ret, - public virtual switch_<switch_image_base_mutable, E>::ret + typedef stc::abstract point; + typedef stc::abstract iter; + typedef stc::abstract value; + typedef stc::abstract rvalue; + typedef stc::abstract lvalue; + + typedef mlc::none niter; + typedef mlc::none nbh; + }; + + template <typename Exact> + struct image_base : + public virtual switch_<switch_image_base, Exact>::ret, + public virtual switch_<switch_image_base_mutable, Exact>::ret { image_base() { @@ -363,7 +371,7 @@ template <typename T> struct image2d; template<> - struct set_super_type<iterator2d> + struct super_trait_<iterator2d> { typedef mlc::none ret; }; @@ -371,7 +379,7 @@ template <> struct vtypes<iterator2d> { - typedef point2d point_type; + typedef point2d point; }; struct iterator2d : public Iterator<iterator2d> @@ -427,7 +435,7 @@ template <typename T> struct image2d; template<typename T> - struct set_super_type< image2d<T> > + struct super_trait_< image2d<T> > { typedef image_base< image2d<T> > ret; }; @@ -435,11 +443,11 @@ template <typename T> struct vtypes< image2d<T> > { - typedef point2d point_type; - typedef iterator2d iter_type; - typedef T value_type; - typedef value_type rvalue_type; - typedef value_type& lvalue_type; + typedef point2d point; + typedef iterator2d iter; + typedef T value; + typedef value rvalue; + typedef value& lvalue; }; template <typename T> @@ -499,7 +507,7 @@ struct neighborhood2d { - typedef niter2d niter_type; + typedef niter2d niter; }; @@ -512,7 +520,7 @@ template <typename T> struct image3d; template<> - struct set_super_type<iterator3d> + struct super_trait_<iterator3d> { typedef mlc::none ret; }; @@ -520,7 +528,7 @@ template <> struct vtypes<iterator3d> { - typedef point3d point_type; + typedef point3d point; }; struct iterator3d : public Iterator<iterator3d> @@ -584,7 +592,7 @@ template <typename T> struct image3d; template<typename T> - struct set_super_type< image3d<T> > + struct super_trait_< image3d<T> > { typedef image_base< image3d<T> > ret; }; @@ -592,11 +600,11 @@ template <typename T> struct vtypes< image3d<T> > { - typedef point3d point_type; - typedef iterator3d iter_type; - typedef T value_type; - typedef value_type rvalue_type; - typedef value_type& lvalue_type; + typedef point3d point; + typedef iterator3d iter; + typedef T value; + typedef value rvalue; + typedef value& lvalue; }; template <typename T> @@ -665,7 +673,7 @@ struct neighborhood3d { - typedef niter3d niter_type; + typedef niter3d niter; }; @@ -674,24 +682,24 @@ // --------------- // // Forward declaration. - template <typename E> struct image_morpher; + template <typename Exact> struct image_morpher; - template<typename E> - struct set_super_type< image_morpher<E> > + template<typename Exact> + struct super_trait_< image_morpher<Exact> > { - typedef image_base<E> ret; + typedef image_base<Exact> ret; }; - template <typename E> - struct vtypes< image_morpher<E> > + template <typename Exact> + struct vtypes< image_morpher<Exact> > { - typedef stc::abstract delegatee_type; + typedef stc::abstract delegatee; }; - template <typename E> - struct image_morpher : public image_base<E> + template <typename Exact> + struct image_morpher : public image_base<Exact> { - typedef oln_type_of(E, delegatee) delegatee_t; + typedef oln_type_of(Exact, delegatee) delegatee_t; image_morpher(delegatee_t& ref_ima) : ref_ima (ref_ima) @@ -715,7 +723,7 @@ template <typename I, typename N> struct plus; template <typename I, typename N> - struct set_super_type< plus<I, N> > + struct super_trait_< plus<I, N> > { typedef image_morpher< plus <I, N> > ret; }; @@ -723,12 +731,12 @@ template <typename I, typename N> struct vtypes< plus<I, N> > { - typedef I delegatee_type; - typedef N nbh_type; + typedef I delegatee; + typedef N nbh; // For the sake of simplicity, the niter type is obtained directly // from the neighborhood type itself (without using a virtual // type). - typedef typename N::niter_type niter_type; + typedef typename N::niter niter; }; template <typename I, typename N> Index: samples/mini-std/cpp/impl.hh --- samples/mini-std/cpp/impl.hh (revision 1031) +++ samples/mini-std/cpp/impl.hh (working copy) @@ -14,25 +14,25 @@ { // front insertion - template <typename b, typename E> struct front_insertion_sequence; - template <typename E> struct front_insertion_sequence <mlc::true_, E> : virtual Front_Insertion_Sequence<E> {}; - template <typename E> struct front_insertion_sequence <mlc::false_, E> : virtual Sequence<E> {}; + template <typename b, typename Exact> struct front_insertion_sequence; + template <typename Exact> struct front_insertion_sequence <mlc::true_, Exact> : virtual Front_Insertion_Sequence<Exact> {}; + template <typename Exact> struct front_insertion_sequence <mlc::false_, Exact> : virtual Sequence<Exact> {}; // back insertion - template <typename b, typename E> struct back_insertion_sequence; - template <typename E> struct back_insertion_sequence <mlc::true_, E> : virtual Back_Insertion_Sequence<E> {}; - template <typename E> struct back_insertion_sequence <mlc::false_, E> : virtual Sequence<E> {}; + template <typename b, typename Exact> struct back_insertion_sequence; + template <typename Exact> struct back_insertion_sequence <mlc::true_, Exact> : virtual Back_Insertion_Sequence<Exact> {}; + template <typename Exact> struct back_insertion_sequence <mlc::false_, Exact> : virtual Sequence<Exact> {}; // random access - template <typename b, typename E> struct random_access_container; - template <typename E> struct random_access_container <mlc::true_, E> : virtual Random_Access_Container<E> {}; - template <typename E> struct random_access_container <mlc::false_, E> : virtual Container<E> {}; + template <typename b, typename Exact> struct random_access_container; + template <typename Exact> struct random_access_container <mlc::true_, Exact> : virtual Random_Access_Container<Exact> {}; + template <typename Exact> struct random_access_container <mlc::false_, Exact> : virtual Container<Exact> {}; - template <typename E> + template <typename Exact> struct container_switch - : front_insertion_sequence< abc_vtype(E, has_front_insertion), E >, - back_insertion_sequence < abc_vtype(E, has_back_insertion), E >, - random_access_container < abc_vtype(E, has_random_access), E > + : front_insertion_sequence< abc_vtype(Exact, has_front_insertion), Exact >, + back_insertion_sequence < abc_vtype(Exact, has_back_insertion), Exact >, + random_access_container < abc_vtype(Exact, has_random_access), Exact > { protected: container_switch() {} @@ -55,15 +55,19 @@ - // Class container_base<E>. + // Class container_base<Exact>. - template <typename E> class container_base; + template <typename Exact> class container_base; - template <typename E> - struct vtypes< container_base<E> > + template <typename Exact> + struct super_trait_< container_base<Exact> > { - typedef mlc::none super_type; + typedef mlc::none ret; + }; + template <typename Exact> + struct vtypes< container_base<Exact> > + { typedef stc::abstract value_type; typedef stc::abstract iterator; typedef stc::abstract const_iterator; @@ -78,39 +82,48 @@ typedef stc::abstract tag; }; - template <typename E> - class container_base : public internal::container_switch<E> + template <typename Exact> + class container_base : public internal::container_switch<Exact> { public: // FIXME: remove below. - typedef typename Back_Insertion_Sequence<E>::reference reference; - typedef typename Back_Insertion_Sequence<E>::const_reference const_reference; + typedef typename Back_Insertion_Sequence<Exact>::reference reference; + typedef typename Back_Insertion_Sequence<Exact>::const_reference const_reference; protected: container_base() {} }; - // Class morpher_container<E>. + // Class morpher_container<Exact>. + + template <typename Exact> class morpher_container; - template <typename E> class morpher_container; - template <typename E> - struct vtypes< morpher_container<E> > + template <typename Exact> + struct super_trait_< morpher_container<Exact> > + { + typedef container_base<Exact> ret; + }; + + template <typename Exact> + struct vtypes< morpher_container<Exact> > { - typedef container_base<E> super_type; - typedef stc::abstract delegatee_type; + typedef stc::abstract delegatee; }; - template <typename E> - class morpher_container : public container_base<E> + template <typename Exact> + class morpher_container : public container_base<Exact> { public: - stc_using_from(Container<E>, value_type); - abc_typename(delegatee_type); + stc_using_from(Container, value_type); + abc_typename(delegatee); - const delegatee_type& delegatee() const { return this->exact().impl_delegatee(); } - delegatee_type& delegatee() { return this->exact().impl_delegatee(); } + // FIXME: `delegatee_' and `impl_delegatee_' are not elegant + // names, but we cannot use `delegatee' (since it is a typedef in + // this class). Find better names. + const delegatee& delegatee_() const { return this->exact().impl_delegatee_(); } + delegatee& delegatee_() { return this->exact().impl_delegatee_(); } protected: morpher_container() {} @@ -118,36 +131,46 @@ - // Class primary_container<E>. + // Class primary_container<Exact>. - template <typename E> class primary_container; + template <typename Exact> class primary_container; - template <typename E> - struct vtypes< primary_container<E> > + template <typename Exact> + struct super_trait_< primary_container<Exact> > + { + typedef container_base<Exact> ret; + }; + + template <typename Exact> + struct vtypes< primary_container<Exact> > { - typedef container_base<E> super_type; typedef mlc::none tag; }; - template <typename E> - class primary_container : public container_base<E> + template <typename Exact> + class primary_container : public container_base<Exact> { public: - stc_using_from(Container<E>, value_type); + stc_using_from(Container, value_type); protected: primary_container() {} }; - // Class primary_std_container<E>. + // Class primary_std_container<Exact>. - template <typename E> class primary_std_container; + template <typename Exact> class primary_std_container; + + template <typename Exact> + struct super_trait_< primary_std_container<Exact> > + { + typedef primary_container<Exact> ret; + }; - template <typename E> - struct vtypes< primary_std_container<E> > + template <typename Exact> + struct vtypes< primary_std_container<Exact> > { - typedef primary_container<E> super_type; typedef stc::abstract std_type; typedef stc_defer(std_type) container_t; @@ -159,11 +182,11 @@ typedef stc::final<typename container_t::size_type> size_type; }; - template <typename E> - class primary_std_container : public primary_container<E> + template <typename Exact> + class primary_std_container : public primary_container<Exact> { public: - typedef primary_container<E> super; + typedef primary_container<Exact> super; stc_using(iterator); stc_using(const_iterator); @@ -179,8 +202,8 @@ bool impl_empty() const { return data_.empty(); } // Forward_Container. - bool impl_equal(const E& rhs) const { return data_ == rhs.data_; } - bool impl_less (const E& rhs) const { return data_ < rhs.data_; } + bool impl_equal(const Exact& rhs) const { return data_ == rhs.data_; } + bool impl_less (const Exact& rhs) const { return data_ < rhs.data_; } protected: @@ -189,7 +212,7 @@ primary_std_container(size_type n, const value_type& t) : data_(n, t) {} primary_std_container(const primary_std_container& rhs) : data_(rhs.data_) {} - abc_vtype(E, std_type) data_; + abc_vtype(Exact, std_type) data_; }; Index: samples/mini-std/cpp/vector.hh --- samples/mini-std/cpp/vector.hh (revision 1031) +++ samples/mini-std/cpp/vector.hh (working copy) @@ -11,13 +11,16 @@ template <typename T> class vector; + template <typename T> + struct super_trait_< vector<T> > + { + typedef vector<T> self__; + typedef primary_std_container<self__> ret; + }; template <typename T> struct vtypes< vector<T> > { - typedef vector<T> E; - typedef primary_std_container<E> super_type; - typedef std::vector<T> std_type; // As Reversible_Container: Index: samples/mini-std/cpp/deque.hh --- samples/mini-std/cpp/deque.hh (revision 1031) +++ samples/mini-std/cpp/deque.hh (working copy) @@ -8,17 +8,18 @@ namespace abc { - template <typename T> class deque; - + typename <template T> + struct super_trait_< deque<T> > + { + typedef deque<T> self__; + typedef primary_std_container<self__> ret; + }; template <typename T> struct vtypes< deque<T> > { - typedef deque<T> E; - typedef primary_std_container<E> super_type; - typedef std::deque<T> std_type; // As Reversible_Container: Index: samples/mini-std/cpp/stack.hh --- samples/mini-std/cpp/stack.hh (revision 1031) +++ samples/mini-std/cpp/stack.hh (working copy) @@ -10,15 +10,17 @@ template <typename T, typename S> class stack; - + template <typename T, S> + struct super_trait_< list<T, S> > + { + typedef stack<T, S> self__; + typedef morpher_container<self__> ret; + }; template <typename T, typename S> struct vtypes< stack<T,S> > { - typedef stack<T,S> E; - typedef morpher_container<E> super_type; - - typedef S delegatee_type; + typedef S delegatee; // Properties. typedef mlc::false_ has_front_insertion; @@ -39,7 +41,7 @@ stc_using(reference); stc_using(value_type); - stc_using(delegatee_type); + stc_using(delegatee); // Renaming. reference top() @@ -57,8 +59,8 @@ this->pop_back(); } - const delegatee_type& impl_delegatee() const { return this->seq_; } - delegatee_type& impl_delegatee() { return this->seq_; } + const delegatee& impl_delegatee_() const { return this->seq_; } + delegatee& impl_delegatee_() { return this->seq_; } protected: S seq_; Index: samples/mini-std/cpp/value_cast.hh --- samples/mini-std/cpp/value_cast.hh (revision 1031) +++ samples/mini-std/cpp/value_cast.hh (working copy) @@ -11,14 +11,17 @@ template <typename T, typename C> class value_cast_; + template <typename T, C> + struct super_trait_< value_cast_<T, C> > + { + typedef value_cast_<T, C> self__; + typedef morpher_container<self__> super_type; + }; template <typename T, typename C> struct vtypes< value_cast_<T,C> > { - typedef value_cast_<T,C> E; - typedef morpher_container<E> super_type; - - typedef C delegatee_type; + typedef C delegatee; typedef T value_type; typedef T& reference; @@ -36,15 +39,15 @@ typedef value_cast_<T,C> self_type; typedef morpher_container<self_type> super; - stc_using(delegatee_type); + stc_using(delegatee); value_cast_(Container<C>& con) : con_(con.exact()) { } - const delegatee_type& impl_delegatee() const { return this->con_; } - delegatee_type& impl_delegatee() { return this->con_; } + const delegatee& impl_delegatee_() const { return this->con_; } + delegatee& impl_delegatee_() { return this->con_; } protected: C& con_; Index: samples/mini-std/cpp/equipment.hh --- samples/mini-std/cpp/equipment.hh (revision 1031) +++ samples/mini-std/cpp/equipment.hh (working copy) @@ -6,33 +6,32 @@ # include <stc/scoop.hh> -stc_scoop_equipment_for_namespace(abc); - - // Patch. # define abc_vtype_(From, Target) abc::vtype<From, abc::typedef_::Target>::ret # define abc_vtype(From, Target) typename abc_vtype_(From, Target) -# define abc_typename(Vtype) typedef abc_vtype(E, Vtype) Vtype +# define abc_typename(Vtype) typedef abc_vtype(Exact, Vtype) Vtype -# define stc_defer(Target) typename abc::deferred_vtype<E, abc::typedef_::Target>::ret - -# define stc_using(Vtype) typedef typename super::Vtype Vtype -# define stc_using_from(From, Vtype) typedef typename From::Vtype Vtype +# define stc_defer(Target) \ + typename abc::deferred_vtype<Exact, abc::typedef_::Target>::ret # define stc_introducing(Vtype) typedef abc_vtype(self_type, Vtype) Vtype -// stc_deferred_vtype(test, E, dim) +// stc_deferred_vtype(test, Exact, dim) namespace abc { - /// \{ +// Namespace equipment. +#include <stc/scoop.hxx> + + /// Typedef declarations. + /// \{ // From std. mlc_decl_typedef(value_type); @@ -64,17 +63,19 @@ namespace automatic { - template < template <class> class abstraction, typename E, typename tag = void > + template < template <class> class abstraction, + typename Exact, typename tag = void > struct impl; - template < template <class> class abstraction, typename E > - struct impl< abstraction, E, mlc::none > + template < template <class> class abstraction, typename Exact > + struct impl< abstraction, Exact, mlc::none > { // none means nothing! }; - template < template <class> class abstraction, typename E > - struct impl< abstraction, E, void > : impl< abstraction, E, abc_vtype(E, tag) > + template < template <class> class abstraction, typename Exact > + struct impl< abstraction, Exact, void > + : impl< abstraction, Exact, abc_vtype(Exact, tag) > { // fetch impl w.r.t. tag }; Index: samples/mini-std/cpp/identity.hh --- samples/mini-std/cpp/identity.hh (revision 1031) +++ samples/mini-std/cpp/identity.hh (working copy) @@ -19,8 +19,8 @@ // FIXME: Hack! (to be removed) - template < template <class> class abstraction, typename E > - struct impl< abstraction, E, tag::identity > + template < template <class> class abstraction, typename Exact > + struct impl< abstraction, Exact, tag::identity > { // ... }; @@ -29,10 +29,10 @@ // Container - template <typename E> - class impl< Container, E, tag::identity > + template <typename Exact> + class impl< Container, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: abc_typename(value_type); @@ -40,117 +40,117 @@ abc_typename(const_iterator); abc_typename(size_type); public: - iterator impl_begin() { return this->exact().delegatee().begin(); } - const_iterator impl_begin() const { return this->exact().delegatee().begin(); } - iterator impl_end() { return this->exact().delegatee().end(); } - const_iterator impl_end() const { return this->exact().delegatee().end(); } - size_type impl_size() const { return this->exact().delegatee().size(); } - bool impl_empty() const { return this->exact().delegatee().empty(); } + iterator impl_begin() { return this->exact().delegatee_().begin(); } + const_iterator impl_begin() const { return this->exact().delegatee_().begin(); } + iterator impl_end() { return this->exact().delegatee_().end(); } + const_iterator impl_end() const { return this->exact().delegatee_().end(); } + size_type impl_size() const { return this->exact().delegatee_().size(); } + bool impl_empty() const { return this->exact().delegatee_().empty(); } }; // Forward_Container - template <typename E> - class impl< Forward_Container, E, tag::identity > + template <typename Exact> + class impl< Forward_Container, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: - typedef Forward_Container<E> self_type; + typedef Forward_Container<Exact> self_type; public: - bool impl_equal(const self_type& rhs) const { return this->exact().delegatee().operator==(rhs); } - bool impl_less (const self_type& rhs) const { return this->exact().delegatee().operator< (rhs); } + bool impl_equal(const self_type& rhs) const { return this->exact().delegatee_().operator==(rhs); } + bool impl_less (const self_type& rhs) const { return this->exact().delegatee_().operator< (rhs); } }; // Reversible_Container - template <typename E> - class impl< Reversible_Container, E, tag::identity > + template <typename Exact> + class impl< Reversible_Container, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: abc_typename(reverse_iterator); abc_typename(const_reverse_iterator); public: - reverse_iterator impl_rbegin() { return this->exact().delegatee().rbegin(); } - const_reverse_iterator impl_rbegin() const { return this->exact().delegatee().rbegin(); } - reverse_iterator impl_rend() { return this->exact().delegatee().rend(); } - const_reverse_iterator impl_rend() const { return this->exact().delegatee().rend(); } + reverse_iterator impl_rbegin() { return this->exact().delegatee_().rbegin(); } + const_reverse_iterator impl_rbegin() const { return this->exact().delegatee_().rbegin(); } + reverse_iterator impl_rend() { return this->exact().delegatee_().rend(); } + const_reverse_iterator impl_rend() const { return this->exact().delegatee_().rend(); } }; // Random_Access_Container - template <typename E> - class impl< Random_Access_Container, E, tag::identity > + template <typename Exact> + class impl< Random_Access_Container, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: abc_typename(reference); abc_typename(const_reference); abc_typename(size_type); public: - reference impl_brackets(size_type n) { return this->exact().delegatee()[n]; } - const_reference impl_brackets(size_type n) const { return this->exact().delegatee()[n]; } + reference impl_brackets(size_type n) { return this->exact().delegatee_()[n]; } + const_reference impl_brackets(size_type n) const { return this->exact().delegatee_()[n]; } }; // Sequence - template <typename E> - class impl< Sequence, E, tag::identity > + template <typename Exact> + class impl< Sequence, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: abc_typename(value_type); abc_typename(iterator); public: - iterator impl_insert(iterator p, value_type t) { return this->exact().delegatee().insert(p, t); } - iterator impl_erase(iterator p) { return this->exact().delegatee().erase(p); } - iterator impl_erase(iterator p, iterator q) { return this->exact().delegatee().erase(p, q); } + iterator impl_insert(iterator p, value_type t) { return this->exact().delegatee_().insert(p, t); } + iterator impl_erase(iterator p) { return this->exact().delegatee_().erase(p); } + iterator impl_erase(iterator p, iterator q) { return this->exact().delegatee_().erase(p, q); } }; // Front_Insertion_Sequence - template <typename E> - class impl< Front_Insertion_Sequence, E, tag::identity > + template <typename Exact> + class impl< Front_Insertion_Sequence, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: abc_typename(value_type); public: - void impl_push_front(value_type t) { this->exact().delegatee().push_front(t); } - void impl_pop_front() { this->exact().delegatee().pop_front(); } + void impl_push_front(value_type t) { this->exact().delegatee_().push_front(t); } + void impl_pop_front() { this->exact().delegatee_().pop_front(); } }; // Back_Insertion_Sequence - template <typename E> - class impl< Back_Insertion_Sequence, E, tag::identity > + template <typename Exact> + class impl< Back_Insertion_Sequence, Exact, tag::identity > : - public virtual stc::any__simple<E> + public virtual stc::any__simple<Exact> { protected: abc_typename(value_type); abc_typename(reference); public: - reference impl_back() { this->exact().delegatee().back(); } - void impl_push_back(value_type t) { this->exact().delegatee().push_back(t); } - void impl_pop_back() { this->exact().delegatee().pop_back(); } + reference impl_back() { this->exact().delegatee_().back(); } + void impl_push_back(value_type t) { this->exact().delegatee_().push_back(t); } + void impl_pop_back() { this->exact().delegatee_().pop_back(); } }; Index: samples/mini-std/cpp/fwddecls.hh --- samples/mini-std/cpp/fwddecls.hh (revision 1031) +++ samples/mini-std/cpp/fwddecls.hh (working copy) @@ -16,10 +16,10 @@ // | +-- Random_Access_Container // | - template <typename E> class Container; - template <typename E> class Forward_Container; - template <typename E> class Reversible_Container; - template <typename E> class Random_Access_Container; + template <typename Exact> class Container; + template <typename Exact> class Forward_Container; + template <typename Exact> class Reversible_Container; + template <typename Exact> class Random_Access_Container; // | // +-- Sequence @@ -29,9 +29,9 @@ // | +-- Back_Insertion_Sequence // | - template <typename E> class Sequence; - template <typename E> class Front_Insertion_Sequence; - template <typename E> class Back_Insertion_Sequence; + template <typename Exact> class Sequence; + template <typename Exact> class Front_Insertion_Sequence; + template <typename Exact> class Back_Insertion_Sequence; // | // +-- Associative_Container @@ -45,13 +45,13 @@ // +-- Unique_Associative_Container // +-- Multiple_Associative_Container - template <typename E> class Associative_Container; - template <typename E> class Simple_Associative_Container; - template <typename E> class Pair_Associative_Container; - template <typename E> class Sorted_Associative_Container; - template <typename E> class Hashed_Associative_Container; - template <typename E> class Unique_Associative_Container; - template <typename E> class Multiple_Associative_Container; + template <typename Exact> class Associative_Container; + template <typename Exact> class Simple_Associative_Container; + template <typename Exact> class Pair_Associative_Container; + template <typename Exact> class Sorted_Associative_Container; + template <typename Exact> class Hashed_Associative_Container; + template <typename Exact> class Unique_Associative_Container; + template <typename Exact> class Multiple_Associative_Container; @@ -69,13 +69,13 @@ // | // +-- Random_Access_Iterator - template <typename E> class Iterator; - template <typename E> class Trivial_Iterator; - template <typename E> class Input_Iterator; - template <typename E> class Output_Iterator; - template <typename E> class Forward_Iterator; - template <typename E> class Bidirectional_Iterator; - template <typename E> class Random_Access_Iterator; + template <typename Exact> class Iterator; + template <typename Exact> class Trivial_Iterator; + template <typename Exact> class Input_Iterator; + template <typename Exact> class Output_Iterator; + template <typename Exact> class Forward_Iterator; + template <typename Exact> class Bidirectional_Iterator; + template <typename Exact> class Random_Access_Iterator; } // end of namespace abc Index: samples/mini-std/cpp/list.hh --- samples/mini-std/cpp/list.hh (revision 1031) +++ samples/mini-std/cpp/list.hh (working copy) @@ -11,13 +11,16 @@ template <typename T> class list; + typename <template T> + struct super_trait_< list<T> > + { + typedef list<T> self__; + typedef primary_std_container<self__> ret; + }; template <typename T> struct vtypes< list<T> > { - typedef list<T> E; - typedef primary_std_container<E> super_type; - typedef std::list<T> std_type; // As Reversible_Container: Index: samples/mini-std/cpp/Makefile.am --- samples/mini-std/cpp/Makefile.am (revision 0) +++ samples/mini-std/cpp/Makefile.am (revision 0) @@ -0,0 +1,22 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +AM_CPPFLAGS = -I$(top_srcdir)/static -I$(top_srcdir)/metalic + +# FIXME: Add +# +# AM_CXXFLAGS = $(CXXFLAGS_STRICT) $(CXXFLAGS_DEBUG) +# +# when oln.m4 is available in the distribution, instead of using the +# set-by-hand TESTS_CXXFLAGS. +TESTS_CXXFLAGS = @TESTS_CXXFLAGS@ +AM_CXXFLAGS = $(TESTS_CXXFLAGS) + + +noinst_HEADERS = \ + algorithm.hh concepts.hh deque.hh equipment.hh fwddecls.hh \ + identity.hh impl.hh list.hh stack.hh value_cast.hh vector.hh + +check_PROGRAMS = test +test_SOURCES = main.cc + +TESTS = $(check_PROGRAMS) Index: samples/mini-std/cpp/concepts.hh --- samples/mini-std/cpp/concepts.hh (revision 1031) +++ samples/mini-std/cpp/concepts.hh (working copy) @@ -9,9 +9,9 @@ // Container - template <typename E> - class Container : public virtual stc::any__simple<E>, - public automatic::impl<Container, E> + template <typename Exact> + class Container : public virtual stc::any__simple<Exact>, + public automatic::impl<Container, Exact> { public: @@ -39,13 +39,13 @@ // Forward_Container - template <typename E> - class Forward_Container : public virtual Container<E>, - public automatic::impl<Forward_Container, E> + template <typename Exact> + class Forward_Container : public virtual Container<Exact>, + public automatic::impl<Forward_Container, Exact> { public: - typedef Forward_Container<E> self_type; + typedef Forward_Container<Exact> self_type; // Methods. bool operator==(const self_type& rhs) const { return this->exact().impl_equal(rhs.exact()); } @@ -65,9 +65,9 @@ // Reversible_Container - template <typename E> - class Reversible_Container : public virtual Forward_Container<E>, - public automatic::impl<Reversible_Container, E> + template <typename Exact> + class Reversible_Container : public virtual Forward_Container<Exact>, + public automatic::impl<Reversible_Container, Exact> { public: @@ -89,13 +89,13 @@ // Random_Access_Container - template <typename E> - class Random_Access_Container : public virtual Reversible_Container<E>, - public automatic::impl<Random_Access_Container, E> + template <typename Exact> + class Random_Access_Container : public virtual Reversible_Container<Exact>, + public automatic::impl<Random_Access_Container, Exact> { public: - typedef Reversible_Container<E> super; + typedef Reversible_Container<Exact> super; stc_using(reference); stc_using(const_reference); stc_using(size_type); @@ -113,13 +113,13 @@ // Sequence - template <typename E> - class Sequence : public virtual Forward_Container<E>, - public automatic::impl<Sequence, E> + template <typename Exact> + class Sequence : public virtual Forward_Container<Exact>, + public automatic::impl<Sequence, Exact> { public: - typedef Forward_Container<E> super; + typedef Forward_Container<Exact> super; stc_using(iterator); stc_using(value_type); stc_using(reference); @@ -155,13 +155,13 @@ // Front_Insertion_Sequence - template <typename E> - class Front_Insertion_Sequence : public virtual Sequence<E>, - public automatic::impl<Front_Insertion_Sequence, E> + template <typename Exact> + class Front_Insertion_Sequence : public virtual Sequence<Exact>, + public automatic::impl<Front_Insertion_Sequence, Exact> { public: - typedef Sequence<E> super; + typedef Sequence<Exact> super; stc_using(value_type); // Concrete. @@ -183,13 +183,13 @@ // Back_Insertion_Sequence - template <typename E> - class Back_Insertion_Sequence : public virtual Sequence<E>, - public automatic::impl<Back_Insertion_Sequence, E> + template <typename Exact> + class Back_Insertion_Sequence : public virtual Sequence<Exact>, + public automatic::impl<Back_Insertion_Sequence, Exact> { public: - typedef Sequence<E> super; + typedef Sequence<Exact> super; stc_using(reference); stc_using(value_type); @@ -216,9 +216,9 @@ // Iterator - template <typename E> - class Iterator : public virtual stc::any__simple<E>, - public automatic::impl<Iterator, E> + template <typename Exact> + class Iterator : public virtual stc::any__simple<Exact>, + public automatic::impl<Iterator, Exact> { public: @@ -232,13 +232,13 @@ // Trivial_Iterator - template <typename E> - class Trivial_Iterator : public virtual Iterator<E>, - public automatic::impl<Trivial_Iterator, E> + template <typename Exact> + class Trivial_Iterator : public virtual Iterator<Exact>, + public automatic::impl<Trivial_Iterator, Exact> { public: - typedef Trivial_Iterator<E> self_type; + typedef Trivial_Iterator<Exact> self_type; // Typedef. abc_typename(value_type); @@ -262,9 +262,9 @@ // Input_Iterator - template <typename E> - class Input_Iterator : public virtual Trivial_Iterator<E>, - public automatic::impl<Input_Iterator, E> + template <typename Exact> + class Input_Iterator : public virtual Trivial_Iterator<Exact>, + public automatic::impl<Input_Iterator, Exact> { public: @@ -272,12 +272,12 @@ abc_typename(distance_type); // Method. - E& operator++() { return this->exact().impl_preinc(); } + Exact& operator++() { return this->exact().impl_preinc(); } // Concrete. - E operator++(int) const + Exact operator++(int) const { - E cpy(*this); + Exact cpy(*this); ++(*this); return cpy; } @@ -290,13 +290,13 @@ // Output_Iterator - template <typename E> - class Output_Iterator : public virtual Trivial_Iterator<E>, - public automatic::impl<Output_Iterator, E> + template <typename Exact> + class Output_Iterator : public virtual Trivial_Iterator<Exact>, + public automatic::impl<Output_Iterator, Exact> { public: - typedef Trivial_Iterator<E> super; + typedef Trivial_Iterator<Exact> super; stc_using(value_type); using super::operator*; @@ -314,9 +314,9 @@ // Forward_Iterator - template <typename E> - class Forward_Iterator : public virtual Input_Iterator<E>, public virtual Output_Iterator<E>, - public automatic::impl<Forward_Iterator, E> + template <typename Exact> + class Forward_Iterator : public virtual Input_Iterator<Exact>, public virtual Output_Iterator<Exact>, + public automatic::impl<Forward_Iterator, Exact> { public: // nothing @@ -328,19 +328,19 @@ // Bidirectional_Iterator - template <typename E> - class Bidirectional_Iterator : public virtual Forward_Iterator<E>, - public automatic::impl<Bidirectional_Iterator, E> + template <typename Exact> + class Bidirectional_Iterator : public virtual Forward_Iterator<Exact>, + public automatic::impl<Bidirectional_Iterator, Exact> { public: // Method. - E& operator--() { return this->exact().impl_predec(); } + Exact& operator--() { return this->exact().impl_predec(); } // Concrete. - E operator--(int) const + Exact operator--(int) const { - E cpy(*this); + Exact cpy(*this); --(*this); return cpy; } Index: samples/mini-std/cpp2/mini-std.cc Index: samples/mini-std/cpp2/Makefile.am --- samples/mini-std/cpp2/Makefile.am (revision 1019) +++ samples/mini-std/cpp2/Makefile.am (working copy) @@ -1,7 +1,18 @@ -CPPFLAGS = -I../../../../olena/oln -I../../../../metalic +## Process this file through Automake to create Makefile.in -*- Makefile -*- -.PHONY: all +AM_CPPFLAGS = -I$(top_srcdir)/static -I$(top_srcdir)/metalic -all: mini-std +# FIXME: Add +# +# AM_CXXFLAGS = $(CXXFLAGS_STRICT) $(CXXFLAGS_DEBUG) +# +# when oln.m4 is available in the distribution, instead of using the +# set-by-hand TESTS_CXXFLAGS. +TESTS_CXXFLAGS = @TESTS_CXXFLAGS@ +AM_CXXFLAGS = $(TESTS_CXXFLAGS) -mini-std: mini-std.cc \ No newline at end of file + +check_PROGRAMS = mini-std +mini_std_SOURCES = mini-std.cc + +TESTS = $(check_PROGRAMS) Index: samples/mini-std/Makefile.am --- samples/mini-std/Makefile.am (revision 0) +++ samples/mini-std/Makefile.am (revision 0) @@ -0,0 +1,5 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +SUBDIRS = cpp cpp2 + +EXTRA_DIST = README design.hh Index: samples/mini-std/README --- samples/mini-std/README (revision 1031) +++ samples/mini-std/README (working copy) @@ -5,6 +5,8 @@ cd cpp g++ -I../../.. -I../../../../metalic -Wall -ansi -pedantic main.cc +or just use `make' + * contents ** utility files Index: samples/Makefile.am --- samples/Makefile.am (revision 1031) +++ samples/Makefile.am (working copy) @@ -1,3 +1,3 @@ ## Process this file through Automake to create Makefile.in -*- Makefile -*- -SUBDIRS = mini-oln +SUBDIRS = mini-std mini-oln

17 years, 5 months

1031: Some renaming and add phantom border routines.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Some renaming and add phantom border routines. * mln/pw: New directory. * mln/fun/var.hh: Rename as... * mln/pw/var.hh: ...this. * mln/fun/val.hh: Rename as... * mln/pw/cst.hh: ...this. * mln/fun/pw_value.hh: Renameas ... * mln/pw/value.hh: ...this. * mln/core/concept/image.hh: . * mln/core/concept/iterator.hh: . * tests/erosion.cc, * tests/pw_value.cc, * TODO: Update. * mln/convert/to_window.hh: Fix doc. * mln/border/resize.hh: New. * mln/border/fill.hh: New. * mln/border/all.hh: New. * mln/border/duplicate.hh: New. * mln/border/mirror.hh: New. TODO | 15 ------- mln/border/all.hh | 54 ++++++++++++++++++++++++++++ mln/border/duplicate.hh | 75 +++++++++++++++++++++++++++++++++++++++ mln/border/fill.hh | 76 ++++++++++++++++++++++++++++++++++++++++ mln/border/mirror.hh | 75 +++++++++++++++++++++++++++++++++++++++ mln/border/resize.hh | 81 +++++++++++++++++++++++++++++++++++++++++++ mln/convert/to_window.hh | 2 - mln/core/concept/image.hh | 4 ++ mln/core/concept/iterator.hh | 6 +++ mln/pw/cst.hh | 41 ++++++++++++--------- mln/pw/value.hh | 57 ++++++++++++------------------ mln/pw/var.hh | 28 +++++++------- tests/erosion.cc | 10 ++--- tests/pw_value.cc | 6 +-- 14 files changed, 442 insertions(+), 88 deletions(-) Index: tests/erosion.cc --- tests/erosion.cc (revision 1030) +++ tests/erosion.cc (working copy) @@ -40,8 +40,8 @@ #include <mln/level/fill.hh> #include <mln/morpho/erosion.hh> -#include <mln/fun/pw_value.hh> -#include <mln/fun/val.hh> +#include <mln/pw/value.hh> +#include <mln/pw/cst.hh> #include <mln/fun/ops.hh> @@ -61,18 +61,16 @@ morpho::erosion(lena, rec, out); io::save_pgm(out, "out.pgm"); - /* { image2d_b<bool> bin(lena.domain()), out(lena.domain()); - level::fill(bin, pw_value(1) > val(127)); + level::fill(bin, pw::value(lena) > pw::cst(127)); morpho::erosion(bin, rec, out); image2d_b<int_u8> test(lena.domain()); - image2d_b<int_u8>::piter p(lena.domain()); + image2d_b<int_u8>::fwd_piter p(lena.domain()); for_all(p) test(p) = out(p) ? 255 : 0; io::save_pgm(test, "test.pgm"); } - */ } Index: tests/pw_value.cc --- tests/pw_value.cc (revision 1030) +++ tests/pw_value.cc (working copy) @@ -31,9 +31,9 @@ */ #include <mln/core/image2d_b.hh> -#include <mln/fun/pw_value.hh> #include <mln/fun/ops.hh> -#include <mln/fun/val.hh> +#include <mln/pw/value.hh> +#include <mln/pw/cst.hh> int main() @@ -44,5 +44,5 @@ point2d p = make::point2d(1, 1); ima(p) = 51; - std::cout << (pw_value(ima) = val(51))(p) << std::endl; + mln_assertion( (pw::value(ima) = pw::cst(51))(p) = true ); } Index: TODO --- TODO (revision 1030) +++ TODO (working copy) @@ -31,12 +31,12 @@ * renaming mlc into metal -point-wise material: pw::value_of, pw::constant, and pw::variable * clean-up accu::histo and median: remove inheritance +select_function in fun::internal::selector_p2? etc. * processing routines @@ -48,16 +48,3 @@ border::* and no-op versions if not fast image arith::inplace_plus et al. linear:: for convolutions - - -svn mv genpoint.hh generalized_point.hh -svn mv genpixel.hh generalized_pixel.hh -svn mv psite.hh point_site.hh -svn mv viter.hh value_iterator.hh -svn mv piter.hh point_iterator.hh - - -svn mv doc/genpoint.hh doc/generalized_point.hh -svn mv doc/genpixel.hh doc/generalized_pixel.hh -svn mv doc/viter.hh doc/value_iterator.hh -svn mv doc/piter.hh doc/point_iterator.hh Index: mln/convert/to_window.hh --- mln/convert/to_window.hh (revision 1030) +++ mln/convert/to_window.hh (working copy) @@ -30,7 +30,7 @@ /*! \file mln/convert/to_window.hh * - * \brief Convertions to mln::Image. + * \brief Convertions to mln::Window. */ # include <mln/core/concept/neighborhood.hh> Index: mln/pw/var.hh --- mln/pw/var.hh (revision 0) +++ mln/pw/var.hh (working copy) @@ -25,10 +25,10 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_FUN_VAR_HH -# define MLN_FUN_VAR_HH +#ifndef MLN_PW_VAR_HH +# define MLN_PW_VAR_HH -/*! \file mln/fun/var.hh +/*! \file mln/pw/var.hh * * \brief FIXME. */ @@ -41,31 +41,31 @@ // FIXME: Doc! - namespace fun + namespace pw { template <typename V> struct var_ : public Function_p2v< var_<V> > { typedef V result; + var_(const V& v); + template <typename P> const V& operator()(const P&) const; + private: const V& v_; }; - } // end of namespace mln::fun - template <typename V> - fun::var_<V> var(const V& v); + var_<V> var(const V& v); # ifndef MLN_INCLUDE_ONLY - namespace fun - { + // pw::var_<V> template <typename V> var_<V>::var_(const V& v) @@ -81,18 +81,20 @@ return v_; } - } // end of namespace mln::fun + // pw::var(v) template <typename V> - fun::var_<V> var(const V& v) + var_<V> var(const V& v) { - fun::var_<V> tmp(v); + var_<V> tmp(v); return tmp; } # endif // ! MLN_INCLUDE_ONLY + } // end of namespace mln::pw + } // end of namespace mln -#endif // ! MLN_FUN_VAR_HH +#endif // ! MLN_PW_VAR_HH Index: mln/pw/cst.hh --- mln/pw/cst.hh (revision 0) +++ mln/pw/cst.hh (working copy) @@ -25,10 +25,10 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_FUN_VAL_HH -# define MLN_FUN_VAL_HH +#ifndef MLN_PW_CST_HH +# define MLN_PW_CST_HH -/*! \file mln/fun/val.hh +/*! \file mln/pw/cst.hh * * \brief FIXME. */ @@ -39,35 +39,38 @@ namespace mln { - // FIXME: Doc! - - namespace fun + namespace pw { + // FIXME: Doc! + template <typename T> - struct val_ : public Function_p2v< val_<T> > + struct cst_ : public Function_p2v< cst_<T> > { typedef T result; - val_(T t); + + cst_(T t); + template <typename P> T operator()(const P&) const; + private: T t_; }; - } // end of namespace mln::fun + + // FIXME: Doc! template <typename T> - fun::val_<T> val(T t); + cst_<T> cst(T t); # ifndef MLN_INCLUDE_ONLY - namespace fun - { + // pw::cst_<T> template <typename T> - val_<T>::val_(T t) + cst_<T>::cst_(T t) : t_(t) { } @@ -75,23 +78,25 @@ template <typename T> template <typename P> T - val_<T>::operator()(const P&) const + cst_<T>::operator()(const P&) const { return t_; } - } // end of namespace mln::fun + // pw::cst(t) template <typename T> - fun::val_<T> val(T t) + cst_<T> cst(T t) { - fun::val_<T> tmp(t); + cst_<T> tmp(t); return tmp; } # endif // ! MLN_INCLUDE_ONLY + } // end of namespace mln::pw + } // end of namespace mln -#endif // ! MLN_FUN_VAL_HH +#endif // ! MLN_PW_CST_HH Index: mln/pw/value.hh --- mln/pw/value.hh (revision 0) +++ mln/pw/value.hh (working copy) @@ -25,10 +25,10 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef MLN_FUN_PW_VALUE_HH -# define MLN_FUN_PW_VALUE_HH +#ifndef MLN_PW_VALUE_HH +# define MLN_PW_VALUE_HH -/*! \file mln/fun/pw_value.hh +/*! \file mln/fun/pw/value.hh * * \brief FIXME. */ @@ -42,19 +42,7 @@ namespace mln { - // Fwd decl. - namespace fun { template <typename I> struct pw_value; } - - - - // FIXME: Doc! - - template <typename I> - fun::pw_value pw_value(const Image& ima); - - - - namespace fun + namespace pw { // FIXME: Move! @@ -70,16 +58,16 @@ struct select_function_< value::binary_kind, E > : Function_p2b<E> {}; - } // end of namespace mln::fun::internal + } // end of namespace mln::pw::internal // FIXME: Doc! template <typename I> - struct pw_value : public internal::select_function_< mln_value_kind(I), pw_value > + struct value_ : public internal::select_function_< mln_value_kind(I), value_ > { typedef mln_value(I) result; - pw_value(const I& ima); + value_(const I& ima); mln_rvalue(I) operator()(const mln_psite(I)& p) const; protected: const I& ima_; @@ -87,44 +75,47 @@ + // FIXME: Doc! + + template <typename I> + value_ value(const Image& ima); + + + # ifndef MLN_INCLUDE_ONLY - // fun::pw_value + // pw::value_ template <typename I> - pw_value::pw_value(const I& ima) + value_::value_(const I& ima) : ima_(ima) { } template <typename I> mln_rvalue(I) - pw_value::operator()(const mln_psite(I)& p) const + value_::operator()(const mln_psite(I)& p) const { mln_precondition(ima_.owns_(p)); return ima_(p); } -# endif // ! MLN_INCLUDE_ONLY - - } // end of namespace mln::fun - -# ifndef MLN_INCLUDE_ONLY - - // pw_value + // pw::value(ima) template <typename I> - fun::pw_value - pw_value(const Image& ima) + value_ + value(const Image& ima) { mln_precondition(exact(ima).has_data()); - fun::pw_value tmp(exact(ima)); + value_ tmp(exact(ima)); return tmp; } # endif // ! MLN_INCLUDE_ONLY + } // end of namespace mln::pw + } // end of namespace mln -#endif // ! MLN_FUN_PW_VALUE_HH +#endif // ! MLN_PW_VALUE_HH Index: mln/core/concept/image.hh --- mln/core/concept/image.hh (revision 1030) +++ mln/core/concept/image.hh (working copy) @@ -134,6 +134,10 @@ m6 = 0; lvalue (E::*m7)(const psite& p) = & E::operator(); m7 = 0; + + typedef mln_vset(E) vset; + const vset& (E::*m8)() const = & E::values; + m8 = 0; } # endif // ! MLN_INCLUDE_ONLY Index: mln/core/concept/iterator.hh --- mln/core/concept/iterator.hh (revision 1030) +++ mln/core/concept/iterator.hh (working copy) @@ -40,6 +40,12 @@ # define for_all(x) for(x.start(); x.is_valid(); x.next()) +/*! \brief Loop to browse all the elements targetted by the couples of + * iterators \p x1 and \p x2. + */ +# define for_all_2(x1, x2) for(x1.start(),x2.start(); x1.is_valid(); x1.next(),x2.next()) + + /*! \brief Loop to browse all the remaining elements targetted by the * iterator \p x. */ Index: mln/border/resize.hh --- mln/border/resize.hh (revision 0) +++ mln/border/resize.hh (revision 0) @@ -0,0 +1,81 @@ +// 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_BORDER_RESIZE_HH +# define MLN_BORDER_RESIZE_HH + +/*! \file mln/border/resize.hh + * + * \brief FIXME. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace border + { + + /*! Resize the virtual (outer) border of image \p ima to at least + * \p thickness. + * + * \param[in,out] ima The image whose border is to be resized. + * \param[in] thickness The expected minimum border size. + * + * \pre \p ima has to be initialized. + * + * \warning If the image border already has a size greater than \p + * thickness, this routine is a no-op. + * + * \todo Implement it. + */ + template <typename I> + void resize(const Fast_Image& ima, unsigned thickness); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + void resize(const Fast_Image& ima_, unsigned thickness) + { + const I& ima = exact(ima_); + mln_precondition(ima_.has_data()); + if (ima.border() >= thickness) + return; + mln_invariant(0); // FIXME: NYI + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::border + +} // end of namespace mln + + +#endif // ! MLN_BORDER_RESIZE_HH Index: mln/border/fill.hh --- mln/border/fill.hh (revision 0) +++ mln/border/fill.hh (revision 0) @@ -0,0 +1,76 @@ +// 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_BORDER_FILL_HH +# define MLN_BORDER_FILL_HH + +/*! \file mln/border/fill.hh + * + * \brief FIXME. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace border + { + + /*! Fill the virtual (outer) border of image \p ima with the + * single value \p v. + * + * \param[in,out] ima The image whose border is to be filled. + * \param[in] v The value to assign to all border pixels. + * + * \pre \p ima has to be initialized. + * + * \todo Implement it + optimize with memset if possible. + */ + template <typename I> + void fill(const Fast_Image& ima, const mln_value(I)& v); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + void fill(const Fast_Image& ima_, const mln_value(I)& v) + { + const I& ima = exact(ima_); + mln_precondition(ima_.has_data()); + mln_invariant(0); // FIXME: NYI + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::border + +} // end of namespace mln + + +#endif // ! MLN_BORDER_FILL_HH Index: mln/border/all.hh --- mln/border/all.hh (revision 0) +++ mln/border/all.hh (revision 0) @@ -0,0 +1,54 @@ +// 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_BORDER_ALL_HH +# define MLN_BORDER_ALL_HH + +/*! \file mln/border/all.hh + * + * \brief File that includes all border-related routines. + */ + + +namespace mln +{ + + /*! Namespace of routines related to image virtual (outer) border. + */ + namespace border {} + +} + + +# include <mln/border/duplicate.hh> +# include <mln/border/fill.hh> +# include <mln/border/mirror.hh> +# include <mln/border/resize.hh> +# include <mln/border/thickness.hh> + + +#endif // ! MLN_BORDER_ALL_HH Index: mln/border/duplicate.hh --- mln/border/duplicate.hh (revision 0) +++ mln/border/duplicate.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_BORDER_DUPLICATE_HH +# define MLN_BORDER_DUPLICATE_HH + +/*! \file mln/border/duplicate.hh + * + * \brief FIXME. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace border + { + + /*! Assign the virtual (outer) border of image \p ima with the + * dupplicate of the inner border of this image. + * + * \param[in,out] ima The image whose border is to be duplicated. + * + * \pre \p ima has to be initialized. + * + * \todo Implement it + optimize with memcpy if possible. + */ + template <typename I> + void duplicate(const Fast_Image& ima); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + void duplicate(const Fast_Image& ima_) + { + const I& ima = exact(ima_); + mln_precondition(ima_.has_data()); + mln_invariant(0); // FIXME: NYI + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::border + +} // end of namespace mln + + +#endif // ! MLN_BORDER_DUPLICATE_HH Index: mln/border/mirror.hh --- mln/border/mirror.hh (revision 0) +++ mln/border/mirror.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_BORDER_MIRROR_HH +# define MLN_BORDER_MIRROR_HH + +/*! \file mln/border/mirror.hh + * + * \brief FIXME. + */ + +# include <mln/core/concept/image.hh> + + +namespace mln +{ + + namespace border + { + + /*! Mirror the virtual (outer) border of image \p ima with the + * (inner) level contents of this image. + * + * \param[in,out] ima The image whose border is to be mirrored. + * + * \pre \p ima has to be initialized. + * + * \todo Implement it + optimize with memset if possible. + */ + template <typename I> + void mirror(const Fast_Image& ima); + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + void mirror(const Fast_Image& ima_) + { + const I& ima = exact(ima_); + mln_precondition(ima_.has_data()); + mln_invariant(0); // FIXME: NYI + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::border + +} // end of namespace mln + + +#endif // ! MLN_BORDER_MIRROR_HH

17 years, 5 months

1029: Adjust tests to the new interface of Static.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Adjust tests to the new interface of Static. * tests/super.cc, tests/vtypes-and-exact.cc: No longer use stc_scoop_equipment_for_namespace. Include stc/scoop.hxx instead. Remove the `_type' suffix from all virtual types. s/set_super_type/super_trait_/. * tests/vtypes.cc: Likewise. my::set_super_type<Z>: Remove. vtypes<Z>::delegatee: New virtual type. super.cc | 13 ++---- vtypes-and-exact.cc | 76 ++++++++++++------------------------ vtypes.cc | 108 ++++++++++++++++++++++++++-------------------------- 3 files changed, 85 insertions(+), 112 deletions(-) Index: tests/vtypes-and-exact.cc --- tests/vtypes-and-exact.cc (revision 1029) +++ tests/vtypes-and-exact.cc (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2006 EPITA Research and Development Laboratory +// Copyright (C) 2006, 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 @@ -40,28 +40,33 @@ // Helper macros. #define my_type_of_(FromType, Alias) \ - my::find_vtype<FromType, my::typedef_:: Alias##_type>::ret + my::find_vtype< FromType, my::typedef_:: Alias >::ret #define my_type_of(FromType, Alias) \ typename my_type_of_(FromType, Alias) -// Namespace equipment. -stc_scoop_equipment_for_namespace(my); namespace my { + /*----------------------. + | Namespace equipment. | + `----------------------*/ + +#include <stc/scoop.hxx> + + /*-----------. | Typedefs. | `-----------*/ - mlc_decl_typedef(foo_type); - mlc_decl_typedef(bar_type); - mlc_decl_typedef(baz_type); - mlc_decl_typedef(quux_type); - mlc_decl_typedef(yin_type); - mlc_decl_typedef(zorg_type); + mlc_decl_typedef(foo); + mlc_decl_typedef(bar); + mlc_decl_typedef(baz); + mlc_decl_typedef(quux); + mlc_decl_typedef(yin); + mlc_decl_typedef(zorg); /*----------------------------------------. @@ -77,12 +82,12 @@ struct vtypes< A<Exact> > { // A native type. - typedef int foo_type; + typedef int foo; // A Metalic value, used here to ensure that mlc::abstract::values // are accepted as virtual types, as well as any other type). - typedef mlc::int_<42> bar_type; + typedef mlc::int_<42> bar; // An undefined type. - typedef mlc::undefined baz_type; + typedef mlc::undefined baz; }; template <typename Exact> @@ -92,23 +97,6 @@ typedef Exact exact_t; // Aliases. - - // META-FIXME: Update comment (stc/scoop.hh as changed since). - - /* FIXME: Work around a bug that affects both g++ 4.1 and - gcc-snapshot (4.2) from Debian. The versions of the compiler - used at the moment this text was written were: - - g++ 4.1 : g++ (GCC) 4.1.2 20060920 (prerelease) (Debian 4.1.1-14) - gcc-snapshot : g++ (GCC) 4.2.0 20060922 (experimental) - - - Problem description: - - Using my_type_of (i.e., using stc_to_exact) breaks the - assertions ``Ensure stc::is_any_ works properly.'' below (in - main). Using my_direct_type_of (on the exact type) solves - this! */ typedef my_type_of(exact_t, foo) foo_t; typedef my_type_of(exact_t, bar) bar_t; typedef my_type_of(exact_t, baz) baz_t; @@ -125,7 +113,7 @@ // Super type. template <typename Exact> - struct set_super_type< B<Exact> > + struct super_trait_< B<Exact> > { typedef A<Exact> ret; }; @@ -137,16 +125,16 @@ // (foo is left untouched.) // A type redefined here. - typedef double bar_type; + typedef double bar; // A type defined here (but declared abstract in the super class). - typedef char baz_type; + typedef char baz; // A type defined only here (and not in the super class). - typedef long quux_type; + typedef long quux; }; /// An extended type associated to my::B. template <typename Exact> - struct single_vtype< B<Exact>, typedef_::yin_type > + struct single_vtype< B<Exact>, typedef_::yin > { typedef unsigned long ret; }; @@ -158,13 +146,6 @@ typedef Exact exact_t; // Aliases. - - // META-FIXME: Update comment (stc/scoop.hh as changed since). - - /* FIXME: Same as above; using my_type_of (i.e., using - stc_to_exact) breaks the assertions ``Ensure stc::is_any_ works - properly.'' below (in main). Using my_direct_type_of (on the - exact type) solves this! */ typedef my_type_of(exact_t, foo) foo_t; typedef my_type_of(exact_t, bar) bar_t; typedef my_type_of(exact_t, baz) baz_t; @@ -182,7 +163,7 @@ // Super type. template <> - struct set_super_type<C> + struct super_trait_<C> { typedef B<C> ret; }; @@ -192,7 +173,7 @@ struct vtypes<C> { // A type defined only here (and not in the super class). - typedef double zorg_type; + typedef double zorg; }; struct C : public B<C> @@ -201,13 +182,6 @@ typedef self_t exact_t; // Aliases. - - // META-FIXME: Update comment (stc/scoop.hh as changed since). - - /* FIXME: Same as above; using my_type_of_ (i.e., using - stc_to_exact) breaks the assertions ``Ensure stc::is_any_ works - properly.'' below (in main). Using my_direct_type_of_ (on the - exact type) solves this! */ typedef my_type_of_(exact_t, foo) foo_t; typedef my_type_of_(exact_t, quux) quux_t; typedef my_type_of_(exact_t, zorg) zorg_t; Index: tests/super.cc --- tests/super.cc (revision 1029) +++ tests/super.cc (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2006 EPITA Research and Development Laboratory +// Copyright (C) 2006, 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 @@ -33,13 +33,12 @@ #include <stc/scoop.hh> -// Namespace equipment. -stc_scoop_equipment_for_namespace(my); - - namespace my { +// Namespace equipment. +# include <stc/scoop.hxx> + /*----. | A. | `----*/ @@ -58,7 +57,7 @@ // Set super type. template<> - struct set_super_type + struct super_trait_ { typedef A ret; }; @@ -84,7 +83,7 @@ template<> struct vtypes<C> { - typedef B delegatee_type; + typedef B delegatee; }; struct C // no inheritance Index: tests/vtypes.cc --- tests/vtypes.cc (revision 1029) +++ tests/vtypes.cc (working copy) @@ -1,4 +1,4 @@ -// Copyright (C) 2006 EPITA Research and Development Laboratory +// Copyright (C) 2006, 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 @@ -37,28 +37,33 @@ // Helper macros. #define my_type_of_(FromType, Alias) \ - my::find_vtype<FromType, my::typedef_:: Alias##_type>::ret + my::find_vtype< FromType, my::typedef_:: Alias >::ret #define my_type_of(FromType, Alias) \ typename my_type_of_(FromType, Alias) -// Namespace equipment. -stc_scoop_equipment_for_namespace(my); namespace my { + /*----------------------. + | Namespace equipment. | + `----------------------*/ + +#include <stc/scoop.hxx> + + /*-----------. | Typedefs. | `-----------*/ - mlc_decl_typedef(foo_type); - mlc_decl_typedef(bar_type); - mlc_decl_typedef(baz_type); - mlc_decl_typedef(quux_type); - mlc_decl_typedef(yin_type); - mlc_decl_typedef(zorg_type); + mlc_decl_typedef(foo); + mlc_decl_typedef(bar); + mlc_decl_typedef(baz); + mlc_decl_typedef(quux); + mlc_decl_typedef(yin); + mlc_decl_typedef(zorg); /*----. @@ -73,21 +78,21 @@ struct vtypes<my::A> { // A native type. - typedef int foo_type; + typedef int foo; // A Metalic value, used here is to ensure that // mlc::abstract::values are accepted as virtual types, as well as // any other type). - typedef mlc::int_<42> bar_type; + typedef mlc::int_<42> bar; // An undefined type. - typedef mlc::undefined baz_type; + typedef mlc::undefined baz; }; struct A { // Aliases. - typedef my_type_of_(A, foo) foo_type; - typedef my_type_of_(A, bar) bar_type; - typedef my_type_of_(A, baz) baz_type; + typedef my_type_of_(A, foo) foo; + typedef my_type_of_(A, bar) bar; + typedef my_type_of_(A, baz) baz; }; @@ -100,7 +105,7 @@ // Set super type. template<> - struct set_super_type + struct super_trait_ { typedef A ret; }; @@ -112,16 +117,16 @@ // (foo is left untouched.) // A type redefined here. - typedef double bar_type; + typedef double bar; // A type defined here (but declared abstract in the super class). - typedef char baz_type; + typedef char baz; // A type defined only here (and not in the super class). - typedef long quux_type; + typedef long quux; }; /// An extended type associated to my::B. template <> - struct single_vtype<B, typedef_::yin_type> + struct single_vtype<B, typedef_::yin> { typedef unsigned long ret; }; @@ -129,11 +134,11 @@ struct B : public A { // Aliases. - typedef my_type_of_(B, foo) foo_type; - typedef my_type_of_(B, bar) bar_type; - typedef my_type_of_(B, baz) baz_type; - typedef my_type_of_(B, quux) quux_type; - typedef my_type_of_(B, yin) yin_type; + typedef my_type_of_(B, foo) foo; + typedef my_type_of_(B, bar) bar; + typedef my_type_of_(B, baz) baz; + typedef my_type_of_(B, quux) quux; + typedef my_type_of_(B, yin) yin; }; @@ -145,33 +150,28 @@ struct Z; // Z doesn't derive from B, but we want its vtypes to ``inherit'' - // from B's vtypes (see the specialization - // types<category::my_cat, Z>). - - /// Link to B (``pseudo'' inheritance). - template<> - struct set_super_type<Z> - { - typedef B ret; - }; + // from B's vtypes. /// Types associated to my::Z. template <> struct vtypes<Z> { + /// Delegation to B (used to be called ``pseudo'' inheritance). + typedef B delegatee; + // A type defined only here (and not in the super class). - typedef double zorg_type; + typedef double zorg; }; struct Z // no inheritance { // Aliases. - typedef my_type_of_(Z, foo) foo_type; - typedef my_type_of_(Z, bar) bar_type; - typedef my_type_of_(Z, baz) baz_type; - typedef my_type_of_(Z, quux) quux_type; - typedef my_type_of_(Z, yin) yin_type; - typedef my_type_of_(Z, zorg) zorg_type; + typedef my_type_of_(Z, foo) foo; + typedef my_type_of_(Z, bar) bar; + typedef my_type_of_(Z, baz) baz; + typedef my_type_of_(Z, quux) quux; + typedef my_type_of_(Z, yin) yin; + typedef my_type_of_(Z, zorg) zorg; }; } // end of namespace my @@ -181,21 +181,21 @@ main() { // Check types associated to A. - mlc::assert_<mlc_eq(my::A::foo_type, int)>::check(); - mlc::assert_<mlc_eq(my::A::bar_type, mlc::int_<42>)>::check(); + mlc::assert_<mlc_eq(my::A::foo, int)>::check(); + mlc::assert_<mlc_eq(my::A::bar, mlc::int_<42>)>::check(); // Check types associated to B. - mlc::assert_<mlc_eq(my::B::baz_type, char)>::check(); - mlc::assert_<mlc_eq(my::B::quux_type, long)>::check(); - mlc::assert_<mlc_eq(my::B::yin_type, unsigned long)>::check(); + mlc::assert_<mlc_eq(my::B::baz, char)>::check(); + mlc::assert_<mlc_eq(my::B::quux, long)>::check(); + mlc::assert_<mlc_eq(my::B::yin, unsigned long)>::check(); - mlc::assert_<mlc_neq(my::B::bar_type, my::A::bar_type)>::check(); + mlc::assert_<mlc_neq(my::B::bar, my::A::bar)>::check(); // Check types associated to Z. - mlc::assert_<mlc_eq(my::Z::foo_type, int)>::check(); - mlc::assert_<mlc_eq(my::Z::bar_type, double)>::check(); - mlc::assert_<mlc_eq(my::Z::baz_type, char)>::check(); - mlc::assert_<mlc_eq(my::Z::quux_type, long)>::check(); - mlc::assert_<mlc_eq(my::Z::yin_type, unsigned long)>::check(); - mlc::assert_<mlc_eq(my::Z::zorg_type, double)>::check(); + mlc::assert_<mlc_eq(my::Z::foo, int)>::check(); + mlc::assert_<mlc_eq(my::Z::bar, double)>::check(); + mlc::assert_<mlc_eq(my::Z::baz, char)>::check(); + mlc::assert_<mlc_eq(my::Z::quux, long)>::check(); + mlc::assert_<mlc_eq(my::Z::yin, unsigned long)>::check(); + mlc::assert_<mlc_eq(my::Z::zorg, double)>::check(); }

17 years, 5 months

1027: Clean up stc/scoop.hxx a bit.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Clean up stc/scoop.hxx a bit. * stc/scoop.hxx: Add a copyright header. Typos. Re-indent some parts. (helper_check): Fix documentation. Actually use check_final_stm and check_delegatee_inherited as described in the documentation. (helper_find): Add some documentation. scoop.hxx | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 53 insertions(+), 12 deletions(-) Index: static/stc/scoop.hxx --- static/stc/scoop.hxx (revision 1027) +++ static/stc/scoop.hxx (working copy) @@ -1,3 +1,29 @@ +// Copyright (C) 2005, 2006, 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 oln/stc/scoop.hxx \brief To be included within a namespace to import SCOOP 2 equipment. */ @@ -102,7 +128,8 @@ /* - FIXME: Inactivate since dummy code (many class are not Abstractions but abstraction<Exact>). + FIXME: Inactivate since dummy code (many class are not Abstractions + but abstraction<Exact>). template <template <class> class abstraction, typename Exact> struct super_trait_< abstraction<Exact> > @@ -241,7 +268,7 @@ * Returns the statement for class 'from' corresponding to 'target'. * This statement is either defined in 'vtypes' or in 'single_vtype'. * - * This routine is local; it does not recourse on superior classes. + * This routine is local; it does not recur on superior classes. * */ @@ -308,7 +335,8 @@ }; template <typename orig, typename target, typename stm> - struct check_no_final_inherited <orig, /* if curr == */ mlc::none, target, stm> + struct check_no_final_inherited <orig, /* if curr == */ mlc::none, + target, stm> { }; @@ -342,7 +370,7 @@ * check_delegatee_inherited */ - template <typename curr, typename target> + template <typename curr> struct check_delegatee_inherited : mlc::assert_< stc::is_found< typename first_stm<curr, typedef_::delegatee>::ret::second_elt >, @@ -422,7 +450,7 @@ * super = super(curr); * * if (stm == stc::abstract) { - * check_no_stm_inherited(curr, super, target); + * check_no_stm_inherited((curr, abstract), super, target); * return check(super, target); * } * if (stm == stc::final<T>) { @@ -463,10 +491,8 @@ : check_no_final_inherited< mlc::pair_<curr, stc::final<T> >, stc_super(curr), target > + , check_final_stm< curr, target, T > { - /* FIXME: - check_final_stm(T); - */ typedef typename check<stc_super(curr), target>::ret ret; }; @@ -476,10 +502,8 @@ : check_no_final_inherited< mlc::pair_<curr, stc::not_delegated>, stc_super(curr), target > + , check_delegatee_inherited< curr > { - /* FIXME: - check_delegatee_inherited(curr); - */ typedef typename check<stc_super(curr), target>::ret ret; }; @@ -662,6 +686,7 @@ * * delegator_find(from, target) * { + * // FIXME: This precondition is not actually enforced in the algorithm. * precondition(target != delegatee); * delegatee = superior_find(from, delegatee); * if (delegatee == mlc::not_found) @@ -696,8 +721,23 @@ /* * helper_find(from, target, where, res) * + * FIXME: ... * - * + * helper_find(from, target, where, res) + * { + * if (res == mlc::not_found) + * return delegator_find(from, target) + * else if (res = stc::abstract) + * { + * res_d = delegator_find(source, target) + * assert(res_d != mlc::not_found, + * "<target> declared <where> but not defined at <from>") + * } + * else if (res = stc::not_delegated) + * return superior_find(from, target) + * else + * return res + * } */ template <typename from, typename target, typename where> @@ -712,6 +752,7 @@ /* if res == */ stc::abstract > { typedef typename delegator_find<from, target>::ret res_d; + // FIXME: Might be shorten using mlc::assert_and_return_. struct check_ : mlc::assert_< stc::is_found<res_d>, ERROR::vtype_declared_but_not_defined

17 years, 5 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches