Information Home Overview Documentation Getting Started Release Notes ASL Wiki License Indices Success Stories Contributors Media Download ASL Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contributing to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe XMP Adobe Labs Other Resources Boost SGI STL

pixel_iterator.hpp Go to the documentation of this file. /* Copyright 2005-2006 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://opensource.adobe.com/licenses.html) */ /*************************************************************************************************/ #ifndef GIL_PIXEL_ITERATOR_H #define GIL_PIXEL_ITERATOR_H #include <cassert> #include <cstddef> #include <iterator> #include "gil_config.hpp" #include "gil_concept.hpp" #include "pixel.hpp" #include "planar_ptr.hpp" #include "locator.hpp" #include "pixel_iterator_traits.hpp" ADOBE_GIL_NAMESPACE_BEGIN template <typename IC, typename C> struct planar_ptr; namespace detail {template <typename T, typename C> struct color_base;} // Byte step template <typename P> inline std::ptrdiff_t byte_step(const P*) { return sizeof(P); } template <typename IC, typename C> inline std::ptrdiff_t byte_step(const planar_ptr<IC,C>&) { return sizeof(typename std::iterator_traits<IC>::value_type); } // byte_distance template <typename P> inline std::ptrdiff_t byte_distance(const P* p1, const P* p2) { return (reinterpret_cast<const unsigned char*>(p2)-reinterpret_cast<const unsigned char*>(p1)); } template <typename IC, typename C> inline std::ptrdiff_t byte_distance(const planar_ptr<IC,C>& p1, const planar_ptr<IC,C>& p2) { return byte_distance(p1.template channel<0>(),p2.template channel<0>()); } // byte_advance template <typename P> P* byte_advanced(const P* p, std::ptrdiff_t byteDiff); template <typename P> inline void byte_advance(P* &p, std::ptrdiff_t byteDiff) { p=(P*)((unsigned char*)(p)+byteDiff); } template <typename IC> struct byte_advance_fn { byte_advance_fn(std::ptrdiff_t byte_diff) : _byte_diff(byte_diff) {} IC operator()(const IC& p) const { return byte_advanced(p,_byte_diff); } std::ptrdiff_t _byte_diff; }; template <typename IC, typename C> inline void byte_advance(planar_ptr<IC,C>& p, std::ptrdiff_t byte_diff) { transform_channels(p, p, byte_advance_fn<IC>(byte_diff)); } // byte_advanced template <typename P> inline P* byte_advanced(const P* p, std::ptrdiff_t byteDiff) { return (P*)((unsigned char*)(p)+byteDiff); } template <typename IC, typename C> inline planar_ptr<IC,C> byte_advanced(const planar_ptr<IC,C>& p, std::ptrdiff_t byteDiff) { planar_ptr<IC,C> ret=p; byte_advance(ret, byteDiff); return ret; } // byte_advanced_ref // (shortcut to advancing a pointer by a given number of bytes and taking the reference in case the compiler is not smart enough) template <typename P> inline P& byte_advanced_ref(P* p, std::ptrdiff_t byteDiff) { return *byte_advanced(p,byteDiff); } template <typename I> class pixel_step_iterator; template <typename IT> struct byte_step_fn { typedef std::ptrdiff_t difference_type; byte_step_fn(difference_type step=byte_step(IT())) : _step(step) {} difference_type difference(const IT& it1, const IT& it2) const { return byte_distance(it1,it2)/_step; } void advance(IT& it, difference_type d) const { byte_advance(it,d*_step); } difference_type step() const { return _step; } void set_step(std::ptrdiff_t step) { _step=step; } private: GIL_CLASS_REQUIRE(IT, GIL, ByteAdvancableIteratorConcept); difference_type _step; }; template <typename IT> class pixel_step_iterator : public adobe::step_iterator_adaptor<pixel_step_iterator<IT>, IT, byte_step_fn<IT> > { GIL_CLASS_REQUIRE(IT, GIL, ByteAdvancableIteratorConcept); GIL_CLASS_REQUIRE(IT, GIL, PixelIteratorConcept); public: typedef adobe::step_iterator_adaptor<pixel_step_iterator<IT>, IT, byte_step_fn<IT> > parent_t; typedef std::random_access_iterator_tag iterator_category; // TODO: Fix that! typedef typename parent_t::reference reference; typedef typename parent_t::difference_type difference_type; typedef typename pixel_iterator_traits<IT>::channel_t channel_t; typedef typename pixel_iterator_traits<IT>::color_space_t color_space_t; typedef IT x_iterator; pixel_step_iterator() : parent_t(IT()) {} pixel_step_iterator(IT it, std::ptrdiff_t byte_step) : parent_t(it, byte_step_fn<IT>(byte_step)) {} template <typename I2> pixel_step_iterator(const pixel_step_iterator<I2>& it) : parent_t(it.base(), byte_step_fn<IT>(it.step())) {} reference operator[](difference_type d) const { return *(*this+d); } void set_step(std::ptrdiff_t byte_step) { this->_step_fn.set_step(byte_step); } x_iterator& base() { return parent_t::base_reference(); } x_iterator const& base() const { return parent_t::base_reference(); } }; template <typename IT> inline std::ptrdiff_t byte_step(const pixel_step_iterator<IT>& p) { return p.step(); } template <typename IT> inline std::ptrdiff_t byte_distance(const pixel_step_iterator<IT>& p1, const pixel_step_iterator<IT>& p2) { return byte_distance(p1.base(),p2.base()); } template <typename IT> inline void byte_advance(pixel_step_iterator<IT>& p, std::ptrdiff_t byteDiff) { byte_advance(p.base(), byteDiff); } template <typename IT> inline pixel_step_iterator<IT> byte_advanced(const pixel_step_iterator<IT>& p, std::ptrdiff_t byteDiff) { return pixel_step_iterator<IT>(byte_advanced(p.base(), byteDiff),p.step()); } template <typename IT> inline typename std::iterator_traits<IT>::reference byte_advanced_ref(const pixel_step_iterator<IT>& p, std::ptrdiff_t byteDiff) { return byte_advanced_ref(p.base(), byteDiff); } template <typename IT> struct iterator_is_step<pixel_step_iterator<IT> > { static const bool value = true; }; template <typename LOC2> // Models PixelLocatorConcept class pixel_image_iterator : public boost::iterator_facade<pixel_image_iterator<LOC2>, typename LOC2::value_type, boost::random_access_traversal_tag, typename LOC2::reference, typename LOC2::coord_t> { GIL_CLASS_REQUIRE(LOC2, GIL, PixelLocatorConcept); public: typedef boost::iterator_facade<pixel_image_iterator<LOC2>, typename LOC2::value_type, boost::random_access_traversal_tag, typename LOC2::reference, typename LOC2::coord_t> parent_t; typedef std::random_access_iterator_tag iterator_category; // TODO: Fix that! typedef typename parent_t::reference reference; typedef typename parent_t::difference_type difference_type; typedef typename LOC2::x_iterator x_iterator; typedef typename LOC2::point_t point_t; typedef typename LOC2::pixel_t pixel_t; int width() const { return _width; } // number of pixels per image row int x_pos() const { return _x; } // current x position reference operator[](difference_type d) const { return *(*this+d); } bool is_contiguous() const { return _p.row_bytes()-_p.pix_bytestep()*width()==0; } // is there no gap at the end of each row? x_iterator& x() { return _p.x(); } pixel_image_iterator(){} pixel_image_iterator(const LOC2& p, int width, int x=0) : _x(x), _width(width), _p(p) {} pixel_image_iterator(const pixel_image_iterator& pit) : _x(pit._x), _width(pit._width), _p(pit._p) {} template <typename LOC> pixel_image_iterator(const pixel_image_iterator<LOC>& pit) : _x(pit._x), _width(pit._width), _p(pit._p) {} private: template <typename LOC> friend class pixel_image_iterator; friend class boost::iterator_core_access; reference dereference() const { return *_p; } void increment() { ++_x; ++_p.x(); if (_x>=_width) { _x=0; _p+=point_t(-_width,1); } } void decrement() { --_x; --_p.x(); if (_x<0) { _x=_width-1; _p+=point_t(_width,-1); } } GIL_FORCEINLINE void advance(difference_type d) { if (_width==0) return; // unfortunately we need to check for that. Default-constructed images have width of 0 and the code below will throw if executed. point_t delta; if (_x+d>=0) { // not going back to a previous row? delta.x=(_x+(int)d)%_width - _x; delta.y=(_x+(int)d)/_width; } else { delta.x=(_x+(int)d*(1-_width))%_width -_x; delta.y=-(_width-_x-(int)d-1)/_width; } _p+=delta; _x+=delta.x; } difference_type distance_to(const pixel_image_iterator& it) const { if (_width==0) return 0; std::ptrdiff_t xByteDiff=_p.pix_bytestep()*(it.x_pos()-_x); // distance to align the x coordinate std::ptrdiff_t rowDiff=byte_distance(_p.x(),it._p.x())-xByteDiff; assert(( rowDiff % _p.row_bytes())==0); std::ptrdiff_t rows=rowDiff / _p.row_bytes(); return rows*_width+it.x_pos()-_x; } bool equal(const pixel_image_iterator& it) const { assert(_width==it.width()); // they must belong to the same image return _p==it._p; } int _x,_width; LOC2 _p; }; // DEREFERENCE ITERATOR ADAPTOR template <typename IT, // Models Iterator typename D_FN> // Models Unary Function. Returns the result of dereferencing a given iterator of type IT class dereference_iterator_adaptor : public boost::iterator_adaptor<dereference_iterator_adaptor<IT,D_FN>, IT, boost::use_default, boost::use_default, typename D_FN::result_type, boost::use_default> { D_FN _deref_fn; public: typedef boost::iterator_adaptor<dereference_iterator_adaptor<IT,D_FN>, IT, boost::use_default, boost::use_default, typename D_FN::result_type, boost::use_default> parent_t; typedef typename D_FN::result_type reference; typedef typename std::iterator_traits<IT>::difference_type difference_type; typedef std::random_access_iterator_tag iterator_category; // TODO: Fix that! typedef D_FN dereference_fn; dereference_iterator_adaptor() {} dereference_iterator_adaptor(IT it, D_FN deref_fn=D_FN()) : parent_t(it), _deref_fn(deref_fn) {} template <typename IT1, typename DFN1> dereference_iterator_adaptor(const dereference_iterator_adaptor<IT1,DFN1>& it) : parent_t(it.base()), _deref_fn(it._deref_fn) {} reference operator[](difference_type d) const { return *(*this+d);} // although boost::iterator_adaptor defines these, the default implementation computes distance and compares for zero. // it is often faster to just apply the relation operator to the base bool operator> (const dereference_iterator_adaptor& p) const { return this->base_reference()> p.base_reference(); } bool operator< (const dereference_iterator_adaptor& p) const { return this->base_reference()< p.base_reference(); } bool operator>=(const dereference_iterator_adaptor& p) const { return this->base_reference()>=p.base_reference(); } bool operator<=(const dereference_iterator_adaptor& p) const { return this->base_reference()<=p.base_reference(); } bool operator==(const dereference_iterator_adaptor& p) const { return this->base_reference()==p.base_reference(); } bool operator!=(const dereference_iterator_adaptor& p) const { return this->base_reference()!=p.base_reference(); } IT& base() { return this->base_reference(); } const IT& base() const { return this->base_reference(); } private: template <typename IT1, typename DFN1> friend class dereference_iterator_adaptor; friend class boost::iterator_core_access; reference dereference() const { return _deref_fn(this->base_reference()); } }; template <typename IT, typename D_FN> inline typename std::iterator_traits<IT>::difference_type byte_step(const dereference_iterator_adaptor<IT,D_FN>& p) { return byte_step(p.base()); } template <typename IT, typename D_FN> inline typename std::iterator_traits<IT>::difference_type byte_distance(const dereference_iterator_adaptor<IT,D_FN>& p1, const dereference_iterator_adaptor<IT,D_FN>& p2) { return byte_distance(p1.base(),p2.base()); } template <typename IT, typename D_FN> inline void byte_advance(dereference_iterator_adaptor<IT,D_FN>& p, typename std::iterator_traits<IT>::difference_type byteDiff) { byte_advance(p.base(), byteDiff); } template <typename IT, typename D_FN> inline dereference_iterator_adaptor<IT,D_FN> byte_advanced(dereference_iterator_adaptor<IT,D_FN>& p, typename std::iterator_traits<IT>::difference_type byteDiff) { return dereference_iterator_adaptor<IT,D_FN>(byte_advanced(p.base(), byteDiff)); } template <typename IT, typename D_FN> inline dereference_iterator_adaptor<IT,D_FN> byte_advanced(const dereference_iterator_adaptor<IT,D_FN>& p, typename std::iterator_traits<IT>::difference_type byteDiff) { return dereference_iterator_adaptor<IT,D_FN>(byte_advanced(p.base(), byteDiff)); } template <typename IT, typename D_FN> inline typename std::iterator_traits<dereference_iterator_adaptor<IT,D_FN> >::reference byte_advanced_ref(const dereference_iterator_adaptor<IT,D_FN>& p, typename std::iterator_traits<IT>::difference_type byteDiff) { return *byte_advanced(p, byteDiff); } template <typename I, typename D_FN> struct iterator_is_step<dereference_iterator_adaptor<I,D_FN> > { static const bool value = iterator_is_step<I>::value; }; ADOBE_GIL_NAMESPACE_END #endif

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

Copyright © 2006 Adobe Systems Incorporated.

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

Search powered by Google