locator.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_LOCATOR_H
00014 #define GIL_LOCATOR_H
00015 
00016 
00025 
00026 #include <cstddef>
00027 #include <cassert>
00028 #include "pixel_iterator.hpp"
00029 
00033 
00034 
00035 namespace boost { namespace gil {
00036 
00037 //forward declarations
00038 template <typename P> ptrdiff_t memunit_step(const P*);
00039 template <typename P> P* memunit_advanced(const P* p, ptrdiff_t diff);
00040 template <typename P> P& memunit_advanced_ref(P* p, ptrdiff_t diff);
00041 template <typename Iterator, typename D> struct iterator_add_deref;
00042 template <typename T> class point2;
00043 namespace detail {
00044     // helper class specialized for each axis of pixel_2d_locator
00045     template <std::size_t D, typename Loc>  class locator_axis;
00046 }
00047 template <typename T> struct dynamic_x_step_type;
00048 template <typename T> struct dynamic_y_step_type;
00049 
00050 template <typename T> struct channel_type;
00051 template <typename T> struct color_space_type;
00052 template <typename T> struct channel_mapping_type;
00053 template <typename T> struct is_planar;
00054 template <typename T> struct num_channels;
00055 
00056 // The type of a locator or a view that has X and Y swapped. By default it is the same
00057 template <typename T> struct transposed_type {
00058     typedef T type;
00059 };
00060 
00119 
00120 template <typename Loc, typename XIterator, typename YIterator>    // The concrete subclass, the X-iterator and the Y-iterator
00121 class pixel_2d_locator_base {
00122 public:
00123     typedef XIterator           x_iterator;
00124     typedef YIterator           y_iterator;
00125 
00126     // typedefs required by ConstRandomAccessNDLocatorConcept
00127     static const std::size_t num_dimensions=2;
00128     typedef typename std::iterator_traits<x_iterator>::value_type       value_type;
00129     typedef typename std::iterator_traits<x_iterator>::reference        reference;    // result of dereferencing
00130     typedef typename std::iterator_traits<x_iterator>::difference_type  coord_t;      // 1D difference type (same for all dimensions)
00131     typedef point2<coord_t>                                             difference_type; // result of operator-(locator,locator)
00132     typedef difference_type                                             point_t;
00133     template <std::size_t D> struct axis {
00134         typedef typename detail::locator_axis<D,Loc>::coord_t           coord_t;
00135         typedef typename detail::locator_axis<D,Loc>::iterator          iterator;
00136     };
00137 
00138 // typedefs required by ConstRandomAccess2DLocatorConcept
00139     typedef typename point_t::template axis<0>::coord_t                 x_coord_t;
00140     typedef typename point_t::template axis<1>::coord_t                 y_coord_t;
00141 
00142     bool              operator!=(const Loc& p)          const { return !(concrete()==p); }
00143 
00144     x_iterator        x_at(x_coord_t dx, y_coord_t dy)  const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.x(); }
00145     x_iterator        x_at(const difference_type& d)    const { Loc tmp=concrete(); tmp+=d;              return tmp.x(); }
00146     y_iterator        y_at(x_coord_t dx, y_coord_t dy)  const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.y(); }
00147     y_iterator        y_at(const difference_type& d)    const { Loc tmp=concrete(); tmp+=d;              return tmp.y(); }
00148     Loc               xy_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp; }
00149     Loc               xy_at(const difference_type& d)   const { Loc tmp=concrete(); tmp+=d;              return tmp; }
00150 
00151     template <std::size_t D> typename axis<D>::iterator&       axis_iterator()                       { return detail::locator_axis<D,Loc>()(concrete()); }
00152     template <std::size_t D> typename axis<D>::iterator const& axis_iterator()                 const { return detail::locator_axis<D,Loc>()(concrete()); }
00153     template <std::size_t D> typename axis<D>::iterator        axis_iterator(const point_t& p) const { return detail::locator_axis<D,Loc>()(concrete(),p); }
00154 
00155     reference         operator()(x_coord_t dx, y_coord_t dy) const { return *x_at(dx,dy); }
00156     reference         operator[](const difference_type& d)   const { return *x_at(d.x,d.y); }
00157 
00158     reference         operator*()                            const { return *concrete().x(); }
00159 
00160     Loc&              operator+=(const difference_type& d)         { concrete().x()+=d.x; concrete().y()+=d.y; return concrete(); }
00161     Loc&              operator-=(const difference_type& d)         { concrete().x()-=d.x; concrete().y()-=d.y; return concrete(); }
00162     
00163     Loc               operator+(const difference_type& d)    const { return xy_at(d); }
00164     Loc               operator-(const difference_type& d)    const { return xy_at(-d); }
00165 
00166     // Some locators can cache 2D coordinates for faster subsequent access. By default there is no caching
00167     typedef difference_type    cached_location_t;    
00168     cached_location_t cache_location(const difference_type& d)  const { return d; }
00169     cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return difference_type(dx,dy); }
00170 
00171 private:
00172     Loc&              concrete()       { return (Loc&)*this; }
00173     const Loc&        concrete() const { return (const Loc&)*this; }
00174 
00175     template <typename X> friend class pixel_2d_locator;
00176 };
00177 
00178 // helper classes for each axis of pixel_2d_locator_base
00179 namespace detail {
00180     template <typename Loc> 
00181     class locator_axis<0,Loc> {
00182         typedef typename Loc::point_t                       point_t;
00183     public:
00184         typedef typename point_t::template axis<0>::coord_t coord_t;
00185         typedef typename Loc::x_iterator                    iterator;
00186 
00187         inline iterator&        operator()(      Loc& loc)                   const { return loc.x(); }
00188         inline iterator  const& operator()(const Loc& loc)                   const { return loc.x(); }
00189         inline iterator         operator()(      Loc& loc, const point_t& d) const { return loc.x_at(d); }
00190         inline iterator         operator()(const Loc& loc, const point_t& d) const { return loc.x_at(d); }
00191     };
00192 
00193     template <typename Loc> 
00194     class locator_axis<1,Loc> {
00195         typedef typename Loc::point_t                       point_t;
00196     public:
00197         typedef typename point_t::template axis<1>::coord_t coord_t;
00198         typedef typename Loc::y_iterator                    iterator;
00199 
00200         inline iterator&        operator()(      Loc& loc)               const { return loc.y(); }
00201         inline iterator const&  operator()(const Loc& loc)               const { return loc.y(); }
00202         inline iterator     operator()(      Loc& loc, const point_t& d) const { return loc.y_at(d); }
00203         inline iterator     operator()(const Loc& loc, const point_t& d) const { return loc.y_at(d); }
00204     };
00205 }
00206 
00207 template <typename Loc, typename XIt, typename YIt>
00208 struct channel_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_type<XIt> {};
00209 
00210 template <typename Loc, typename XIt, typename YIt>
00211 struct color_space_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public color_space_type<XIt> {};
00212 
00213 template <typename Loc, typename XIt, typename YIt>
00214 struct channel_mapping_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_mapping_type<XIt> {};
00215 
00216 template <typename Loc, typename XIt, typename YIt>
00217 struct is_planar<pixel_2d_locator_base<Loc,XIt,YIt> > : public is_planar<XIt> {};
00218 
00239 
00240 template <typename StepIterator>
00241 class memory_based_2d_locator : public pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> {
00242     typedef memory_based_2d_locator<StepIterator>  this_t;
00243     GIL_CLASS_REQUIRE(StepIterator, boost::gil, StepIteratorConcept)
00244 public:
00245     typedef pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> parent_t;
00246     typedef memory_based_2d_locator<typename const_iterator_type<StepIterator>::type> const_t; // same as this type, but over const values
00247 
00248     typedef typename parent_t::coord_t          coord_t;
00249     typedef typename parent_t::x_coord_t        x_coord_t;
00250     typedef typename parent_t::y_coord_t        y_coord_t;
00251     typedef typename parent_t::x_iterator       x_iterator;
00252     typedef typename parent_t::y_iterator       y_iterator;
00253     typedef typename parent_t::difference_type  difference_type;
00254     typedef typename parent_t::reference        reference;
00255 
00256     template <typename Deref> struct add_deref {
00257         typedef memory_based_2d_locator<typename iterator_add_deref<StepIterator,Deref>::type> type;
00258         static type make(const memory_based_2d_locator<StepIterator>& loc, const Deref& nderef) { 
00259             return type(iterator_add_deref<StepIterator,Deref>::make(loc.y(),nderef)); 
00260         }
00261     };
00262 
00263     memory_based_2d_locator() {}
00264     memory_based_2d_locator(const StepIterator& yit) : _p(yit) {}
00265     template <typename SI> memory_based_2d_locator(const memory_based_2d_locator<SI>& loc, coord_t y_step) : _p(loc.x(), loc.row_size()*y_step) {}
00266     template <typename SI> memory_based_2d_locator(const memory_based_2d_locator<SI>& loc, coord_t x_step, coord_t y_step, bool transpose=false)
00267         : _p(make_step_iterator(loc.x(),(transpose ? loc.row_size() : loc.pixel_size())*x_step),
00268                                         (transpose ? loc.pixel_size() : loc.row_size())*y_step ) {}
00269 
00270     memory_based_2d_locator(x_iterator xit, std::ptrdiff_t row_bytes) : _p(xit,row_bytes) {}
00271     template <typename X> memory_based_2d_locator(const memory_based_2d_locator<X>& pl) : _p(pl._p) {}
00272     memory_based_2d_locator(const memory_based_2d_locator& pl) : _p(pl._p) {}
00273 
00274     bool                  operator==(const this_t& p)  const { return _p==p._p; }
00275 
00276     x_iterator const&     x()                          const { return _p.base(); }
00277     y_iterator const&     y()                          const { return _p; }
00278     x_iterator&           x()                                { return _p.base(); }
00279     y_iterator&           y()                                { return _p; }
00280 
00281     // These are faster versions of functions already provided in the superclass 
00282     x_iterator x_at      (x_coord_t dx, y_coord_t dy)  const { return memunit_advanced(x(), offset(dx,dy)); }    
00283     x_iterator x_at      (const difference_type& d)    const { return memunit_advanced(x(), offset(d.x,d.y)); }
00284     this_t     xy_at     (x_coord_t dx, y_coord_t dy)  const { return this_t(x_at( dx , dy ), row_size()); }
00285     this_t     xy_at     (const difference_type& d)    const { return this_t(x_at( d.x, d.y), row_size()); }
00286     reference  operator()(x_coord_t dx, y_coord_t dy)  const { return memunit_advanced_ref(x(),offset(dx,dy)); }
00287     reference  operator[](const difference_type& d)    const { return memunit_advanced_ref(x(),offset(d.x,d.y)); }
00288     this_t&    operator+=(const difference_type& d)          { memunit_advance(x(),offset(d.x,d.y)); return *this; }
00289     this_t&    operator-=(const difference_type& d)          { memunit_advance(x(),offset(-d.x,-d.y)); return *this; }
00290 
00291     // Memory-based locators can have 1D caching of 2D relative coordinates
00292     typedef std::ptrdiff_t cached_location_t; // type used to store relative location (to allow for more efficient repeated access)
00293     cached_location_t cache_location(const difference_type& d)  const { return offset(d.x,d.y); }
00294     cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return offset(dx,dy); }
00295     reference         operator[](const cached_location_t& loc)  const { return memunit_advanced_ref(x(),loc); }
00296 
00297     // Only make sense for memory-based locators
00298     std::ptrdiff_t         row_size()                           const { return memunit_step(y()); }    // distance in mem units (bytes or bits) between adjacent rows
00299     std::ptrdiff_t         pixel_size()                         const { return memunit_step(x()); }    // distance in mem units (bytes or bits) between adjacent pixels on the same row
00300 
00301     bool                   is_1d_traversable(x_coord_t width)   const { return row_size()-pixel_size()*width==0; }   // is there no gap at the end of each row?
00302 
00303     // Returns the vertical distance (it2.y-it1.y) between two x_iterators given the difference of their x positions
00304     std::ptrdiff_t y_distance_to(const this_t& p2, x_coord_t xDiff) const { 
00305         std::ptrdiff_t rowDiff=memunit_distance(x(),p2.x())-pixel_size()*xDiff;
00306         assert(( rowDiff % row_size())==0);
00307         return rowDiff / row_size();
00308     }
00309 
00310 private:
00311     template <typename X> friend class memory_based_2d_locator;
00312     std::ptrdiff_t offset(x_coord_t x, y_coord_t y)        const { return y*row_size() + x*pixel_size(); }
00313     StepIterator _p;
00314 };
00315 
00317 //  PixelBasedConcept
00319 
00320 template <typename SI>
00321 struct color_space_type<memory_based_2d_locator<SI> > : public color_space_type<typename memory_based_2d_locator<SI>::parent_t> {
00322 };
00323 
00324 template <typename SI>
00325 struct channel_mapping_type<memory_based_2d_locator<SI> > : public channel_mapping_type<typename memory_based_2d_locator<SI>::parent_t> {
00326 };
00327 
00328 template <typename SI>
00329 struct is_planar<memory_based_2d_locator<SI> > : public is_planar<typename memory_based_2d_locator<SI>::parent_t> {
00330 };
00331 
00332 template <typename SI>
00333 struct channel_type<memory_based_2d_locator<SI> > : public channel_type<typename memory_based_2d_locator<SI>::parent_t> {
00334 };
00335 
00337 //  HasDynamicXStepTypeConcept
00339 
00340 // Take the base iterator of SI (which is typically a step iterator) and change it to have a step in x
00341 template <typename SI>
00342 struct dynamic_x_step_type<memory_based_2d_locator<SI> > {
00343 private:
00344     typedef typename iterator_adaptor_get_base<SI>::type                        base_iterator_t;
00345     typedef typename dynamic_x_step_type<base_iterator_t>::type                 base_iterator_step_t;
00346     typedef typename iterator_adaptor_rebind<SI, base_iterator_step_t>::type    dynamic_step_base_t;
00347 public:
00348     typedef memory_based_2d_locator<dynamic_step_base_t> type;
00349 };
00350 
00352 //  HasDynamicYStepTypeConcept
00354 
00355 template <typename SI>
00356 struct dynamic_y_step_type<memory_based_2d_locator<SI> > {
00357     typedef memory_based_2d_locator<SI> type;
00358 };
00359 
00360 } }  // namespace boost::gil
00361 
00362 #endif
Статья Generic Image Library: locator.hpp Source File раздела может быть полезна для разработчиков на c++ и boost.
Generic Image Library: locator.hpp Source File

Boost , ,

locator.hpp
