locator.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated Use, modification and distribution are subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). See http://opensource.adobe.com/gil for most recent version including documentation. */ /*************************************************************************************************/ #ifndef GIL_LOCATOR_H #define GIL_LOCATOR_H #include <cstddef> #include <cassert> #include "pixel_iterator.hpp" namespace boost { namespace gil { //forward declarations template <typename P> ptrdiff_t memunit_step(const P*); template <typename P> P* memunit_advanced(const P* p, ptrdiff_t diff); template <typename P> P& memunit_advanced_ref(P* p, ptrdiff_t diff); template <typename Iterator, typename D> struct iterator_add_deref; template <typename T> class point2; namespace detail { // helper class specialized for each axis of pixel_2d_locator template <std::size_t D, typename Loc> class locator_axis; } template <typename T> struct dynamic_x_step_type; template <typename T> struct dynamic_y_step_type; template <typename T> struct channel_type; template <typename T> struct color_space_type; template <typename T> struct channel_mapping_type; template <typename T> struct is_planar; template <typename T> struct num_channels; // The type of a locator or a view that has X and Y swapped. By default it is the same template <typename T> struct transposed_type { typedef T type; }; template <typename Loc, typename XIterator, typename YIterator> // The concrete subclass, the X-iterator and the Y-iterator class pixel_2d_locator_base { public: typedef XIterator x_iterator; typedef YIterator y_iterator; // typedefs required by ConstRandomAccessNDLocatorConcept static const std::size_t num_dimensions=2; typedef typename std::iterator_traits<x_iterator>::value_type value_type; typedef typename std::iterator_traits<x_iterator>::reference reference; // result of dereferencing typedef typename std::iterator_traits<x_iterator>::difference_type coord_t; // 1D difference type (same for all dimensions) typedef point2<coord_t> difference_type; // result of operator-(locator,locator) typedef difference_type point_t; template <std::size_t D> struct axis { typedef typename detail::locator_axis<D,Loc>::coord_t coord_t; typedef typename detail::locator_axis<D,Loc>::iterator iterator; }; // typedefs required by ConstRandomAccess2DLocatorConcept typedef typename point_t::template axis<0>::coord_t x_coord_t; typedef typename point_t::template axis<1>::coord_t y_coord_t; bool operator!=(const Loc& p) const { return !(concrete()==p); } x_iterator x_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.x(); } x_iterator x_at(const difference_type& d) const { Loc tmp=concrete(); tmp+=d; return tmp.x(); } y_iterator y_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.y(); } y_iterator y_at(const difference_type& d) const { Loc tmp=concrete(); tmp+=d; return tmp.y(); } Loc xy_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp; } Loc xy_at(const difference_type& d) const { Loc tmp=concrete(); tmp+=d; return tmp; } template <std::size_t D> typename axis<D>::iterator& axis_iterator() { return detail::locator_axis<D,Loc>()(concrete()); } template <std::size_t D> typename axis<D>::iterator const& axis_iterator() const { return detail::locator_axis<D,Loc>()(concrete()); } template <std::size_t D> typename axis<D>::iterator axis_iterator(const point_t& p) const { return detail::locator_axis<D,Loc>()(concrete(),p); } reference operator()(x_coord_t dx, y_coord_t dy) const { return *x_at(dx,dy); } reference operator[](const difference_type& d) const { return *x_at(d.x,d.y); } reference operator*() const { return *concrete().x(); } Loc& operator+=(const difference_type& d) { concrete().x()+=d.x; concrete().y()+=d.y; return concrete(); } Loc& operator-=(const difference_type& d) { concrete().x()-=d.x; concrete().y()-=d.y; return concrete(); } Loc operator+(const difference_type& d) const { return xy_at(d); } Loc operator-(const difference_type& d) const { return xy_at(-d); } // Some locators can cache 2D coordinates for faster subsequent access. By default there is no caching typedef difference_type cached_location_t; cached_location_t cache_location(const difference_type& d) const { return d; } cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return difference_type(dx,dy); } private: Loc& concrete() { return (Loc&)*this; } const Loc& concrete() const { return (const Loc&)*this; } template <typename X> friend class pixel_2d_locator; }; // helper classes for each axis of pixel_2d_locator_base namespace detail { template <typename Loc> class locator_axis<0,Loc> { typedef typename Loc::point_t point_t; public: typedef typename point_t::template axis<0>::coord_t coord_t; typedef typename Loc::x_iterator iterator; inline iterator& operator()( Loc& loc) const { return loc.x(); } inline iterator const& operator()(const Loc& loc) const { return loc.x(); } inline iterator operator()( Loc& loc, const point_t& d) const { return loc.x_at(d); } inline iterator operator()(const Loc& loc, const point_t& d) const { return loc.x_at(d); } }; template <typename Loc> class locator_axis<1,Loc> { typedef typename Loc::point_t point_t; public: typedef typename point_t::template axis<1>::coord_t coord_t; typedef typename Loc::y_iterator iterator; inline iterator& operator()( Loc& loc) const { return loc.y(); } inline iterator const& operator()(const Loc& loc) const { return loc.y(); } inline iterator operator()( Loc& loc, const point_t& d) const { return loc.y_at(d); } inline iterator operator()(const Loc& loc, const point_t& d) const { return loc.y_at(d); } }; } template <typename Loc, typename XIt, typename YIt> struct channel_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_type<XIt> {}; template <typename Loc, typename XIt, typename YIt> struct color_space_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public color_space_type<XIt> {}; template <typename Loc, typename XIt, typename YIt> struct channel_mapping_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_mapping_type<XIt> {}; template <typename Loc, typename XIt, typename YIt> struct is_planar<pixel_2d_locator_base<Loc,XIt,YIt> > : public is_planar<XIt> {}; template <typename StepIterator> class memory_based_2d_locator : public pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> { typedef memory_based_2d_locator<StepIterator> this_t; GIL_CLASS_REQUIRE(StepIterator, boost::gil, StepIteratorConcept) public: typedef pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> parent_t; typedef memory_based_2d_locator<typename const_iterator_type<StepIterator>::type> const_t; // same as this type, but over const values typedef typename parent_t::coord_t coord_t; typedef typename parent_t::x_coord_t x_coord_t; typedef typename parent_t::y_coord_t y_coord_t; typedef typename parent_t::x_iterator x_iterator; typedef typename parent_t::y_iterator y_iterator; typedef typename parent_t::difference_type difference_type; typedef typename parent_t::reference reference; template <typename Deref> struct add_deref { typedef memory_based_2d_locator<typename iterator_add_deref<StepIterator,Deref>::type> type; static type make(const memory_based_2d_locator<StepIterator>& loc, const Deref& nderef) { return type(iterator_add_deref<StepIterator,Deref>::make(loc.y(),nderef)); } }; memory_based_2d_locator() {} memory_based_2d_locator(const StepIterator& yit) : _p(yit) {} 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) {} 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) : _p(make_step_iterator(loc.x(),(transpose ? loc.row_size() : loc.pixel_size())*x_step), (transpose ? loc.pixel_size() : loc.row_size())*y_step ) {} memory_based_2d_locator(x_iterator xit, std::ptrdiff_t row_bytes) : _p(xit,row_bytes) {} template <typename X> memory_based_2d_locator(const memory_based_2d_locator<X>& pl) : _p(pl._p) {} memory_based_2d_locator(const memory_based_2d_locator& pl) : _p(pl._p) {} bool operator==(const this_t& p) const { return _p==p._p; } x_iterator const& x() const { return _p.base(); } y_iterator const& y() const { return _p; } x_iterator& x() { return _p.base(); } y_iterator& y() { return _p; } // These are faster versions of functions already provided in the superclass x_iterator x_at (x_coord_t dx, y_coord_t dy) const { return memunit_advanced(x(), offset(dx,dy)); } x_iterator x_at (const difference_type& d) const { return memunit_advanced(x(), offset(d.x,d.y)); } this_t xy_at (x_coord_t dx, y_coord_t dy) const { return this_t(x_at( dx , dy ), row_size()); } this_t xy_at (const difference_type& d) const { return this_t(x_at( d.x, d.y), row_size()); } reference operator()(x_coord_t dx, y_coord_t dy) const { return memunit_advanced_ref(x(),offset(dx,dy)); } reference operator[](const difference_type& d) const { return memunit_advanced_ref(x(),offset(d.x,d.y)); } this_t& operator+=(const difference_type& d) { memunit_advance(x(),offset(d.x,d.y)); return *this; } this_t& operator-=(const difference_type& d) { memunit_advance(x(),offset(-d.x,-d.y)); return *this; } // Memory-based locators can have 1D caching of 2D relative coordinates typedef std::ptrdiff_t cached_location_t; // type used to store relative location (to allow for more efficient repeated access) cached_location_t cache_location(const difference_type& d) const { return offset(d.x,d.y); } cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return offset(dx,dy); } reference operator[](const cached_location_t& loc) const { return memunit_advanced_ref(x(),loc); } // Only make sense for memory-based locators std::ptrdiff_t row_size() const { return memunit_step(y()); } // distance in mem units (bytes or bits) between adjacent rows std::ptrdiff_t pixel_size() const { return memunit_step(x()); } // distance in mem units (bytes or bits) between adjacent pixels on the same row 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? // Returns the vertical distance (it2.y-it1.y) between two x_iterators given the difference of their x positions std::ptrdiff_t y_distance_to(const this_t& p2, x_coord_t xDiff) const { std::ptrdiff_t rowDiff=memunit_distance(x(),p2.x())-pixel_size()*xDiff; assert(( rowDiff % row_size())==0); return rowDiff / row_size(); } private: template <typename X> friend class memory_based_2d_locator; std::ptrdiff_t offset(x_coord_t x, y_coord_t y) const { return y*row_size() + x*pixel_size(); } StepIterator _p; }; // PixelBasedConcept template <typename SI> struct color_space_type<memory_based_2d_locator<SI> > : public color_space_type<typename memory_based_2d_locator<SI>::parent_t> { }; template <typename SI> struct channel_mapping_type<memory_based_2d_locator<SI> > : public channel_mapping_type<typename memory_based_2d_locator<SI>::parent_t> { }; template <typename SI> struct is_planar<memory_based_2d_locator<SI> > : public is_planar<typename memory_based_2d_locator<SI>::parent_t> { }; template <typename SI> struct channel_type<memory_based_2d_locator<SI> > : public channel_type<typename memory_based_2d_locator<SI>::parent_t> { }; // HasDynamicXStepTypeConcept // Take the base iterator of SI (which is typically a step iterator) and change it to have a step in x template <typename SI> struct dynamic_x_step_type<memory_based_2d_locator<SI> > { private: typedef typename iterator_adaptor_get_base<SI>::type base_iterator_t; typedef typename dynamic_x_step_type<base_iterator_t>::type base_iterator_step_t; typedef typename iterator_adaptor_rebind<SI, base_iterator_step_t>::type dynamic_step_base_t; public: typedef memory_based_2d_locator<dynamic_step_base_t> type; }; // HasDynamicYStepTypeConcept template <typename SI> struct dynamic_y_step_type<memory_based_2d_locator<SI> > { typedef memory_based_2d_locator<SI> type; }; } } // namespace boost::gil #endif

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google