Modules | Alphabetical List | Class List | Directories | File List | GIL Home Page

# position_iterator.hpp

Go to the documentation of this file.

    00001 /*
    00002     Copyright 2005-2007 Adobe Systems Incorporated
    00003
    00004     Use, modification and distribution are subject to the Boost Software License,
    00005     Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    00006     http://www.boost.org/LICENSE_1_0.txt).
    00007
    00008     See http://opensource.adobe.com/gil for most recent version including documentation.
    00009 */
    00010
    00011 /*************************************************************************************************/
    00012
    00013 #ifndef GIL_POSITION_ITERATOR_HPP
    00014 #define GIL_POSITION_ITERATOR_HPP
    00015
    00024
    00025 #include <boost/iterator/iterator_facade.hpp>
    00026 #include "locator.hpp"
    00027
    00028 namespace boost { namespace gil {
    00029
    00033
    00034
    00038 template <typename Deref, // A function object that given a point returns a pixel reference. Models PixelDereferenceAdaptorConcept
    00039           int Dim>        // the dimension to advance along
    00040 struct position_iterator : public iterator_facade<position_iterator<Deref,Dim>,
    00041                                                   typename Deref::value_type,
    00042                                                   random_access_traversal_tag,
    00043                                                   typename Deref::reference,
    00044                                                   typename Deref::argument_type::template axis<Dim>::coord_t> {
    00045     typedef iterator_facade<position_iterator<Deref,Dim>,
    00046                             typename Deref::value_type,
    00047                             random_access_traversal_tag,
    00048                             typename Deref::reference,
    00049                             typename Deref::argument_type::template axis<Dim>::coord_t> parent_t;
    00050     typedef typename parent_t::difference_type difference_type;
    00051     typedef typename parent_t::reference       reference;
    00052     typedef typename Deref::argument_type      point_t;
    00053
    00054     position_iterator() {}
    00055     position_iterator(const point_t& p, const point_t& step, const Deref& d) : _p(p), _step(step), _d(d) {}
    00056
    00057     position_iterator(const position_iterator& p) : _p(p._p), _step(p._step), _d(p._d) {}
    00058     template <typename D> position_iterator(const position_iterator<D,Dim>& p) : _p(p._p), _step(p._step), _d(p._d) {}
    00059     position_iterator& operator=(const position_iterator& p) { _p=p._p; _d=p._d; _step=p._step; return *this; }
    00060
    00061     const point_t&   pos()      const { return _p; }
    00062     const point_t&   step()     const { return _step; }
    00063     const Deref&     deref_fn() const { return _d; }
    00064
    00065     void set_step(difference_type s) { _step[Dim]=s; }
    00068     reference operator[](difference_type d) const { point_t p=_p; p[Dim]+=d*_step[Dim]; return _d(p); }
    00069
    00070 private:
    00071     point_t _p, _step;
    00072     Deref   _d;
    00073
    00074     template <typename DE, int DI> friend struct position_iterator;
    00075     friend class boost::iterator_core_access;
    00076     reference dereference()     const { return _d(_p); }
    00077     void increment()                  { _p[Dim]+=_step[Dim]; }
    00078     void decrement()                  { _p[Dim]-=_step[Dim]; }
    00079     void advance(difference_type d)   { _p[Dim]+=d*_step[Dim]; }
    00080
    00081     difference_type distance_to(const position_iterator& it) const { return (it._p[Dim]-_p[Dim])/_step[Dim]; }
    00082     bool equal(const position_iterator& it) const { return _p==it._p; }
    00083 };
    00084
    00085 template <typename Deref,int Dim>
    00086 struct const_iterator_type<position_iterator<Deref,Dim> > {
    00087     typedef position_iterator<typename Deref::const_t,Dim> type;
    00088 };
    00089
    00090 template <typename Deref,int Dim>
    00091 struct iterator_is_mutable<position_iterator<Deref,Dim> > : public mpl::bool_<Deref::is_mutable> {
    00092 };
    00093
    00095 //  PixelBasedConcept
    00097
    00098 template <typename Deref,int Dim>
    00099 struct color_space_type<position_iterator<Deref,Dim> > : public color_space_type<typename Deref::value_type> {};
    00100
    00101 template <typename Deref,int Dim>
    00102 struct channel_mapping_type<position_iterator<Deref,Dim> > : public channel_mapping_type<typename Deref::value_type> {};
    00103
    00104 template <typename Deref,int Dim>
    00105 struct is_planar<position_iterator<Deref,Dim> > : public mpl::false_ {};
    00106
    00107 template <typename Deref,int Dim>
    00108 struct channel_type<position_iterator<Deref,Dim> > : public channel_type<typename Deref::value_type> {};
    00109
    00111 //  HasDynamicXStepTypeConcept
    00113
    00114 template <typename Deref,int Dim>
    00115 struct dynamic_x_step_type<position_iterator<Deref,Dim> > {
    00116     typedef position_iterator<Deref,Dim> type;
    00117 };
    00118
    00119 } }  // namespace boost::gil
    00120
    00121 #endif