x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
planar_pixel_iterator.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\gil\planar_pixel_iterator.hpp
旋转
特效
属性
历史版本
/* 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_PLANAR_PTR_H #define GIL_PLANAR_PTR_H //////////////////////////////////////////////////////////////////////////////////////// /// \file /// \brief planar pixel pointer class /// \author Lubomir Bourdev and Hailin Jin \n /// Adobe Systems Incorporated /// \date 2005-2007 \n Last updated on February 12, 2007 /// //////////////////////////////////////////////////////////////////////////////////////// #include
#include
#include
#include "gil_config.hpp" #include "pixel.hpp" #include "step_iterator.hpp" namespace boost { namespace gil { //forward declaration (as this file is included in planar_pixel_reference.hpp) template
struct planar_pixel_reference; /// \defgroup ColorBaseModelPlanarPtr planar_pixel_iterator /// \ingroup ColorBaseModel /// \brief A homogeneous color base whose element is a channel iterator. Models HomogeneousColorBaseValueConcept /// This class is used as an iterator to a planar pixel. /// \defgroup PixelIteratorModelPlanarPtr planar_pixel_iterator /// \ingroup PixelIteratorModel /// \brief An iterator over planar pixels. Models PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept //////////////////////////////////////////////////////////////////////////////////////// /// \brief An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept /// /// Planar pixels have channel data that is not consecutive in memory. /// To abstract this we use classes to represent references and pointers to planar pixels. /// /// \ingroup PixelIteratorModelPlanarPtr ColorBaseModelPlanarPtr PixelBasedModel template
struct planar_pixel_iterator : public iterator_facade
, pixel
::value_type,layout
>, random_access_traversal_tag, const planar_pixel_reference
::reference,ColorSpace> >, public detail::homogeneous_color_base
,mpl::size
::value > { private: typedef iterator_facade
, pixel
::value_type,layout
>, random_access_traversal_tag, const planar_pixel_reference
::reference,ColorSpace> > parent_t; typedef detail::homogeneous_color_base
,mpl::size
::value> color_base_parent_t; typedef typename std::iterator_traits
::value_type channel_t; public: typedef typename parent_t::value_type value_type; typedef typename parent_t::reference reference; typedef typename parent_t::difference_type difference_type; planar_pixel_iterator() : color_base_parent_t(0) {} planar_pixel_iterator(bool) {} // constructor that does not fill with zero (for performance) planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1) : color_base_parent_t(v0,v1) {} planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2) : color_base_parent_t(v0,v1,v2) {} planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3) : color_base_parent_t(v0,v1,v2,v3) {} 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) {} template
planar_pixel_iterator(const planar_pixel_iterator
& ptr) : color_base_parent_t(ptr) {} /// Copy constructor and operator= from pointers to compatible planar pixels or planar pixel references. /// That allow constructs like pointer = &value or pointer = &reference /// Since we should not override operator& that's the best we can do. template
planar_pixel_iterator(P* pix) : color_base_parent_t(pix, true) { function_requires
>(); } struct address_of { template
T* operator()(T& t) { return &t; } }; template
planar_pixel_iterator& operator=(P* pix) { function_requires
>(); static_transform(*pix,*this, address_of()); // PERFORMANCE_CHECK: Compare to this: //this->template semantic_at_c<0>()=&pix->template semantic_at_c<0>(); //this->template semantic_at_c<1>()=&pix->template semantic_at_c<1>(); //this->template semantic_at_c<2>()=&pix->template semantic_at_c<2>(); return *this; } /// For some reason operator[] provided by iterator_facade returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { return memunit_advanced_ref(*this,d*sizeof(channel_t));} reference operator->() const { return **this; } // PERFORMANCE_CHECK: Remove? bool operator< (const planar_pixel_iterator& ptr) const { return at_c<0>(*this)< at_c<0>(ptr); } bool operator!=(const planar_pixel_iterator& ptr) const { return at_c<0>(*this)!=at_c<0>(ptr); } private: friend class boost::iterator_core_access; void increment() { static_transform(*this,*this,detail::inc
()); } void decrement() { static_transform(*this,*this,detail::dec
()); } void advance(ptrdiff_t d) { static_transform(*this,*this,std::bind2nd(detail::plus_asymmetric
(),d)); } reference dereference() const { return this->template deref
(); } ptrdiff_t distance_to(const planar_pixel_iterator& it) const { return at_c<0>(it)-at_c<0>(*this); } bool equal(const planar_pixel_iterator& it) const { return at_c<0>(*this)==at_c<0>(it); } }; namespace detail { template
struct channel_iterator_is_mutable : public mpl::true_ {}; template
struct channel_iterator_is_mutable
: public mpl::false_ {}; } template
struct const_iterator_type
> { private: typedef typename std::iterator_traits
::value_type channel_t; public: typedef planar_pixel_iterator
::const_pointer,C> type; }; // The default implementation when the iterator is a C pointer is to use the standard constness semantics template
struct iterator_is_mutable
> : public detail::channel_iterator_is_mutable
{}; ///////////////////////////// // ColorBasedConcept ///////////////////////////// template
struct kth_element_type
, K> { typedef IC type; }; template
struct kth_element_reference_type
, K> : public add_reference
{}; template
struct kth_element_const_reference_type
, K> : public add_reference
::type> {}; ///////////////////////////// // HomogeneousPixelBasedConcept ///////////////////////////// template
struct color_space_type
> { typedef C type; }; template
struct channel_mapping_type
> : public channel_mapping_type
::value_type> {}; template
struct is_planar
> : public mpl::true_ {}; template
struct channel_type
> { typedef typename std::iterator_traits
::value_type type; }; ///////////////////////////// // MemoryBasedIteratorConcept ///////////////////////////// template
inline std::ptrdiff_t memunit_step(const planar_pixel_iterator
&) { return sizeof(typename std::iterator_traits
::value_type); } template
inline std::ptrdiff_t memunit_distance(const planar_pixel_iterator
& p1, const planar_pixel_iterator
& p2) { return memunit_distance(at_c<0>(p1),at_c<0>(p2)); } template
struct memunit_advance_fn { memunit_advance_fn(std::ptrdiff_t diff) : _diff(diff) {} IC operator()(const IC& p) const { return memunit_advanced(p,_diff); } std::ptrdiff_t _diff; }; template
inline void memunit_advance(planar_pixel_iterator
& p, std::ptrdiff_t diff) { static_transform(p, p, memunit_advance_fn
(diff)); } template
inline planar_pixel_iterator
memunit_advanced(const planar_pixel_iterator
& p, std::ptrdiff_t diff) { planar_pixel_iterator
ret=p; memunit_advance(ret, diff); return ret; } template
inline planar_pixel_reference
::reference,ColorSpace> memunit_advanced_ref(const planar_pixel_iterator
& ptr, std::ptrdiff_t diff) { return planar_pixel_reference
::reference,ColorSpace>(ptr, diff); } ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template
struct dynamic_x_step_type
> { typedef memory_based_step_iterator
> type; }; } } // namespace boost::gil #endif
planar_pixel_iterator.hpp
网页地址
文件地址
上一页
26/34
下一页
下载
( 10 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.