Chris@16: /*
Chris@16:     Copyright 2005-2007 Adobe Systems Incorporated
Chris@16:    
Chris@16:     Use, modification and distribution are subject to the Boost Software License,
Chris@16:     Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
Chris@16:     http://www.boost.org/LICENSE_1_0.txt).
Chris@16: 
Chris@16:     See http://opensource.adobe.com/gil for most recent version including documentation.
Chris@16: */
Chris@16: 
Chris@16: /*************************************************************************************************/
Chris@16: 
Chris@16: #ifndef GIL_PLANAR_PTR_H
Chris@16: #define GIL_PLANAR_PTR_H
Chris@16: 
Chris@16: ////////////////////////////////////////////////////////////////////////////////////////
Chris@16: /// \file               
Chris@16: /// \brief planar pixel pointer class
Chris@16: /// \author Lubomir Bourdev and Hailin Jin \n
Chris@16: ///         Adobe Systems Incorporated
Chris@16: /// \date   2005-2007 \n Last updated on February 12, 2007
Chris@16: ///
Chris@16: ////////////////////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: #include <cassert>
Chris@16: #include <iterator>
Chris@16: #include <boost/iterator/iterator_facade.hpp>
Chris@16: #include "gil_config.hpp"
Chris@16: #include "pixel.hpp"
Chris@16: #include "step_iterator.hpp"
Chris@16: 
Chris@16: namespace boost { namespace gil {
Chris@16: 
Chris@16: //forward declaration (as this file is included in planar_pixel_reference.hpp)
Chris@16: template <typename ChannelReference, typename ColorSpace> 
Chris@16: struct planar_pixel_reference;
Chris@16: 
Chris@16: /// \defgroup ColorBaseModelPlanarPtr planar_pixel_iterator 
Chris@16: /// \ingroup ColorBaseModel
Chris@16: /// \brief A homogeneous color base whose element is a channel iterator. Models HomogeneousColorBaseValueConcept
Chris@16: /// This class is used as an iterator to a planar pixel.
Chris@16: 
Chris@16: /// \defgroup PixelIteratorModelPlanarPtr planar_pixel_iterator
Chris@16: /// \ingroup PixelIteratorModel
Chris@16: /// \brief An iterator over planar pixels. Models PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept
Chris@16: 
Chris@16: ////////////////////////////////////////////////////////////////////////////////////////
Chris@16: /// \brief An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept
Chris@16: ///
Chris@16: /// Planar pixels have channel data that is not consecutive in memory.
Chris@16: /// To abstract this we use classes to represent references and pointers to planar pixels.
Chris@16: /// 
Chris@16: /// \ingroup PixelIteratorModelPlanarPtr ColorBaseModelPlanarPtr PixelBasedModel
Chris@16: template <typename ChannelPtr, typename ColorSpace>
Chris@16: struct planar_pixel_iterator : public iterator_facade<planar_pixel_iterator<ChannelPtr,ColorSpace>,
Chris@16:                                                       pixel<typename std::iterator_traits<ChannelPtr>::value_type,layout<ColorSpace> >,
Chris@16:                                                       std::random_access_iterator_tag,
Chris@16:                                                       const planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace> >,
Chris@16:                                public detail::homogeneous_color_base<ChannelPtr,layout<ColorSpace>,mpl::size<ColorSpace>::value > {
Chris@16: private:
Chris@16:     typedef iterator_facade<planar_pixel_iterator<ChannelPtr,ColorSpace>,
Chris@16:                             pixel<typename std::iterator_traits<ChannelPtr>::value_type,layout<ColorSpace> >,
Chris@16:                             std::random_access_iterator_tag,
Chris@16:                             const planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace> > parent_t;
Chris@16:     typedef detail::homogeneous_color_base<ChannelPtr,layout<ColorSpace>,mpl::size<ColorSpace>::value> color_base_parent_t;
Chris@16:     typedef typename std::iterator_traits<ChannelPtr>::value_type channel_t;
Chris@16: public:
Chris@16:     typedef typename parent_t::value_type                 value_type;
Chris@16:     typedef typename parent_t::reference                  reference;
Chris@16:     typedef typename parent_t::difference_type            difference_type;
Chris@16: 
Chris@16:     planar_pixel_iterator() : color_base_parent_t(0) {} 
Chris@16:     planar_pixel_iterator(bool) {}        // constructor that does not fill with zero (for performance)
Chris@16: 
Chris@16:     planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1) : color_base_parent_t(v0,v1) {}
Chris@16:     planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2) : color_base_parent_t(v0,v1,v2) {}
Chris@16:     planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3) : color_base_parent_t(v0,v1,v2,v3) {}
Chris@16:     planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3, const ChannelPtr& v4) : color_base_parent_t(v0,v1,v2,v3,v4) {}
Chris@16: 
Chris@16:     template <typename IC1,typename C1> 
Chris@16:     planar_pixel_iterator(const planar_pixel_iterator<IC1,C1>& ptr) : color_base_parent_t(ptr) {}
Chris@16: 
Chris@16: 
Chris@16:     /// Copy constructor and operator= from pointers to compatible planar pixels or planar pixel references.
Chris@16:     /// That allow constructs like pointer = &value or pointer = &reference
Chris@16:     /// Since we should not override operator& that's the best we can do.
Chris@16:     template <typename P> 
Chris@16:     planar_pixel_iterator(P* pix) : color_base_parent_t(pix, true) {
Chris@16:         function_requires<PixelsCompatibleConcept<P,value_type> >();
Chris@16:     }
Chris@16: 
Chris@16:     struct address_of { template <typename T> T* operator()(T& t) { return &t; } };
Chris@16:     template <typename P> 
Chris@16:     planar_pixel_iterator& operator=(P* pix) {
Chris@16:         function_requires<PixelsCompatibleConcept<P,value_type> >();
Chris@16:         static_transform(*pix,*this, address_of());
Chris@16: 
Chris@16:         // PERFORMANCE_CHECK: Compare to this:
Chris@16:         //this->template semantic_at_c<0>()=&pix->template semantic_at_c<0>();
Chris@16:         //this->template semantic_at_c<1>()=&pix->template semantic_at_c<1>();
Chris@16:         //this->template semantic_at_c<2>()=&pix->template semantic_at_c<2>();
Chris@16:         return *this;
Chris@16:     }
Chris@16: 
Chris@16:     /// For some reason operator[] provided by iterator_facade returns a custom class that is convertible to reference
Chris@16:     /// We require our own reference because it is registered in iterator_traits
Chris@16:     reference operator[](difference_type d)       const { return memunit_advanced_ref(*this,d*sizeof(channel_t));}
Chris@16: 
Chris@16:     reference operator->()                        const { return **this; }
Chris@16: 
Chris@16:     // PERFORMANCE_CHECK: Remove?
Chris@16:     bool operator< (const planar_pixel_iterator& ptr)   const { return gil::at_c<0>(*this)< gil::at_c<0>(ptr); }
Chris@16:     bool operator!=(const planar_pixel_iterator& ptr)   const { return gil::at_c<0>(*this)!=gil::at_c<0>(ptr); }
Chris@16: private:
Chris@16:     friend class boost::iterator_core_access;
Chris@16: 
Chris@16:     void increment()            { static_transform(*this,*this,detail::inc<ChannelPtr>()); }
Chris@16:     void decrement()            { static_transform(*this,*this,detail::dec<ChannelPtr>()); }
Chris@16:     void advance(ptrdiff_t d)   { static_transform(*this,*this,std::bind2nd(detail::plus_asymmetric<ChannelPtr,ptrdiff_t>(),d)); }
Chris@16:     reference dereference() const { return this->template deref<reference>(); }
Chris@16: 
Chris@16:     ptrdiff_t distance_to(const planar_pixel_iterator& it) const { return gil::at_c<0>(it)-gil::at_c<0>(*this); }
Chris@16:     bool equal(const planar_pixel_iterator& it) const { return gil::at_c<0>(*this)==gil::at_c<0>(it); }
Chris@16: };
Chris@16: 
Chris@16: namespace detail {
Chris@16:     template <typename IC> struct channel_iterator_is_mutable : public mpl::true_ {};
Chris@16:     template <typename T>  struct channel_iterator_is_mutable<const T*> : public mpl::false_ {};
Chris@16: }
Chris@16: 
Chris@16: template <typename IC, typename C> 
Chris@16: struct const_iterator_type<planar_pixel_iterator<IC,C> > { 
Chris@16: private:
Chris@16:     typedef typename std::iterator_traits<IC>::value_type channel_t;
Chris@16: public:
Chris@16:     typedef planar_pixel_iterator<typename channel_traits<channel_t>::const_pointer,C> type; 
Chris@16: };
Chris@16: 
Chris@16: // The default implementation when the iterator is a C pointer is to use the standard constness semantics
Chris@16: template <typename IC, typename C> 
Chris@16: struct iterator_is_mutable<planar_pixel_iterator<IC,C> > : public detail::channel_iterator_is_mutable<IC> {};
Chris@16: 
Chris@16: /////////////////////////////
Chris@16: //  ColorBasedConcept
Chris@16: /////////////////////////////
Chris@16: 
Chris@16: template <typename IC, typename C, int K>  
Chris@16: struct kth_element_type<planar_pixel_iterator<IC,C>, K> {
Chris@16:     typedef IC type;
Chris@16: };
Chris@16: 
Chris@16: template <typename IC, typename C, int K>  
Chris@16: struct kth_element_reference_type<planar_pixel_iterator<IC,C>, K> : public add_reference<IC> {};
Chris@16: 
Chris@16: template <typename IC, typename C, int K>  
Chris@16: struct kth_element_const_reference_type<planar_pixel_iterator<IC,C>, K> : public add_reference<typename add_const<IC>::type> {};
Chris@16: 
Chris@16: /////////////////////////////
Chris@16: //  HomogeneousPixelBasedConcept
Chris@16: /////////////////////////////
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: struct color_space_type<planar_pixel_iterator<IC,C> > {
Chris@16:     typedef C type;
Chris@16: };
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: struct channel_mapping_type<planar_pixel_iterator<IC,C> > : public channel_mapping_type<typename planar_pixel_iterator<IC,C>::value_type> {};
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: struct is_planar<planar_pixel_iterator<IC,C> > : public mpl::true_ {};
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: struct channel_type<planar_pixel_iterator<IC,C> > {
Chris@16:     typedef typename std::iterator_traits<IC>::value_type type;
Chris@16: };
Chris@16: 
Chris@16: /////////////////////////////
Chris@16: //  MemoryBasedIteratorConcept
Chris@16: /////////////////////////////
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: inline std::ptrdiff_t memunit_step(const planar_pixel_iterator<IC,C>&) { return sizeof(typename std::iterator_traits<IC>::value_type); }
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: inline std::ptrdiff_t memunit_distance(const planar_pixel_iterator<IC,C>& p1, const planar_pixel_iterator<IC,C>& p2) { 
Chris@16:     return memunit_distance(gil::at_c<0>(p1),gil::at_c<0>(p2)); 
Chris@16: }
Chris@16: 
Chris@16: template <typename IC>
Chris@16: struct memunit_advance_fn {
Chris@16:     memunit_advance_fn(std::ptrdiff_t diff) : _diff(diff) {}
Chris@16:     IC operator()(const IC& p) const { return memunit_advanced(p,_diff); }
Chris@16: 
Chris@16:     std::ptrdiff_t _diff;
Chris@16: };
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: inline void memunit_advance(planar_pixel_iterator<IC,C>& p, std::ptrdiff_t diff) { 
Chris@16:     static_transform(p, p, memunit_advance_fn<IC>(diff));
Chris@16: }
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: inline planar_pixel_iterator<IC,C> memunit_advanced(const planar_pixel_iterator<IC,C>& p, std::ptrdiff_t diff) {
Chris@16:     planar_pixel_iterator<IC,C> ret=p;
Chris@16:     memunit_advance(ret, diff);
Chris@16:     return ret;
Chris@16: }
Chris@16: 
Chris@16: template <typename ChannelPtr, typename ColorSpace>
Chris@16: inline planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace> 
Chris@16:     memunit_advanced_ref(const planar_pixel_iterator<ChannelPtr,ColorSpace>& ptr, std::ptrdiff_t diff) {
Chris@16:     return planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace>(ptr, diff);
Chris@16: }
Chris@16: 
Chris@16: /////////////////////////////
Chris@16: //  HasDynamicXStepTypeConcept
Chris@16: /////////////////////////////
Chris@16: 
Chris@16: template <typename IC, typename C>
Chris@16: struct dynamic_x_step_type<planar_pixel_iterator<IC,C> > {
Chris@16:     typedef memory_based_step_iterator<planar_pixel_iterator<IC,C> > type;
Chris@16: };
Chris@16: 
Chris@16: } }  // namespace boost::gil
Chris@16: 
Chris@16: #endif