1/*
2 Copyright 2005-2007 Adobe Systems Incorporated
3
4 Use, modification and distribution are subject to the Boost Software License,
5 Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
6 http://www.boost.org/LICENSE_1_0.txt).
7
8 See http://opensource.adobe.com/gil for most recent version including documentation.
9*/
10
11/*************************************************************************************************/
12
13#ifndef GIL_BIT_ALIGNED_PIXEL_ITERATOR_HPP
14#define GIL_BIT_ALIGNED_PIXEL_ITERATOR_HPP
15
16////////////////////////////////////////////////////////////////////////////////////////
17/// \file
18/// \brief A model of a heterogeneous pixel that is not byte aligned. Examples are bitmap (1-bit pixels) or 6-bit RGB (222)
19/// \author Lubomir Bourdev and Hailin Jin \n
20/// Adobe Systems Incorporated
21/// \date 2005-2007 \n Last updated on September 28, 2006
22///
23////////////////////////////////////////////////////////////////////////////////////////
24
25#include <functional>
26#include <boost/iterator/iterator_facade.hpp>
27#include "gil_config.hpp"
28#include "bit_aligned_pixel_reference.hpp"
29#include "pixel_iterator.hpp"
30
31namespace boost { namespace gil {
32
33/// \defgroup PixelIteratorNonAlignedPixelIterator bit_aligned_pixel_iterator
34/// \ingroup PixelIteratorModel
35/// \brief An iterator over non-byte-aligned pixels. Models PixelIteratorConcept, PixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept
36
37////////////////////////////////////////////////////////////////////////////////////////
38/// \brief An iterator over non-byte-aligned pixels. Models PixelIteratorConcept, PixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept
39///
40/// An iterator over pixels that correspond to non-byte-aligned bit ranges. Examples of such pixels are single bit grayscale pixel, or a 6-bit RGB 222 pixel.
41///
42/// \ingroup PixelIteratorNonAlignedPixelIterator PixelBasedModel
43
44template <typename NonAlignedPixelReference>
45struct bit_aligned_pixel_iterator : public iterator_facade<bit_aligned_pixel_iterator<NonAlignedPixelReference>,
46 typename NonAlignedPixelReference::value_type,
47 std::random_access_iterator_tag,
48 const NonAlignedPixelReference,
49 typename NonAlignedPixelReference::bit_range_t::difference_type> {
50private:
51 typedef iterator_facade<bit_aligned_pixel_iterator<NonAlignedPixelReference>,
52 typename NonAlignedPixelReference::value_type,
53 std::random_access_iterator_tag,
54 const NonAlignedPixelReference,
55 typename NonAlignedPixelReference::bit_range_t::difference_type> parent_t;
56 template <typename Ref> friend struct bit_aligned_pixel_iterator;
57
58 typedef typename NonAlignedPixelReference::bit_range_t bit_range_t;
59public:
60 typedef typename parent_t::difference_type difference_type;
61 typedef typename parent_t::reference reference;
62
63 bit_aligned_pixel_iterator() {}
64 bit_aligned_pixel_iterator(const bit_aligned_pixel_iterator& p) : _bit_range(p._bit_range) {}
65 bit_aligned_pixel_iterator& operator=(const bit_aligned_pixel_iterator& p) { _bit_range=p._bit_range; return *this; }
66
67 template <typename Ref> bit_aligned_pixel_iterator(const bit_aligned_pixel_iterator<Ref>& p) : _bit_range(p._bit_range) {}
68
69 bit_aligned_pixel_iterator(reference* ref) : _bit_range(ref->bit_range()) {}
70 explicit bit_aligned_pixel_iterator(typename bit_range_t::byte_t* data, int bit_offset=0) : _bit_range(data,bit_offset) {}
71
72 /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference
73 /// We require our own reference because it is registered in iterator_traits
74 reference operator[](difference_type d) const { bit_aligned_pixel_iterator it=*this; it.advance(d); return *it; }
75
76 reference operator->() const { return **this; }
77 const bit_range_t& bit_range() const { return _bit_range; }
78 bit_range_t& bit_range() { return _bit_range; }
79private:
80 bit_range_t _bit_range;
81 BOOST_STATIC_CONSTANT(int, bit_size = NonAlignedPixelReference::bit_size);
82
83 friend class boost::iterator_core_access;
84 reference dereference() const { return NonAlignedPixelReference(_bit_range); }
85 void increment() { ++_bit_range; }
86 void decrement() { --_bit_range; }
87 void advance(difference_type d) { _bit_range.bit_advance(d*bit_size); }
88
89 difference_type distance_to(const bit_aligned_pixel_iterator& it) const { return _bit_range.bit_distance_to(it._bit_range) / bit_size; }
90 bool equal(const bit_aligned_pixel_iterator& it) const { return _bit_range==it._bit_range; }
91};
92
93template <typename NonAlignedPixelReference>
94struct const_iterator_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > {
95 typedef bit_aligned_pixel_iterator<typename NonAlignedPixelReference::const_reference> type;
96};
97
98template <typename NonAlignedPixelReference>
99struct iterator_is_mutable<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public mpl::bool_<NonAlignedPixelReference::is_mutable> {};
100
101template <typename NonAlignedPixelReference>
102struct is_iterator_adaptor<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public mpl::false_ {};
103
104/////////////////////////////
105// PixelBasedConcept
106/////////////////////////////
107
108template <typename NonAlignedPixelReference>
109struct color_space_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public color_space_type<NonAlignedPixelReference> {};
110
111template <typename NonAlignedPixelReference>
112struct channel_mapping_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public channel_mapping_type<NonAlignedPixelReference> {};
113
114template <typename NonAlignedPixelReference>
115struct is_planar<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public is_planar<NonAlignedPixelReference> {}; // == false
116
117/////////////////////////////
118// MemoryBasedIteratorConcept
119/////////////////////////////
120
121template <typename NonAlignedPixelReference>
122struct byte_to_memunit<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public mpl::int_<8> {};
123
124template <typename NonAlignedPixelReference>
125inline std::ptrdiff_t memunit_step(const bit_aligned_pixel_iterator<NonAlignedPixelReference>&) {
126 return NonAlignedPixelReference::bit_size;
127}
128
129template <typename NonAlignedPixelReference>
130inline std::ptrdiff_t memunit_distance(const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p1, const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p2) {
131 return (p2.bit_range().current_byte() - p1.bit_range().current_byte())*8 + p2.bit_range().bit_offset() - p1.bit_range().bit_offset();
132}
133
134template <typename NonAlignedPixelReference>
135inline void memunit_advance(bit_aligned_pixel_iterator<NonAlignedPixelReference>& p, std::ptrdiff_t diff) {
136 p.bit_range().bit_advance(diff);
137}
138
139template <typename NonAlignedPixelReference>
140inline bit_aligned_pixel_iterator<NonAlignedPixelReference> memunit_advanced(const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p, std::ptrdiff_t diff) {
141 bit_aligned_pixel_iterator<NonAlignedPixelReference> ret=p;
142 memunit_advance(ret, diff);
143 return ret;
144}
145
146template <typename NonAlignedPixelReference> inline
147NonAlignedPixelReference memunit_advanced_ref(bit_aligned_pixel_iterator<NonAlignedPixelReference> it, std::ptrdiff_t diff) {
148 return *memunit_advanced(it,diff);
149}
150/////////////////////////////
151// HasDynamicXStepTypeConcept
152/////////////////////////////
153
154template <typename NonAlignedPixelReference>
155struct dynamic_x_step_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > {
156 typedef memory_based_step_iterator<bit_aligned_pixel_iterator<NonAlignedPixelReference> > type;
157};
158
159/////////////////////////////
160// iterator_type_from_pixel
161/////////////////////////////
162
163template <typename B, typename C, typename L, bool M>
164struct iterator_type_from_pixel<const bit_aligned_pixel_reference<B,C,L,M>,false,false,false> {
165 typedef bit_aligned_pixel_iterator<bit_aligned_pixel_reference<B,C,L,false> > type;
166};
167
168template <typename B, typename C, typename L, bool M>
169struct iterator_type_from_pixel<const bit_aligned_pixel_reference<B,C,L,M>,false,false,true> {
170 typedef bit_aligned_pixel_iterator<bit_aligned_pixel_reference<B,C,L,true> > type;
171};
172
173template <typename B, typename C, typename L, bool M, bool IsPlanar, bool IsStep, bool IsMutable>
174struct iterator_type_from_pixel<bit_aligned_pixel_reference<B,C,L,M>,IsPlanar,IsStep,IsMutable>
175 : public iterator_type_from_pixel<const bit_aligned_pixel_reference<B,C,L,M>,IsPlanar,IsStep,IsMutable> {};
176
177} } // namespace boost::gil
178
179namespace std {
180
181// It is important to provide an overload of uninitialized_copy for bit_aligned_pixel_iterator. The default STL implementation calls placement new,
182// which is not defined for bit_aligned_pixel_iterator.
183template <typename NonAlignedPixelReference>
184boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> uninitialized_copy(boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> first,
185 boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> last,
186 boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> dst) {
187 return std::copy(first,last,dst);
188}
189
190} // namespace std
191#endif
192

source code of boost/boost/gil/bit_aligned_pixel_iterator.hpp