8 #ifndef BOOST_GIL_ITERATOR_FROM_2D_HPP     9 #define BOOST_GIL_ITERATOR_FROM_2D_HPP    11 #include <boost/gil/concepts.hpp>    12 #include <boost/gil/locator.hpp>    13 #include <boost/gil/pixel_iterator.hpp>    14 #include <boost/gil/point.hpp>    16 #include <boost/assert.hpp>    17 #include <boost/iterator/iterator_facade.hpp>    19 namespace boost { 
namespace gil {
    41 template <
typename Loc2>    
    43                                                 typename Loc2::value_type,
    44                                                 std::random_access_iterator_tag,
    45                                                 typename Loc2::reference,
    46                                                 typename Loc2::coord_t> {
    49     using parent_t = iterator_facade<iterator_from_2d<Loc2>,
    50                             typename Loc2::value_type,
    51                             std::random_access_iterator_tag,
    52                             typename Loc2::reference,
    53                             typename Loc2::coord_t>;
    54     using reference = 
typename parent_t::reference;
    55     using difference_type = 
typename parent_t::difference_type;
    56     using x_iterator = 
typename Loc2::x_iterator;
    57     using point_t = 
typename Loc2::point_t;
    59     std::ptrdiff_t width()
         const { 
return _width; }            
    60     std::ptrdiff_t x_pos()
         const { 
return _coords.x; }         
    61     std::ptrdiff_t y_pos()
         const { 
return _coords.y; }         
    65     reference 
operator[](difference_type d)
 const { 
return *(*
this+d); }
    67     bool            is_1d_traversable()
 const { 
return _p.is_1d_traversable(width()); }   
    68     x_iterator&     x()                   { 
return _p.x(); }
    70     iterator_from_2d() = 
default;
    71     iterator_from_2d(
const Loc2& p, std::ptrdiff_t width, std::ptrdiff_t x=0, std::ptrdiff_t y=0) : _coords(x,y), _width(width), _p(p) {}
    72     iterator_from_2d(
const iterator_from_2d& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
    73     template <
typename Loc> iterator_from_2d(
const iterator_from_2d<Loc>& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
    74     iterator_from_2d& operator=(iterator_from_2d 
const& other) = 
default;
    77     template <
typename Loc> 
friend class iterator_from_2d;
    78     friend class boost::iterator_core_access;
    79     reference dereference()
 const { 
return *_p; }
    83         if (_coords.x>=_width) {
    86             _p+=point_t(-_width,1);
    95             _p+=point_t(_width,-1);
    99     BOOST_FORCEINLINE 
void advance(difference_type d) {
   100         if (_width==0) 
return;  
   102         if (_coords.x+d>=0) {  
   103             delta.x=(_coords.x+(std::ptrdiff_t)d)%_width - _coords.x;
   104             delta.y=(_coords.x+(std::ptrdiff_t)d)/_width;
   106             delta.x=(_coords.x+(std::ptrdiff_t)d*(1-_width))%_width -_coords.x;
   107             delta.y=-(_width-_coords.x-(std::ptrdiff_t)d-1)/_width;
   114     difference_type distance_to(
const iterator_from_2d& it)
 const {
   115         if (_width==0) 
return 0;
   116         return (it.y_pos()-_coords.y)*_width + (it.x_pos()-_coords.x);
   119     bool equal(iterator_from_2d 
const& it)
 const   121         BOOST_ASSERT(_width == it.width()); 
   122         return _coords == it._coords && _p == it._p;
   126     std::ptrdiff_t _width;
   130 template <
typename Loc> 
   131 struct const_iterator_type<iterator_from_2d<Loc> > {
   132     using type = iterator_from_2d<typename Loc::const_t>;
   135 template <
typename Loc> 
   136 struct iterator_is_mutable<iterator_from_2d<Loc> > : 
public iterator_is_mutable<typename Loc::x_iterator> {};
   143 template <
typename Loc>
   144 struct dynamic_x_step_type<iterator_from_2d<Loc> > {
   145     using type = iterator_from_2d<typename dynamic_x_step_type<Loc>::type>;
   153 template <
typename Loc> 
   154 struct color_space_type<iterator_from_2d<Loc> > : 
public color_space_type<Loc> {};
   156 template <
typename Loc> 
   157 struct channel_mapping_type<iterator_from_2d<Loc> > : 
public channel_mapping_type<Loc> {};
   159 template <
typename Loc> 
   160 struct is_planar<iterator_from_2d<Loc> > : 
public is_planar<Loc> {};
   162 template <
typename Loc> 
   163 struct channel_type<iterator_from_2d<Loc> > : 
public channel_type<Loc> {};
 Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept,...
Definition: iterator_from_2d.hpp:42
reference operator[](difference_type d) const
Definition: iterator_from_2d.hpp:65
GIL's 2-dimensional locator over immutable GIL pixels.
Definition: pixel_locator.hpp:291
BOOST_FORCEINLINE bool equal(boost::gil::iterator_from_2d< Loc1 > first, boost::gil::iterator_from_2d< Loc1 > last, boost::gil::iterator_from_2d< Loc2 > first2)
std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d
Definition: algorithm.hpp:1029