Olena-patches March 2007

olena-patches@lrde.epita.fr

7 participants
73 discussions

883: Remove obsolete files from oln/Makefile.am.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/olena This is only half of the work: I didn't add the new files (but the build farm will tell us which are missing). :) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * oln/Makefile.am (nobase_oln_HEADERS): Remove obsolete files. Makefile.am | 134 ------------------------------------------------------------ 1 files changed, 134 deletions Index: oln/Makefile.am --- oln/Makefile.am (revision 882) +++ oln/Makefile.am (working copy) @@ -3,177 +3,43 @@ olndir = $(includedir)/oln nobase_oln_HEADERS = \ \ - core/1d/aliases.hh \ core/1d/array1d.hh \ core/1d/dpoint1d.hh \ - core/1d/fwd_decls.hh \ core/1d/image1d.hh \ core/1d/neighb1d.hh \ core/1d/point1d.hh \ - core/1d/topo1d.hh \ core/1d/window1d.hh \ \ - core/2d/aliases.hh \ core/2d/array2d.hh \ core/2d/dpoint2d.hh \ - core/2d/fwd_decls.hh \ core/2d/image2d.hh \ core/2d/neighb2d.hh \ core/2d/point2d.hh \ - core/2d/topo2d.hh \ core/2d/window2d.hh \ \ - core/3d/aliases.hh \ core/3d/array3d.hh \ core/3d/dpoint3d.hh \ - core/3d/fwd_decls.hh \ core/3d/image3d.hh \ core/3d/neighb3d.hh \ core/3d/point3d.hh \ - core/3d/topo3d.hh \ core/3d/window3d.hh \ \ - core/abstract/image/bbox/hierarchy.hh \ - \ - core/abstract/image/computability/hierarchy.hh \ - \ - core/abstract/image/dimension/1d.hh \ - core/abstract/image/dimension/2d.hh \ - core/abstract/image/dimension/3d.hh \ - core/abstract/image/dimension/hierarchy.hh \ - \ - core/abstract/image/hybrid/classical.hh \ - \ - core/abstract/image/mutability/hierarchy.hh \ - \ - core/abstract/image/neighborhood/hierarchy.hh \ - \ - core/abstract/image/point_wise_accessibility/hierarchy.hh \ - \ - core/abstract/image/type/binary.hh \ - core/abstract/image/type/color.hh \ - core/abstract/image/type/data.hh \ - core/abstract/image/type/grey_level.hh \ - core/abstract/image/type/hierarchy.hh \ - core/abstract/image/type/integre.hh \ - core/abstract/image/type/label.hh \ - \ - core/abstract/image/value_wise_accessibility/hierarchy.hh \ - \ - core/abstract/image/all.hh \ - core/abstract/image/hierarchies.hh \ - \ - core/abstract/internal/image_impl.hh \ - \ - core/abstract/point_set/all.hh \ - core/abstract/point_set/hierarchies.hh \ - core/abstract/point_set/point_set_being_connected.hh \ - core/abstract/point_set/point_set_being_random_accessible.hh \ - core/abstract/point_set/point_set_having_bbox.hh \ - core/abstract/point_set/point_set_having_known_size.hh \ - \ - core/abstract/topology/all.hh \ - core/abstract/topology/hierarchies.hh \ - core/abstract/topology/topology_being_random_accessible.hh \ - core/abstract/topology/topology_having_bbox.hh \ - core/abstract/topology/topology_having_neighborhood.hh \ - core/abstract/topology/topology_having_subset.hh \ - \ - core/abstract/any.hh \ - core/abstract/array.hh \ - core/abstract/bbox.hh \ - core/abstract/dpoint.hh \ - core/abstract/entry.hh \ - core/abstract/functions.hh \ - core/abstract/fwd_decls.hh \ - core/abstract/grid.hh \ - core/abstract/image.hh \ - core/abstract/iterator.hh \ - core/abstract/iterator_on_points.hh \ - core/abstract/iterator_on_values.hh \ - core/abstract/neighborhood.hh \ - core/abstract/point.hh \ - core/abstract/point_set.hh \ - core/abstract/topology.hh \ - core/abstract/value.hh \ - core/abstract/window.hh \ - \ - core/automatic/image/image.hh \ - core/automatic/image/image1d.hh \ - core/automatic/image/image2d.hh \ - core/automatic/image/image3d.hh \ - core/automatic/image/mutable_image.hh \ - core/automatic/image/mutable_image1d.hh \ - core/automatic/image/mutable_image2d.hh \ - core/automatic/image/mutable_image3d.hh \ - core/automatic/image/image_being_point_wise_random_accessible.hh \ - core/automatic/image/image_being_value_wise_random_accessible.hh \ - core/automatic/image/image_having_neighborhood.hh \ - \ - core/automatic/topology/topology_being_random_accessible.hh \ - core/automatic/topology/topology_having_bbox.hh \ - core/automatic/topology/topology_having_neighborhood.hh \ - core/automatic/topology/topology_having_subset.hh \ - \ - core/automatic/impl.hh \ - \ - core/gen/bbox.hh \ - core/gen/bbox_bkd_piter.hh \ - core/gen/bbox_fwd_piter.hh \ - core/gen/bkd_niter_neighb.hh \ - core/gen/bkd_piter_bbox.hh \ - core/gen/bkd_qiter_win.hh \ core/gen/bkd_viter_lut.hh \ - core/gen/fwd_decls.hh \ - core/gen/fwd_niter_neighb.hh \ - core/gen/fwd_piter_bbox.hh \ - core/gen/fwd_qiter_win.hh \ core/gen/fwd_viter_lut.hh \ core/gen/piter_isubset.hh \ core/gen/piter_isubset.hh \ - core/gen/pset_.hh \ - core/gen/pset_list.hh \ - core/gen/pset_vec.hh \ - core/gen/grid.hh \ core/gen/mapimage.hh \ core/gen/neighb.hh \ - core/gen/piter_on_std_based_pset.hh \ core/gen/pw_value.hh \ - core/gen/topo_add_isubset.hh \ - core/gen/topo_add_nbh.hh \ - core/gen/topo_bbox.hh \ - core/gen/topo_lbbox.hh \ core/gen/window.hh \ \ - core/spe/col.hh \ - core/spe/row.hh \ - core/spe/slice.hh \ - \ - core/type_fun/ch_value.hh \ - core/type_fun/plain.hh \ - core/type_fun/slice.hh \ - \ - core/internal/bbox_bkd_piter.hh \ - core/internal/bbox_fwd_piter.hh \ core/internal/dpoint_nd.hh \ - core/internal/point_nd.hh \ - core/internal/topology_morpher.hh \ core/internal/tracked_ptr.hh \ \ - core/aliases.hh \ core/case.hh \ - core/fwd_decls.hh \ - core/image_entry.hh \ - core/iterator_vtypes.hh \ core/lookup_table.hh \ - core/macros.hh \ - core/neighborhood_entry.hh \ - core/point_set_entry.hh \ core/traits.hh \ core/traits_id.hh \ - core/topology_entry.hh \ - core/typedefs.hh \ - core/type.hh \ \ debug/print.hh \ debug/track.hh \

17 years, 1 month

882: Allow Olena to use the SCOOP Alternative implementation (back).

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/olena Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Allow Olena to use the SCOOP Alternative implementation (back). * oln/core/equipment.hh [OLENA_USE_SCOOP_ALT]: Include stc/scoop-alt.hh and stc/scoop-alt.inc instead of oln/stc/scoop.hh and oln/stc/scoop.hxx. * oln/stc/scoop.hh (stc::is): Name the template parameter for a better understanding. core/equipment.hh | 8 ++++++++ stc/scoop.hh | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) Index: oln/core/equipment.hh --- oln/core/equipment.hh (revision 881) +++ oln/core/equipment.hh (working copy) @@ -29,7 +29,11 @@ # define OLN_CORE_EQUIPMENT_HH # include <mlc/contract.hh> +# ifndef OLENA_USE_SCOOP_ALT # include <oln/stc/scoop.hh> // FIXME: Remove "oln/" later. +# else +# include <stc/scoop-alt.hh> +# endif # include <oln/core/init.hh> # define oln_typename_shortcut__(Type, Alias) typename Type::Alias @@ -39,7 +43,11 @@ namespace oln { +# ifndef OLENA_USE_SCOOP_ALT # include <oln/stc/scoop.hxx> // FIXME: Remove "oln/" later. +# else +# include <stc/scoop-alt.inc> +# endif // b stc_decl_associated_type( bkd_niter ); Index: oln/stc/scoop.hh --- oln/stc/scoop.hh (revision 881) +++ oln/stc/scoop.hh (working copy) @@ -53,7 +53,7 @@ template <typename T> struct final; - template < template <class> class > + template < template <class> class category > struct is; typedef mlc::true_ true_;

17 years, 1 month

873: New rle_encode function.

by Nicolas Ballas

Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> New rle_encode function. * oln/core/encode, * oln/core/encode/rle_encode.hh: New encode/rle_encode.hh | 81 ++++++++++++++++++++++++++++++++++++++ rle/rle_image.hh | 34 ++++++++++------ rle/rle_pset.hh | 108 ++++++++++++++++++++++++++++++++++++--------------- rle/rle_psite.hh | 29 +------------ 4 files changed, 185 insertions(+), 67 deletions(-) Index: oln/core/rle/rle_image.hh --- oln/core/rle/rle_image.hh (revision 872) +++ oln/core/rle/rle_image.hh (working copy) @@ -67,7 +67,6 @@ typedef rle_psite psite; typedef rle_pset<point> pset; -// typedef typename pset::box box; typedef mlc::none plain; @@ -75,7 +74,19 @@ }; - // Rle image class + /* + ** \class rle_image + ** \brief rle image (use a pair of point range and value as representation) + ** + ** method: + ** pset impl_points() const : return image pset + ** box impl_bbox() const : return image bbox + ** bool impl_has(const point& p) const : rle_image has p? + ** bool impl_owns_(const psite& p) const : same has impl_has + ** void insert(const point& p, unsigned len, value val) : insert a new range on the image + ** rvalue impl_read(const psite& p) const : return value associated to psite (for reading) + ** lvalue impl_read_write(const psite& p) : lvalue impl_read_write(const psite& p) (for writing) + */ template < typename P, typename T> class rle_image : public internal::primitive_image_< rle_image<P, T> > { @@ -136,7 +147,7 @@ bool rle_image<P, T>::impl_owns_(const typename rle_image<P, T>::psite& p) const { - return this->data_->first.has(p); + return this->data_->first.has(p.start_); } template <typename P, typename T> @@ -151,21 +162,22 @@ typename rle_image<P, T>::rvalue rle_image<P, T>::impl_read(const rle_image<P, T>::psite& ps) const { - // precondition(p.iterator_() != this->data_->second.end()); - return this->data_->second[ps]; + typename std::map<point, value>::const_iterator irun; + + irun = this->data_->second.find(ps.start_); + assert(irun != this->data_->second.end() && ps.index_ < this->data_->first.range_len_(ps.start_)); + return irun->second; } - int a = 5; template <typename P, typename T> typename rle_image<P, T>::lvalue rle_image<P, T>::impl_read_write(const rle_image<P, T>::psite& ps) { - std::cout << "read_write: " << std::endl; - std::cout << (point)ps << std::endl; + typename std::map<point, value>::iterator irun; - // precondition(p.iterator_() != this->data_->second.end()); - //return this->data_->second[ps]; - return a; + irun = this->data_->second.find(ps.start_); + assert(irun != this->data_->second.end() && ps.index_ < this->data_->first.range_len_(ps.start_)); + return irun->second; } # endif // !OLN_INCLUDE_ONLY Index: oln/core/rle/rle_psite.hh --- oln/core/rle/rle_psite.hh (revision 872) +++ oln/core/rle/rle_psite.hh (working copy) @@ -43,16 +43,16 @@ ** \class rle_piste ** \brief psite for rle image ** - ** - ** + ** Note: P must be a point type + ** method: + ** to_point: convert the psite to corresponding point + ** operator P(): convert psite to the corresponding point */ template <typename P> class rle_psite { public: rle_psite(); - // template <typename T> -// rle_psite(const rle_image<P, T>& ima, const P& p); P to_point() const; operator P () const; @@ -68,27 +68,6 @@ { } -// template <typename P> -// template <typename T> -// rle_psite::rle_psite(const rle_image<P, T>& ima, const P& p) : start_(p) -// { -// P pend; - -// typename rle_image<P, T>::piter it (ima.points()); - -// for (it.start(); it.is_valid(); it.next()) -// { -// pend = it; -// pend[0] += it->second - 1; -// if (*it >= p && p <= pend) -// { -// this->start_ = it->first; -// this->index_ = it->second - this->start[0]; -// } -// } -// } - - template <typename P> P rle_psite::to_point() const Index: oln/core/rle/rle_pset.hh --- oln/core/rle/rle_pset.hh (revision 872) +++ oln/core/rle/rle_pset.hh (working copy) @@ -47,21 +47,38 @@ template <typename P> struct rle_pset_fwd_piter_; template <typename P> struct rle_pset_bkd_piter_; + // Super type. + template <typename P> + struct super_trait_< rle_pset > + { + typedef rle_pset current; + typedef internal::point_set_base_<current> ret; + }; + // Vtypes associated to rle_pset class template <typename P> struct vtypes< rle_pset > { typedef P point; - typedef typename P::grid grid; - - typedef box_<point> box; typedef rle_pset_fwd_piter_ fwd_piter; typedef rle_pset_bkd_piter_ bkd_piter; - typedef fwd_piter piter; }; // rle_pset class + /* + ** \class rle_pset + ** \brief pset correspoding to the rle_image class + ** + ** Note: P must be a point type + ** method: + ** unsigned impl_npoints() const : return number of point in the point set + ** const box& impl_bbox() const : return a box which includes all poin into the set + ** void insert(const P& p, unsigned len): insert a new range on the point set + ** bool impl_has(const P& p) const : if p include in the set + ** const std_container& con() const : return the container of the point + ** + */ template <typename P> class rle_pset : public internal::point_set_base_<rle_pset > { @@ -81,11 +98,11 @@ bool impl_has(const P& p) const; const std_container& con() const; - unsigned range_len_(const P& range_start); + unsigned range_len_(const P& range_len_) const; protected: - unsigned npts; - std_container con_; - fbbox_<point> fb_; + unsigned npts; /*!< number of point in the set*/ + std_container con_; /*!< container of the set*/ + fbbox_<point> fb_; /*!< pset box*/ }; @@ -133,18 +150,10 @@ bool rle_pset::impl_has(const P& p) const { - P pend; + typename std_container::const_iterator irun; - typename std_container::const_iterator iter; - - for (iter = con_.begin(); iter != con_.end(); ++iter ) - { - pend = iter->first; - pend[0] += iter->second - 1; - if (iter->first >= p && p <= pend) - return 1; - } - return 0; + irun = this->con_.find(p); + return irun != this->con_.end(); } template <typename P> @@ -156,9 +165,13 @@ template <typename P> unsigned - rle_pset::range_len_(const P& range_start) + rle_pset::range_len_(const P& range_start) const { - return this->con_[range_start]; + typename std_container::const_iterator irun; + + irun = this->con_.find(range_start); + assert(irun != this->con_.end()); + return (irun->second); } # endif // !OLN_INCLUDE_ONLY @@ -166,11 +179,18 @@ // end of rle_pset class // -------------------- iterators on classes deriving from internal::rle_pset - // Forward declaration template <typename P> class rle_pset_fwd_piter_; + // Super type. + template <typename P> + struct super_trait_< rle_pset_fwd_piter_ > + { + typedef rle_pset_fwd_piter_ current; + typedef Iterator_on_Points<current> ret; + }; + // Virtual types template <typename P> struct vtypes< rle_pset_fwd_piter_ > @@ -179,6 +199,18 @@ }; // class rle_pset_fwd_iterator_ + /* + ** \class rle_pset_fwd_piter_ + ** \brief foward iterator for rle_pset + ** + ** P must be a point type + ** method: + ** void impl_start(): set the iterator to the start of pset + ** void impl_next(): go to next point + ** void impl_invalidate(): invalidate iterator + ** void impl_valid(): is the iterator valid? + ** + conversions methods + */ template <typename P> class rle_pset_fwd_piter_ : public Iterator_on_Points< rle_pset_fwd_piter_ > { @@ -203,7 +235,7 @@ protected: const typename rle_pset::std_container& con_; typename rle_pset::std_container::const_iterator it_; - rle_psite ps_; + rle_psite ps_; /*!< current point */ }; # ifndef OLN_INCLUDE_ONLY @@ -229,11 +261,8 @@ { precondition(this->is_valid()); - std::cout << "next: " << std::endl; - std::cout << "point start: " << ps_.start_ << " index: " << ps_.index_ << std::endl; - std::cout << "point start: " << it_->first << " index: " << it_->second << " ref" << std::endl; - ++this->ps_.index_; + if (this->ps_.index_ >= this->it_->second) { ++it_; @@ -291,6 +320,14 @@ template <typename P> class rle_pset_bkd_piter_; + // Super type. + template <typename P> + struct super_trait_< rle_pset_bkd_piter_ > + { + typedef rle_pset_bkd_piter_ current; + typedef Iterator_on_Points<current> ret; + }; + // Virtual type template <typename P> struct vtypes< rle_pset_bkd_piter_ > @@ -298,8 +335,18 @@ typedef P point; }; - // class rle_pset_bkd_piter_ - + /* + ** \class rle_pset_bkd_piter_ + ** \brief backward iterator for rle_pset + ** + ** P must be a point type + ** method: + ** void impl_start(): set the iterator to the start of pset + ** void impl_next(): go to next point + ** void impl_invalidate(): invalidate iterator + ** void impl_valid(): is the iterator valid? + ** + conversion method + */ template <typename P> class rle_pset_bkd_piter_ : public Iterator_on_Points< rle_pset_bkd_piter_ > { @@ -322,7 +369,7 @@ protected: const typename rle_pset::std_container& con_; typename rle_pset::std_container::const_reverse_iterator it_; - rle_psite ps_; + rle_psite ps_; /*!< current point*/ }; # ifndef OLN_INCLUDE_ONLY @@ -350,7 +397,6 @@ --ps_.index_; - // ps.index_ is unsigned if (ps_.index_ + 1 == 0) { ++it_; Index: oln/core/encode/rle_encode.hh --- oln/core/encode/rle_encode.hh (revision 0) +++ oln/core/encode/rle_encode.hh (revision 0) @@ -0,0 +1,81 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 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. + +#ifndef RLE_ENCODE_HH_ +# define RLE_ENCODE_HH_ + +# include <oln/core/concept/image.hh> + +# include <oln/core/rle/rle_image.hh> + +namespace oln +{ + + /*! + ** encode an image class to a rle_image + ** + ** @param input has to respect the Image concept + ** + ** @return rle_image + */ + template <typename I> + rle_image<typename Image::point, typename I::value> + rle_encode(const Image& input) + { + rle_image<typename I::point, typename I::value> output; + typename I::piter p (input.points()); + unsigned len = 1; + typename I::point rstart; /*!< range pointstart */ + typename I::value rvalue; /*!< range value */ + + p.start(); + if (!p.is_valid()) + return output; + + rstart = p; + rvalue = input(p); + p.next(); + while (p.is_valid()) + { + if (rvalue == input(p)) + ++len; + else + { + output.insert(rstart, len, rvalue); + len = 1; + rstart = p; + rvalue = input(p); + } + p.next(); + } + output.insert(rstart, len, rvalue); + return output; + } +} // end of namespace oln + +#endif /* !RLE_ENCODE_HH_ */

17 years, 1 month

862: Add rle_class, not finish yet.

by Nicolas Ballas

Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Add rle_class, not finish yet. * oln/core/rle: New. * oln/core/rle/rle_image.hh: New. * oln/core/rle/rle_psite.hh: New. * oln/core/rle/rle_pset.hh: New. rle_image.hh | 184 ++++++++++++++++++++++++++++ rle_pset.hh | 375 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ rle_psite.hh | 104 ++++++++++++++++ 3 files changed, 663 insertions(+) Index: oln/core/rle/rle_image.hh --- oln/core/rle/rle_image.hh (revision 0) +++ oln/core/rle/rle_image.hh (revision 0) @@ -0,0 +1,184 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 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. + +#ifndef OLN_CORE_RLE_RLE_IMAGE_HH_ +# define OLN_CORE_RLE_RLE_IMAGE_HH_ + +# include <map> +# include <utility> + + +# include <oln/core/internal/image_base.hh> +# include <oln/core/rle/rle_psite.hh> +# include <oln/core/rle/rle_pset.hh> + + + +namespace oln +{ + // Fwd decl. + template <typename P, typename T> + struct rle_image; + + // Super type. + template <typename P, typename T> + struct super_trait_< rle_image<P, T> > + { + typedef rle_image<P, T> current; + typedef internal::primitive_image_<current> ret; + }; + + // Virtual types + template <typename P, typename T> + struct vtypes< rle_image<P, T> > + { + typedef T value; + typedef const T& rvalue; + typedef T& lvalue; + + typedef P point; + typedef typename P::coord coord; + + typedef rle_psite<P, T> psite; + + typedef rle_pset<point> pset; +// typedef typename pset::box box; + + typedef std::map<std::pair<point, unsigned>, value> data; + }; + + + // Rle image class + template < typename P, typename T> + class rle_image : public internal::primitive_image_< rle_image<P, T> > + { + typedef rle_image<P, T> current; + typedef internal::primitive_image_< rle_image<P, T> > super; + public: + stc_using(pset); + stc_using(box); + stc_using(point); + stc_using(value); + stc_using(rvalue); + stc_using(lvalue); + stc_using(psite); + stc_using(data); + + rle_image(); + + pset impl_points() const; + box impl_bbox() const; + bool impl_has(const point& p) const; + bool impl_owns_(const psite& p) const; + void insert(const point& p, unsigned len, value val); + rvalue impl_read(const psite& p) const; + lvalue impl_read_write(const psite& p); + + //Internal + const data& get_data_() const; + + protected: + pset pset_; + }; + +# ifndef OLN_INCLUDE_ONLY + + template <typename P, typename T> + rle_image<P, T>::rle_image() + { + this->data_ = new typename rle_image<P, T>::data; + } + + template <typename P, typename T> + typename rle_image<P, T>::pset + rle_image<P, T>::impl_points() const + { + return pset_; + } + + + template <typename P, typename T> + typename rle_image<P, T>::box + rle_image<P, T>::impl_bbox() const + { + return pset_.bbox(); + } + + template <typename P, typename T> + bool + rle_image<P, T>::impl_has(const typename rle_image<P, T>::point& p) const + { + return this->pset_.has(p.point_()); + } + + template <typename P, typename T> + bool + rle_image<P, T>::impl_owns_(const typename rle_image<P, T>::psite& p) const + { + //FIXME + return this->pset_.has(p.point_()); + } + + template <typename P, typename T> + void + rle_image<P, T>::insert(const typename rle_image<P, T>::point& p, unsigned len, rle_image<P, T>::value val) + { + pset_.insert(p, len); + ((this->data_))->operator[](std::make_pair(p, len)) = val; + } + + template <typename P, typename T> + typename rle_image<P, T>::rvalue + rle_image<P, T>::impl_read(const rle_image<P, T>::psite& p) const + { + precondition(p.iterator_() != this->data_->end()); + return p.iterator_()->second; + } + + template <typename P, typename T> + typename rle_image<P, T>::lvalue + rle_image<P, T>::impl_read_write(const rle_image<P, T>::psite& p) + { + precondition(p.iterator_() != this->data_->end()); + return p.iterator_()->second; + } + + template <typename P, typename T> + const typename rle_image<P, T>::data& + rle_image<P, T>::get_data_() const + { + //FIXME: another way to do that? + return *(this->data_.ptr_); + } + + +# endif // !OLN_INCLUDE_ONLY + +} // end of namespace oln + +#endif /* !OLN_CORE_RLE_RLE_IMAGE_HH_ */ Index: oln/core/rle/rle_psite.hh --- oln/core/rle/rle_psite.hh (revision 0) +++ oln/core/rle/rle_psite.hh (revision 0) @@ -0,0 +1,104 @@ +// 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 +// 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 OLN_CORE_RLE_RLE_PSITE_HH_ +# define OLN_CORE_RLE_RLE_PSITE_HH_ + + +# include <map> +# include <utility> + +namespace oln +{ + + + // Forward declaration + template <typename P, typename T> struct rle_image; + + /* + ** \class rle_piste + ** \brief psite for rle image + ** + ** + ** + */ + template <typename P, typename T> + class rle_psite + { + public: + rle_psite(const rle_image<P, T>& ima, const P& p); + const typename std::map<std::pair<P, unsigned>, T>::iterator& iterator_() const; + typename std::map<std::pair<P, unsigned>, T>::iterator& iterator_(); + const P& point_() const; + protected: + P p_; /*!< point corresponding to the psite */ + typename std::map<std::pair<P, unsigned>, T>::iterator it_; /*!< it_ on image map corresponding to p_*/ + }; + +# ifndef OLN_INCLUDE_ONLY + + template <typename P, typename T> + rle_psite<P, T>::rle_psite(const rle_image<P, T>& ima, const P& p) : p_(p)//, it_(ima.points().con()) + { + P pend; + +// for (this->it_ = ima.get_data_().begin(); this->it_ != ima.get_data_().end(); ++(this->it_)) +// { +// pend = this->it_->first.first; +// pend[0] += this->it_->first.second - 1; +// if (this->it_->first.first >= p && p <= pend) +// return; +// } + it_ = ima.get_data_().end(); + } + + template <typename P, typename T> + const typename std::map<std::pair<P, unsigned>, T>::iterator& + rle_psite<P, T>::iterator_() const + { + return this->it_; + } + + template <typename P, typename T> + typename std::map<std::pair<P, unsigned>, T>::iterator& + rle_psite<P, T>::iterator_() + { + return this->it_; + } + + template <typename P, typename T> + const P& + rle_psite<P, T>::point_() const + { + return p_; + } + +# endif /* !OLN_INCLUDE_ONLY */ + + //end of class rle_psite +} +#endif /* !OLN_CORE_RLE_RLE_PSITE_HH_ */ Index: oln/core/rle/rle_pset.hh --- oln/core/rle/rle_pset.hh (revision 0) +++ oln/core/rle/rle_pset.hh (revision 0) @@ -0,0 +1,375 @@ +// 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 +// 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 OLN_CORE_RLE_RLE_PSET_HH_ +# define OLN_CORE_RLE_RLE_PSET_HH_ + +# include <set> +# include <utility> + +# include <oln/core/rle/rle_psite.hh> + +# include <oln/core/internal/point_set_base.hh> + +# include <oln/core/concept/iterator_on_points.hh> + +# include <oln/core/gen/fbbox.hh> + +namespace oln +{ + + // Forwards declaration + template <typename P> struct rle_pset; + template <typename P> struct rle_pset_fwd_piter_; + template <typename P> struct rle_pset_bkd_piter_; + + // Vtypes associated to rle_pset class + template <typename P> + struct vtypes< rle_pset > + { + typedef P point; + typedef typename P::grid grid; + + typedef fbbox_<point> box; + + typedef rle_pset_fwd_piter_ fwd_piter; + typedef rle_pset_bkd_piter_ bkd_piter; + typedef fwd_piter piter; + }; + + // rle_pset class + + template <typename P> + class rle_pset : public internal::point_set_base_<rle_pset > + { + typedef rle_pset current; + typedef internal::point_set_base_<rle_pset > super; + public: + stc_using(point); + stc_using(box); + + typedef std::set< std::pair<point, unsigned> > std_container; + + rle_pset(); + + unsigned impl_npoints() const; + const box& impl_bbox() const; + void insert(const P& p, unsigned len); + bool impl_has(const P& p) const; + const std_container& con() const; + + protected: + unsigned npts; + std_container con_; + fbbox_<point> fb_; + }; + + +# ifndef OLN_INCLUDE_ONLY + + template <typename P> + rle_pset::rle_pset() : npts(0) + { + } + + + template <typename P> + unsigned + rle_pset::impl_npoints() const + { + return npts; + } + + template <typename P> + void + rle_pset::insert(const P& p, unsigned len) + { + con_.insert(std::make_pair(p, len)); + P pend; + + //update bbox + fb_.take(p); + pend = p; + pend[0] += len - 1; + fb_.take(pend); + + // update size + npts += len; + } + + template <typename P> + const typename rle_pset::box& + rle_pset::impl_bbox() const + { + return fb_; + } + + template <typename P> + bool + rle_pset::impl_has(const P& p) const + { + point pend; + typename std_container::const_iterator iter; + + for (iter = con_.begin(); iter != con_.end(); ++iter ) + { + pend = iter->first; + pend[0] += iter->second - 1; + if (iter->first >= p && p <= pend) + return 1; + } + return 0; + } + + // end of rle_pset class + + template <typename P> + const typename rle_pset::std_container& + rle_pset::con() const + { + return this->con_; + } + + +# endif // !OLN_INCLUDE_ONLY + + + // -------------------- iterators on classes deriving from internal::rle_pset + + // Forward declaration + template <typename P> + class rle_pset_fwd_piter_; + + // Virtual types + template <typename P> + struct vtypes< rle_pset_fwd_piter_ > + { + typedef P point; + }; + + // class rle_pset_fwd_iterator_ + template <typename P> + class rle_pset_fwd_piter_ : public Iterator_on_Points< rle_pset_fwd_piter_ > + { + typedef Iterator_on_Points< rle_pset_fwd_piter_ > super; + typedef rle_pset_fwd_piter_ current; + public: + stc_using(point); + + rle_pset_fwd_piter_(const rle_pset& con); + + void impl_start(); + void impl_next(); + void impl_invalidate(); + bool impl_is_valid() const; + point impl_to_point() const; + const point* impl_point_adr() const; + + protected: + const typename rle_pset::std_container& con_; + typename rle_pset::std_container::const_iterator it_; + point p_; + }; + +# ifndef OLN_INCLUDE_ONLY + + template <typename P> + rle_pset_fwd_piter_::rle_pset_fwd_piter_(const rle_pset& cont) : con_(cont.con()) + { + this->it_ = this->con_.end(); + } + + template <typename P> + void + rle_pset_fwd_piter_::impl_start() + { + this->it_ = this->con_.begin(); + this->p_ = this->it_->first; + } + + template <typename P> + void + rle_pset_fwd_piter_::impl_next() + { + point pend; + + if (!this->is_valid()) + return; + + pend = this->it_->first; + pend[0] += this->it_->second - 1; + + ++p_[0]; + if (p_ > pend) + { + ++it_; + p_ = this->it_->first; + } + } + + template <typename P> + void + rle_pset_fwd_piter_::impl_invalidate() + { + this->it_ = this->con_.end(); + } + + template <typename P> + bool + rle_pset_fwd_piter_::impl_is_valid() const + { + return this->it_ != this->con_.end(); + } + + template <typename P> + typename rle_pset_fwd_piter_::point + rle_pset_fwd_piter_::impl_to_point() const + { + return p_; + } + + template <typename P> + const typename rle_pset_fwd_piter_::point* + rle_pset_fwd_piter_::impl_point_adr() const + { + return &p_; + } + +# endif // !OLN_INCLUDE_ONLY + + //end of class rle_pset_fwd_iterator_ + + // Forward declaration + template <typename P> + class rle_pset_bkd_piter_; + + // Virtual type + template <typename P> + struct vtypes< rle_pset_bkd_piter_ > + { + typedef P point; + }; + + // class rle_pset_bkd_piter_ + + template <typename P> + class rle_pset_bkd_piter_ : public Iterator_on_Points< rle_pset_bkd_piter_ > + { + typedef Iterator_on_Points< rle_pset_bkd_piter_ > super; + typedef rle_pset_bkd_piter_ current; + public: + stc_using(point); + + rle_pset_bkd_piter_(const rle_pset& con); + + void impl_start(); + void impl_next(); + void impl_invalidate(); + bool impl_is_valid() const; + point impl_to_point() const; + const point* impl_point_adr() const; + + protected: + const typename rle_pset::std_container& con_; + typename rle_pset::std_container::const_reverse_iterator it_; + point p_; + }; + +# ifndef OLN_INCLUDE_ONLY + + template <typename P> + rle_pset_bkd_piter_::rle_pset_bkd_piter_(const rle_pset& cont) : con_(cont.con()) + { + this->it_ = this->con_.rend(); + } + + template <typename P> + void + rle_pset_bkd_piter_::impl_start() + { + this->it_ = this->con_.rbegin(); + this->p_ = this->it_->first; + this->p_[0] += this->it_->second - 1; + } + + template <typename P> + void + rle_pset_bkd_piter_::impl_next() + { + point pend; + + if (!this->is_valid()) + return; + + pend = this->it_->first; + + --p_[0]; + if (p_ < pend) + { + ++it_; + p_ = this->it_->first; + this->p_[0] += this->it_->second - 1; + } + } + + template <typename P> + void + rle_pset_bkd_piter_::impl_invalidate() + { + this->it_ = this->con_.rend(); + } + + template <typename P> + bool + rle_pset_bkd_piter_::impl_is_valid() const + { + return this->it_ != this->con_.rend(); + } + + template <typename P> + typename rle_pset_bkd_piter_::point + rle_pset_bkd_piter_::impl_to_point() const + { + return p_; + } + + template <typename P> + const typename rle_pset_bkd_piter_::point* + rle_pset_bkd_piter_::impl_point_adr() const + { + return &p_; + } + +# endif // !OLN_INCLUDE_ONLY + + // end of class rle_pset_bkd_piter_ + + +} // end of namespace oln + + +#endif /* !OLN_CORE_RLE_RLE_PSET_HH_ */

17 years, 1 month

871: Change on rle_class.

by Nicolas Ballas

Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Change on rle_class. * static/doc/tiny/more_scoop_2/main.cc: . * olena/ChangeLog: . * olena/oln/core/rle/rle_image.hh: . * olena/oln/core/rle/rle_psite.hh: . * olena/oln/core/rle/rle_pset.hh: . * metalic/mlc/bool.hh: . olena/ChangeLog | 9 +++ olena/oln/core/rle/rle_image.hh | 51 +++++++---------- olena/oln/core/rle/rle_pset.hh | 114 ++++++++++++++++++++++++++-------------- olena/oln/core/rle/rle_psite.hh | 72 ++++++++++++++----------- 4 files changed, 145 insertions(+), 101 deletions(-) Index: olena/ChangeLog --- olena/ChangeLog (revision 870) +++ olena/ChangeLog (working copy) @@ -1,3 +1,12 @@ +2007-03-13 Nicolas Ballas <ballas(a)lrde.epita.fr> + + Change rle_image/rle_pset storage structure(map<point, value>/ map<point/unsigned>). + Note that rle_image know bugs (memory problem). + + * oln/core/rle/rle_image.hh Update + * oln/core/rle/rle_pset.hh Update + * oln/core/rle/rle_psite.hh Adapte rle_psite class to rle_image and rle_pset changement + 2007-03-13 Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add oln_plain_value, update level::apply, and provide a sample test code. Index: olena/oln/core/rle/rle_image.hh --- olena/oln/core/rle/rle_image.hh (revision 870) +++ olena/oln/core/rle/rle_image.hh (working copy) @@ -64,12 +64,14 @@ typedef P point; typedef typename P::coord coord; - typedef rle_psite<P, T> psite; + typedef rle_psite psite; typedef rle_pset<point> pset; // typedef typename pset::box box; - typedef std::map<std::pair<point, unsigned>, value> data; + typedef mlc::none plain; + + typedef std::pair< pset, std::map<point, value> > data; }; @@ -99,11 +101,6 @@ rvalue impl_read(const psite& p) const; lvalue impl_read_write(const psite& p); - //Internal - const data& get_data_() const; - - protected: - pset pset_; }; # ifndef OLN_INCLUDE_ONLY @@ -111,72 +108,66 @@ template <typename P, typename T> rle_image<P, T>::rle_image() { - this->data_ = new typename rle_image<P, T>::data; + this->data_ = new data; } template <typename P, typename T> typename rle_image<P, T>::pset rle_image<P, T>::impl_points() const { - return pset_; + return this->data_->first; } - template <typename P, typename T> typename rle_image<P, T>::box rle_image<P, T>::impl_bbox() const { - return pset_.bbox(); + return this->data_->first.bbox(); } template <typename P, typename T> bool rle_image<P, T>::impl_has(const typename rle_image<P, T>::point& p) const { - return this->pset_.has(p.point_()); + return this->data_->first.has(p); } template <typename P, typename T> bool rle_image<P, T>::impl_owns_(const typename rle_image<P, T>::psite& p) const { - //FIXME - return this->pset_.has(p.point_()); + return this->data_->first.has(p); } template <typename P, typename T> void rle_image<P, T>::insert(const typename rle_image<P, T>::point& p, unsigned len, rle_image<P, T>::value val) { - pset_.insert(p, len); - ((this->data_))->operator[](std::make_pair(p, len)) = val; + this->data_->first.insert(p, len); + this->data_->second[p] = val; } template <typename P, typename T> typename rle_image<P, T>::rvalue - rle_image<P, T>::impl_read(const rle_image<P, T>::psite& p) const + rle_image<P, T>::impl_read(const rle_image<P, T>::psite& ps) const { - precondition(p.iterator_() != this->data_->end()); - return p.iterator_()->second; + // precondition(p.iterator_() != this->data_->second.end()); + return this->data_->second[ps]; } + int a = 5; template <typename P, typename T> typename rle_image<P, T>::lvalue - rle_image<P, T>::impl_read_write(const rle_image<P, T>::psite& p) + rle_image<P, T>::impl_read_write(const rle_image<P, T>::psite& ps) { - precondition(p.iterator_() != this->data_->end()); - return p.iterator_()->second; - } + std::cout << "read_write: " << std::endl; + std::cout << (point)ps << std::endl; - template <typename P, typename T> - const typename rle_image<P, T>::data& - rle_image<P, T>::get_data_() const - { - //FIXME: another way to do that? - return *(this->data_.ptr_); + // precondition(p.iterator_() != this->data_->second.end()); + //return this->data_->second[ps]; + return a; } - # endif // !OLN_INCLUDE_ONLY } // end of namespace oln Index: olena/oln/core/rle/rle_psite.hh --- olena/oln/core/rle/rle_psite.hh (revision 870) +++ olena/oln/core/rle/rle_psite.hh (working copy) @@ -46,55 +46,63 @@ ** ** */ - template <typename P, typename T> + template <typename P> class rle_psite { public: - rle_psite(const rle_image<P, T>& ima, const P& p); - const typename std::map<std::pair<P, unsigned>, T>::iterator& iterator_() const; - typename std::map<std::pair<P, unsigned>, T>::iterator& iterator_(); - const P& point_() const; - protected: - P p_; /*!< point corresponding to the psite */ - typename std::map<std::pair<P, unsigned>, T>::iterator it_; /*!< it_ on image map corresponding to p_*/ + rle_psite(); + // template <typename T> +// rle_psite(const rle_image<P, T>& ima, const P& p); + + P to_point() const; + operator P () const; + + P start_; /*!< start of the range which contains the psite */ + unsigned index_; /*!< index of the point in the range */ }; # ifndef OLN_INCLUDE_ONLY - template <typename P, typename T> - rle_psite<P, T>::rle_psite(const rle_image<P, T>& ima, const P& p) : p_(p)//, it_(ima.points().con()) + template <typename P> + rle_psite::rle_psite() { - P pend; + } -// for (this->it_ = ima.get_data_().begin(); this->it_ != ima.get_data_().end(); ++(this->it_)) +// template <typename P> +// template <typename T> +// rle_psite::rle_psite(const rle_image<P, T>& ima, const P& p) : start_(p) +// { +// P pend; + +// typename rle_image<P, T>::piter it (ima.points()); + +// for (it.start(); it.is_valid(); it.next()) +// { +// pend = it; +// pend[0] += it->second - 1; +// if (*it >= p && p <= pend) // { -// pend = this->it_->first.first; -// pend[0] += this->it_->first.second - 1; -// if (this->it_->first.first >= p && p <= pend) -// return; +// this->start_ = it->first; +// this->index_ = it->second - this->start[0]; +// } +// } // } - it_ = ima.get_data_().end(); - } - template <typename P, typename T> - const typename std::map<std::pair<P, unsigned>, T>::iterator& - rle_psite<P, T>::iterator_() const - { - return this->it_; - } - template <typename P, typename T> - typename std::map<std::pair<P, unsigned>, T>::iterator& - rle_psite<P, T>::iterator_() + template <typename P> + P + rle_psite::to_point() const { - return this->it_; + P p = this->start_; + + p[0] += this->index_; + return p; } - template <typename P, typename T> - const P& - rle_psite<P, T>::point_() const + template <typename P> + rle_psite::operator P() const { - return p_; + return this->to_point(); } # endif /* !OLN_INCLUDE_ONLY */ Index: olena/oln/core/rle/rle_pset.hh --- olena/oln/core/rle/rle_pset.hh (revision 870) +++ olena/oln/core/rle/rle_pset.hh (working copy) @@ -54,7 +54,7 @@ typedef P point; typedef typename P::grid grid; - typedef fbbox_<point> box; + typedef box_<point> box; typedef rle_pset_fwd_piter_ fwd_piter; typedef rle_pset_bkd_piter_ bkd_piter; @@ -62,7 +62,6 @@ }; // rle_pset class - template <typename P> class rle_pset : public internal::point_set_base_<rle_pset > { @@ -72,7 +71,7 @@ stc_using(point); stc_using(box); - typedef std::set< std::pair<point, unsigned> > std_container; + typedef std::map<point, unsigned> std_container; rle_pset(); @@ -82,6 +81,7 @@ bool impl_has(const P& p) const; const std_container& con() const; + unsigned range_len_(const P& range_start); protected: unsigned npts; std_container con_; @@ -108,8 +108,9 @@ void rle_pset::insert(const P& p, unsigned len) { - con_.insert(std::make_pair(p, len)); - P pend; + point pend; + + this->con_[p] = len; //update bbox fb_.take(p); @@ -132,7 +133,8 @@ bool rle_pset::impl_has(const P& p) const { - point pend; + P pend; + typename std_container::const_iterator iter; for (iter = con_.begin(); iter != con_.end(); ++iter ) @@ -145,8 +147,6 @@ return 0; } - // end of rle_pset class - template <typename P> const typename rle_pset::std_container& rle_pset::con() const @@ -154,9 +154,16 @@ return this->con_; } + template <typename P> + unsigned + rle_pset::range_len_(const P& range_start) + { + return this->con_[range_start]; + } # endif // !OLN_INCLUDE_ONLY + // end of rle_pset class // -------------------- iterators on classes deriving from internal::rle_pset @@ -186,13 +193,17 @@ void impl_next(); void impl_invalidate(); bool impl_is_valid() const; + + const rle_psite& impl_to_psite() const; point impl_to_point() const; - const point* impl_point_adr() const; + const point* impl_psite_adr() const; + + operator rle_psite () const; protected: const typename rle_pset::std_container& con_; typename rle_pset::std_container::const_iterator it_; - point p_; + rle_psite ps_; }; # ifndef OLN_INCLUDE_ONLY @@ -208,26 +219,26 @@ rle_pset_fwd_piter_::impl_start() { this->it_ = this->con_.begin(); - this->p_ = this->it_->first; + this->ps_.start_ = this->it_->first; + this->ps_.index_ = 0; } template <typename P> void rle_pset_fwd_piter_::impl_next() { - point pend; - - if (!this->is_valid()) - return; + precondition(this->is_valid()); - pend = this->it_->first; - pend[0] += this->it_->second - 1; + std::cout << "next: " << std::endl; + std::cout << "point start: " << ps_.start_ << " index: " << ps_.index_ << std::endl; + std::cout << "point start: " << it_->first << " index: " << it_->second << " ref" << std::endl; - ++p_[0]; - if (p_ > pend) + ++this->ps_.index_; + if (this->ps_.index_ >= this->it_->second) { ++it_; - p_ = this->it_->first; + this->ps_.start_ = this->it_->first; + this->ps_.index_ = 0; } } @@ -249,14 +260,27 @@ typename rle_pset_fwd_piter_::point rle_pset_fwd_piter_::impl_to_point() const { - return p_; + return ps_.to_point(); + } + + template <typename P> + const rle_psite& + rle_pset_fwd_piter_::impl_to_psite() const + { + return ps_; + } + + template <typename P> + rle_pset_fwd_piter_::operator rle_psite () const + { + return this->impl_to_psite(); } template <typename P> const typename rle_pset_fwd_piter_::point* - rle_pset_fwd_piter_::impl_point_adr() const + rle_pset_fwd_piter_::impl_psite_adr() const { - return &p_; + return &ps_; } # endif // !OLN_INCLUDE_ONLY @@ -290,13 +314,15 @@ void impl_next(); void impl_invalidate(); bool impl_is_valid() const; + const rle_psite& impl_to_psite() const; point impl_to_point() const; - const point* impl_point_adr() const; + const point* impl_psite_adr() const; + operator rle_psite () const; protected: const typename rle_pset::std_container& con_; typename rle_pset::std_container::const_reverse_iterator it_; - point p_; + rle_psite ps_; }; # ifndef OLN_INCLUDE_ONLY @@ -312,27 +338,24 @@ rle_pset_bkd_piter_::impl_start() { this->it_ = this->con_.rbegin(); - this->p_ = this->it_->first; - this->p_[0] += this->it_->second - 1; + this->ps_.start_ = this->it_->first; + this->ps_.index_ = this->it_->second - 1; } template <typename P> void rle_pset_bkd_piter_::impl_next() { - point pend; + precondition(this->is_valid()); - if (!this->is_valid()) - return; + --ps_.index_; - pend = this->it_->first; - - --p_[0]; - if (p_ < pend) + // ps.index_ is unsigned + if (ps_.index_ + 1 == 0) { ++it_; - p_ = this->it_->first; - this->p_[0] += this->it_->second - 1; + this->ps_.start_ = this->it_->first; + this->ps_.index_ = this->it_->second - 1; } } @@ -351,17 +374,30 @@ } template <typename P> + const rle_psite& + rle_pset_bkd_piter_::impl_to_psite() const + { + return ps_; + } + + template <typename P> typename rle_pset_bkd_piter_::point rle_pset_bkd_piter_::impl_to_point() const { - return p_; + return ps_; + } + + template <typename P> + rle_pset_bkd_piter_::operator rle_psite () const + { + return this->impl_to_psite(); } template <typename P> const typename rle_pset_bkd_piter_::point* - rle_pset_bkd_piter_::impl_point_adr() const + rle_pset_bkd_piter_::impl_psite_adr() const { - return &p_; + return &ps_; } # endif // !OLN_INCLUDE_ONLY Index: metalic/mlc/bool.hh

17 years, 1 month

880: sparse_encode working.

by Nicolas Ballas

Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> sparse_encode working. * oln/core/encode/sparse_encode.hh: Update sparse_encode.hh | 39 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 3 deletions(-) Index: oln/core/encode/sparse_encode.hh --- oln/core/encode/sparse_encode.hh (revision 879) +++ oln/core/encode/sparse_encode.hh (working copy) @@ -33,6 +33,8 @@ # include <oln/core/sparse/sparse_image.hh> +# include <vector> + namespace oln { @@ -45,13 +47,44 @@ */ template <typename I> sparse_image<typename I::point, typename I::value> - sparse_encode(const Image input) + sparse_encode(const Image& input) { sparse_image<typename I::point, typename I::value> output; typename I::piter p (input.points()); - // typename I::coord len = 1; + unsigned len = 1; + typename I::coord old = 1; /*!< old point first dim coordinate */ typename I::point rstart; /*!< range pointstart */ - typename I::value rvalue; /*!< range value */ + std::vector<typename I::value> values; /*!< range value */ + + p.start(); + if (!p.is_valid()) + return output; + + rstart = p; + //FIXME: is it generall ? + old = (p.to_point())[0]; + values.push_back(input(p.to_point())); + p.next(); + while (p.is_valid()) + { + if ((p.to_point())[0] - 1 == old) + { + ++len; + values.push_back(input(p.to_point())); + } + else + { + output.insert(rstart, len, values); + rstart = p; + len = 1; + values.clear(); + values.push_back(input(p.to_point())); + } + old = (p.to_point())[0]; + p.next(); + } + output.insert(rstart, len, values); + return output; } }

17 years, 1 month

879: Fix bug on sparse image.

by Nicolas Ballas

Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> Fix bug on sparse image. * oln/core/encode/sparse_encode.hh: New. * oln/core/sparse/sparse_image.hh: sparse_image class working now encode/sparse_encode.hh | 58 ++++++++++++++++++++++++++++++++++++++++++++++++ sparse/sparse_image.hh | 8 +++--- 2 files changed, 62 insertions(+), 4 deletions(-) Index: oln/core/encode/sparse_encode.hh --- oln/core/encode/sparse_encode.hh (revision 0) +++ oln/core/encode/sparse_encode.hh (revision 0) @@ -0,0 +1,58 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 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. + +#ifndef SPARSE_ENCODE_HH_ +# define SPARSE_ENCODE_HH_ + +# include <oln/core/concept/image.hh> + +# include <oln/core/sparse/sparse_image.hh> + +namespace oln +{ + + /*! + ** encode a generic image to a sparse image format + ** + ** @param input an Image + ** + ** @return a sparse image + */ + template <typename I> + sparse_image<typename I::point, typename I::value> + sparse_encode(const Image input) + { + sparse_image<typename I::point, typename I::value> output; + typename I::piter p (input.points()); + // typename I::coord len = 1; + typename I::point rstart; /*!< range pointstart */ + typename I::value rvalue; /*!< range value */ + } +} + +#endif /* !SPARSE_ENCODE_HH_ */ Index: oln/core/sparse/sparse_image.hh --- oln/core/sparse/sparse_image.hh (revision 878) +++ oln/core/sparse/sparse_image.hh (working copy) @@ -133,9 +133,9 @@ typename sparse_image<P, T>::rvalue sparse_image<P, T>::impl_read(const sparse_image<P, T>::psite& ps) const { - typename std::map<point, value>::const_iterator irun; + typename std::map<point, std::vector<value> >::const_iterator irun; - irun = this->data_->second.find(ps.start_); + irun.operator= (this->data_->second.find(ps.start_)); assert(irun != this->data_->second.end() && ps.index_ < this->data_->first.range_len_(ps.start_)); return irun->second[ps.index_]; } @@ -144,9 +144,9 @@ typename sparse_image<P, T>::lvalue sparse_image<P, T>::impl_read_write(const sparse_image<P, T>::psite& ps) { - typename std::map<point, value>::const_iterator irun; + typename std::map<point, std::vector<value> >::iterator irun; - irun = this->data_->second.find(ps.start_); + irun.operator= (this->data_->second.find(ps.start_)); assert(irun != this->data_->second.end() && ps.index_ < this->data_->first.range_len_(ps.start_)); return irun->second[ps.index_]; }

17 years, 1 month

875: Update and add : apply, local canvas.

by Ugo Jardonnet

max and min value for any type can be obtain with std lib yet. Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Update and add : apply, local canvas. * tests/core/Makefile.am: . * oln/function: New. * oln/function/min.hh: New. * oln/level/apply.hh: . * oln/level/local.hh: New. * oln/core/concept/image.hh: . * oln/core/concept/functions.hh: . * oln/core/internal/max_value.hh: New. * oln/morphomath: New. * oln/morphomath/dilatation.hh: New. * oln/morphomath/erosion.hh: New. oln/core/concept/functions.hh | 10 ++++ oln/core/internal/max_value.hh | 42 +++++++++++++++++ oln/function/min.hh | 68 +++++++++++++++++++++++++++++ oln/level/apply.hh | 87 ++++++++++++++++++++++++++++++++++--- oln/level/local.hh | 96 +++++++++++++++++++++++++++++++++++++++++ oln/morphomath/dilatation.hh | 29 ++++++++++++ oln/morphomath/erosion.hh | 59 +++++++++++++++++++++++++ tests/core/Makefile.am | 1 8 files changed, 384 insertions(+), 8 deletions(-) Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 874) +++ tests/core/Makefile.am (working copy) @@ -37,7 +37,6 @@ neighb2d_SOURCES = neighb2d.cc npoints_SOURCES = npoints.cc window2d_SOURCES = window2d.cc -neighb2d_SOURCES = neighb2d.cc # Methods. at_SOURCES = at.cc Index: oln/function/min.hh --- oln/function/min.hh (revision 0) +++ oln/function/min.hh (revision 0) @@ -0,0 +1,68 @@ +// Copyright (C) 2007 EPITA Research and +// Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_FUNCTION_MIN_HH_ +# define OLN_FUNCTION_MIN_HH_ + +namespace oln +{ + + template <typename T> + struct min_ : oln::Function< min_<T> > + { + typedef T argument; + typedef void result; + + min_() + { + init(); + } + + void init() + { + val_ = oln_max_value(T); + } + + T value() const + { + return val_; + } + + template <typename U> + void operator()(U i) const + { + if (i < val_) + val_ = static_cast<T>(i); + } + private: + mutable T val_; + }; + +} + +#endif /* !OLN_FUNCTION_MIN_HH_ */ Index: oln/level/apply.hh --- oln/level/apply.hh (revision 874) +++ oln/level/apply.hh (working copy) @@ -63,16 +63,63 @@ namespace impl { - /// Generic version. + template < typename F > + struct result + { + typedef typename F::result ret; + }; - template <typename R, typename A, typename I> - oln_plain_value(I, R) - apply(R (*fun)(A), const Image& input) + template < typename R (*fun)(A) > + struct result + { + typedef typename R ret; + }; + + template < typename F > + struct argument + { + typedef typename F::argument ret; + }; + + template < typename R (*fun)(A) > + struct argument + { + typedef typename A ret; + }; + + + // APPLY // + //--------- + + template <typename F, typename I> + oln_plain_value(I, result<typename F>::ret) + apply(const F& fun, const Image& input) + { + typedef argument<typename F>::ret A; + typedef result<typename F>::ret R; + + oln_ch_value(I, R) output(input.points()); + oln_piter(I) p(input.points()); + for_all(p) + output(p) = fun( static_cast<A>(input(p)) ); + return output; + } + + + // APPLY_LOCAL // + //--------------- + + template <typename F, typename I> + oln_plain_value(I, result<typename F>::ret) + apply_local(const F& fun, const Image& input) { - oln_plain_value(I, R) output(input.points()); + typedef argument<typename F>::ret A; + typedef result<typename F>::ret R; + + oln_ch_value(I, R) output(input.points()); oln_piter(I) p(input.points()); for_all(p) - output(p) = fun(input(p)); + output(p) = local_apply(fun, input, p); return output; } @@ -112,8 +159,11 @@ } // end of namespace oln::level::impl + /// Facades. + //---------------------------- + + /// Apply. - /// Facade. template <typename R, typename A, typename I> oln_plain_value(I, R) apply(R (*fun)(A), const Image& input) @@ -121,6 +171,29 @@ return impl::apply(fun, exact(input)); } + template <typename F, typename I> + oln_plain_value(I, typename F::result) + apply(const F& fun, const Image& input) + { + return impl::apply(fun, exact(input)); + } + + /// Apply local + + template <typename R, typename A, typename I> + oln_plain_value(I, R) + apply_local(R (*fun)(A), const Image& input) + { + return impl::apply_local(fun, exact(input)); + } + + template <typename F, typename I> + oln_plain_value(I, typename F::result) + apply_local(const F& fun, const Image& input) + { + return impl::apply_local(fun, exact(input)); + } + // /// Facade. // template <typename I, typename F> // oln_plain_value(I, typename F::result_value) Index: oln/level/local.hh --- oln/level/local.hh (revision 0) +++ oln/level/local.hh (revision 0) @@ -0,0 +1,96 @@ +// 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 OLN_LEVEL_LOCAL_HH_ +# define OLN_LEVEL_LOCAL_HH_ + +namespace oln +{ + + namespace impl + { + + // LOCAL APPLICATION ON NBH // + //---------------------------- + + /// Local Apply on neighborhood ( nbh included in image ). + + template <typename R, typename A, typename I> + typename A::result + local_apply(const Accumulator< A >& fun, + const Image_with_Nbh& input, + const oln_point( I )& p) + { + fun.init(); + oln_niter(I) n(p, input.points()); + for_all(n) + fun(input(n)); + return fun.value(); + } + + + /// Local Apply on neighborhood ( nhb has to be given ). + + // ...FIXME + + + // LOCAL APPLICATION ON WINDOW // + //------------------------------- + + /// Local Apply on window ( window included in image). + + // ...FIXME + + + /// Local Apply on window ( window is given ). + + template <typename F, typename I, typename W> + typename F::result + local_apply(const Accumulator<F>& fun, + const Image& input, + const oln_point(I)& p, + const Window<W>& win) + { + fun.init(); + oln_qiter(W) q(p, win); + for_all(q) + fun(input(q)); + return fun.value(); + } + + } + + /// Facades. + + local_apply( ) + { + + } + +} +#endif /* !OLN_LEVEL_LOCAL_HH_ */ Index: oln/core/concept/image.hh Index: oln/core/concept/functions.hh --- oln/core/concept/functions.hh (revision 874) +++ oln/core/concept/functions.hh (working copy) @@ -73,6 +73,16 @@ }; + // Neighborhood -> Value. + + template <typename Exact> + struct Accumulator : public Function<Exact> + { + protected: + Accumulator(); + }; + + /* // Value1 -> Value2 *and* Value2 -> Value1. Index: oln/core/internal/max_value.hh --- oln/core/internal/max_value.hh (revision 0) +++ oln/core/internal/max_value.hh (revision 0) @@ -0,0 +1,42 @@ +// Copyright (C) 2007 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_CORE_INTERNAL_MAX_VALUE_HH_ +# define OLN_CORE_INTERNAL_MAX_VALUE_HH_ + +#include <cassert> +#include <limits> +#include <iostream> + +namespace oln +{ + +#define oln_max(T) std::numeric_limits< T >::max() + +} + +#endif /* !OLN_CORE_INTERNAL_MAX_VALUE_HH_ */ Index: oln/morphomath/dilatation.hh --- oln/morphomath/dilatation.hh (revision 0) +++ oln/morphomath/dilatation.hh (revision 0) @@ -0,0 +1,29 @@ +#ifndef OLN_MORPHOMATH_DILATATION_HH_ +# define OLN_MORPHOMATH_DILATATION_HH_ + +// Facade. + +namespace impl +{ + + /// Generic version + + template <typename I, typename W> + I dilatation(const Image& input) + { + max_<oln_value(I)> max; + return apply(max, input); + } + +} + + +/// Facade. + +template <typename I, typename W> +I erosion(const Image& input) +{ + return impl::dilatation(exact(input)); +} + +#endif /* !OLN_MORPHOMATH_DILATATION_HH_ */ Index: oln/morphomath/erosion.hh --- oln/morphomath/erosion.hh (revision 0) +++ oln/morphomath/erosion.hh (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. + +#ifndef OLN_MORPHOMATH_EROSION_HH_ +# define OLN_MORPHOMATH_EROSION_HH_ + +#include <oln/fonction/min.hh> +#include <oln/level/local.hh> + +namespace oln +{ + namespace impl + { + + /// Generic version + + template <typename I, typename W> + I erosion(const Image& input) + { + min_<oln_value(I)> min; + return apply(min, input); + } + } + + // Facade. + + template <typename I, typename W> + I erosion(const Point_Wise_Accessible_Image& input) + { + return impl::erosion(exact(input)); + } +} + +#endif /* !OLN_MORPHOMATH_EROSION_HH_ */

17 years, 1 month

881: New test for rle_class and sparse_image class.

by Nicolas Ballas

Index: ChangeLog from Nicolas Ballas <ballas(a)lrde.epita.fr> New test for rle_class and sparse_image class. * tests/core/sparse_image.cc: New. * tests/core/rle_image.cc: New. * tests/core/Makefile.am: Update Makefile.am | 5 +++ rle_image.cc | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ sparse_image.cc | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 148 insertions(+) Index: tests/core/sparse_image.cc --- tests/core/sparse_image.cc (revision 0) +++ tests/core/sparse_image.cc (revision 0) @@ -0,0 +1,69 @@ +#include <iostream> +#include <oln/core/rle/rle_psite.hh> +#include <oln/core/2d/image2d.hh> +#include <oln/debug/print.hh> +#include <oln/core/rle/rle_pset.hh> +#include <oln/core/sparse/sparse_image.hh> +#include <oln/core/encode/sparse_encode.hh> + +template <typename Ps> +void test(const Ps& pset) +{ + typename Ps::fwd_piter it (pset); + + for (it.start(); it.is_valid(); it.next()) + std::cout << it.to_point() << std::endl; +} + +template <typename Ps> +void rtest(const Ps& pset) +{ + typename Ps::bkd_piter it (pset); + + for (it.start(); it.is_valid(); it.next()) + std::cout << it.to_point() << std::endl; +} + + + template <typename I> + void print(I& ima) +{ + typename I::piter it (ima.points()); + + for (it.start(); it.is_valid(); it.next()) + { + std::cout << (oln::point2d) it << std::endl; + std::cout << ima(it) << std::endl; + } +} + + +int main() +{ + oln::point2d p(0,1), q(2,2), r(3, 0); + oln::image2d<int> ima2d (1, 5); + oln::sparse_image<oln::point2d, int> sparse; + oln::sparse_image<oln::point2d, int> sparse2; + + ima2d(oln::point2d(0, 4)) = 5; + oln::debug::print(ima2d); + + std::vector<int> values; + int a =5; + values.push_back(a); + a = 6; + values.push_back(a); + a = 42; + values.push_back(a); + + sparse.insert(q, 3, values); + + oln::debug::print(sparse); + + std::cout << "encode sparse" << std::endl; + sparse2 = sparse_encode(ima2d); + + oln::debug::print(sparse2); + + return 0; +} Index: tests/core/rle_image.cc --- tests/core/rle_image.cc (revision 0) +++ tests/core/rle_image.cc (revision 0) @@ -0,0 +1,74 @@ +#include <iostream> +#include <oln/core/rle/rle_psite.hh> +#include <oln/core/rle/rle_image.hh> +#include <oln/core/2d/image2d.hh> +#include <oln/debug/print.hh> +#include <oln/core/rle/rle_pset.hh> +#include <oln/core/encode/rle_encode.hh> + + +template <typename Ps> +void test(const Ps& pset) +{ + typename Ps::fwd_piter it (pset); + + for (it.start(); it.is_valid(); it.next()) + std::cout << it.to_point() << std::endl; +} + +template <typename Ps> +void rtest(const Ps& pset) +{ + typename Ps::bkd_piter it (pset); + + for (it.start(); it.is_valid(); it.next()) + std::cout << it.to_point() << std::endl; +} + + + template <typename I> + void print(I& ima) +{ + typename I::piter it (ima.points()); + + for (it.start(); it.is_valid(); it.next()) + { + std::cout << (oln::point2d) it << std::endl; + std::cout << ima(it) << std::endl; + } +} + + +int main() +{ + oln::point2d p(0,1), q(2,2), r(3, 0); + oln::rle_pset<oln::point2d> my_set; + oln::rle_image<oln::point2d, int> rle; + oln::rle_image<oln::point2d, int> rle2; + + my_set.insert(p, 5); + my_set.insert(q, 8); + + rle.insert(p, 5, 4); + rle.insert(q, 8, 9); + std::cout << my_set.has(q) << std::endl; + test(my_set); + std::cout << "reverse" << std::endl; + rtest(my_set); + std::cout << "ima" << std::endl; + print(rle); + + oln::debug::print(rle); + std::cout << rle.points().npoints() << std::endl; + + std::cout << "encode rle" << std::endl; + oln::image2d<int> ima2d (1, 5); + ima2d(oln::point2d(0, 4)) = 5; + + oln::debug::print(ima2d); + + rle2 = rle_encode(ima2d); + + oln::debug::print(rle2); + return 0; +} Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 880) +++ tests/core/Makefile.am (working copy) @@ -19,6 +19,8 @@ check_PROGRAMS = \ + rle_image \ + sparse_image \ apply \ dpoint2d \ point2d \ @@ -30,6 +32,7 @@ window2d \ at + # Images and auxiliary structures. dpoint2d_SOURCES = dpoint2d.cc point2d_SOURCES = point2d.cc @@ -39,6 +42,8 @@ npoints_SOURCES = npoints.cc subset_SOURCES = subset.cc window2d_SOURCES = window2d.cc +rle_image_SOURCES = rle_image.cc +sparse_image_SOURCES = sparse_image.cc # Methods. at_SOURCES = at.cc

17 years, 1 month

861: Add test for neighborhood.

by Ugo Jardonnet

Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Add test for neighborhood. * tests/core/neighb2d.cc: New. * tests/core/Makefile.am: . * oln/core/automatic/impl.hh: . * oln/core/abstract/internal/image_impl.hh: . oln/core/abstract/internal/image_impl.hh | 2 oln/core/automatic/impl.hh | 2 tests/core/Makefile.am | 2 tests/core/neighb2d.cc | 65 +++++++++++++++++++++++++++++++ 4 files changed, 69 insertions(+), 2 deletions(-) Index: tests/core/neighb2d.cc --- tests/core/neighb2d.cc (revision 0) +++ tests/core/neighb2d.cc (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. + +/// Test oln::neighb2d. + +#include <oln/core/2d/image2d.hh> +#include <oln/core/2d/neighb2d.hh> + + +namespace test +{ + + template <typename I> + unsigned run(const oln::Image_with_Nbh& input) + { + oln_piter(I) p(input.points()); + oln_niter(I) n(p, input.nbhood()); + unsigned count = 0; + + for_all(p) + { + for_all(n) + if (input.owns_(n)) + ++count; + } + return count; + } +} + + +int main() +{ + using namespace oln; + + image2d<bool> ima(3, 3); + // 2 + 3 + 2 + + // 3 + 4 + 3 + + // 2 + 3 + 2 = 24 + std::cout << test::run(ima + c4) << std::endl; + assert(test::run(ima + c4) == 24); +} Index: tests/core/Makefile.am --- tests/core/Makefile.am (revision 860) +++ tests/core/Makefile.am (working copy) @@ -24,6 +24,7 @@ grid \ image2d \ npoints \ + neighb2d \ window2d \ at @@ -34,6 +35,7 @@ image2d_SOURCES = image2d.cc npoints_SOURCES = npoints.cc window2d_SOURCES = window2d.cc +neighb2d_SOURCES = neighb2d.cc # Methods. at_SOURCES = at.cc Index: oln/core/automatic/impl.hh --- oln/core/automatic/impl.hh (revision 860) +++ oln/core/automatic/impl.hh (working copy) @@ -28,7 +28,7 @@ #ifndef OLN_CORE_AUTOMATIC_IMPL_HH # define OLN_CORE_AUTOMATIC_IMPL_HH -# include <oln/core/typedefs.hh> +// # include <oln/core/typedefs.hh> namespace oln Index: oln/core/abstract/internal/image_impl.hh --- oln/core/abstract/internal/image_impl.hh (revision 860) +++ oln/core/abstract/internal/image_impl.hh (working copy) @@ -29,7 +29,7 @@ # define OLN_CORE_ABSTRACT_INTERNAL_IMAGE_IMPL_HH # include <mlc/flags.hh> -# include <oln/core/typedefs.hh> +// # include <oln/core/typedefs.hh> # include <oln/core/abstract/any.hh> # include <oln/core/macros.hh>

17 years, 1 month

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches March 2007