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<P> >
+ {
+ typedef P point;
+ typedef typename P::grid grid;
+
+ typedef fbbox_<point> box;
+
+ typedef rle_pset_fwd_piter_<P> fwd_piter;
+ typedef rle_pset_bkd_piter_<P> bkd_piter;
+ typedef fwd_piter piter;
+ };
+
+ // rle_pset class
+
+ template <typename P>
+ class rle_pset : public internal::point_set_base_<rle_pset <P> >
+ {
+ typedef rle_pset<P> current;
+ typedef internal::point_set_base_<rle_pset<P> > 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<P>::rle_pset() : npts(0)
+ {
+ }
+
+
+ template <typename P>
+ unsigned
+ rle_pset<P>::impl_npoints() const
+ {
+ return npts;
+ }
+
+ template <typename P>
+ void
+ rle_pset<P>::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<P>::box&
+ rle_pset<P>::impl_bbox() const
+ {
+ return fb_;
+ }
+
+ template <typename P>
+ bool
+ rle_pset<P>::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<P>::std_container&
+ rle_pset<P>::con() const
+ {
+ return this->con_;
+ }
+
+
+# endif // !OLN_INCLUDE_ONLY
+
+
+ // -------------------- iterators on classes deriving from internal::rle_pset<P>
+
+ // Forward declaration
+ template <typename P>
+ class rle_pset_fwd_piter_;
+
+ // Virtual types
+ template <typename P>
+ struct vtypes< rle_pset_fwd_piter_<P> >
+ {
+ typedef P point;
+ };
+
+ // class rle_pset_fwd_iterator_
+ template <typename P>
+ class rle_pset_fwd_piter_ : public Iterator_on_Points< rle_pset_fwd_piter_<P> >
+ {
+ typedef Iterator_on_Points< rle_pset_fwd_piter_<P> > super;
+ typedef rle_pset_fwd_piter_<P> current;
+ public:
+ stc_using(point);
+
+ rle_pset_fwd_piter_(const rle_pset<P>& 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<P>::std_container& con_;
+ typename rle_pset<P>::std_container::const_iterator it_;
+ point p_;
+ };
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename P>
+ rle_pset_fwd_piter_<P>::rle_pset_fwd_piter_(const rle_pset<P>& cont) : con_(cont.con())
+ {
+ this->it_ = this->con_.end();
+ }
+
+ template <typename P>
+ void
+ rle_pset_fwd_piter_<P>::impl_start()
+ {
+ this->it_ = this->con_.begin();
+ this->p_ = this->it_->first;
+ }
+
+ template <typename P>
+ void
+ rle_pset_fwd_piter_<P>::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_<P>::impl_invalidate()
+ {
+ this->it_ = this->con_.end();
+ }
+
+ template <typename P>
+ bool
+ rle_pset_fwd_piter_<P>::impl_is_valid() const
+ {
+ return this->it_ != this->con_.end();
+ }
+
+ template <typename P>
+ typename rle_pset_fwd_piter_<P>::point
+ rle_pset_fwd_piter_<P>::impl_to_point() const
+ {
+ return p_;
+ }
+
+ template <typename P>
+ const typename rle_pset_fwd_piter_<P>::point*
+ rle_pset_fwd_piter_<P>::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_<P> >
+ {
+ typedef P point;
+ };
+
+ // class rle_pset_bkd_piter_
+
+ template <typename P>
+ class rle_pset_bkd_piter_ : public Iterator_on_Points< rle_pset_bkd_piter_<P> >
+ {
+ typedef Iterator_on_Points< rle_pset_bkd_piter_<P> > super;
+ typedef rle_pset_bkd_piter_<P> current;
+ public:
+ stc_using(point);
+
+ rle_pset_bkd_piter_(const rle_pset<P>& 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<P>::std_container& con_;
+ typename rle_pset<P>::std_container::const_reverse_iterator it_;
+ point p_;
+ };
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename P>
+ rle_pset_bkd_piter_<P>::rle_pset_bkd_piter_(const rle_pset<P>& cont) : con_(cont.con())
+ {
+ this->it_ = this->con_.rend();
+ }
+
+ template <typename P>
+ void
+ rle_pset_bkd_piter_<P>::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_<P>::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_<P>::impl_invalidate()
+ {
+ this->it_ = this->con_.rend();
+ }
+
+ template <typename P>
+ bool
+ rle_pset_bkd_piter_<P>::impl_is_valid() const
+ {
+ return this->it_ != this->con_.rend();
+ }
+
+ template <typename P>
+ typename rle_pset_bkd_piter_<P>::point
+ rle_pset_bkd_piter_<P>::impl_to_point() const
+ {
+ return p_;
+ }
+
+ template <typename P>
+ const typename rle_pset_bkd_piter_<P>::point*
+ rle_pset_bkd_piter_<P>::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_ */
