1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/*
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://stlab.adobe.com/gil for most recent version including documentation.
*/
/*************************************************************************************************/
////////////////////////////////////////////////////////////////////////////////////////
/// \file
/// \brief Example on how to create a new model of a pixel reference
/// \author Lubomir Bourdev and Hailin Jin \n
/// Adobe Systems Incorporated
/// \date 2005-2007 \n Last updated on February 26, 2007
//////
////////////////////////////////////////////////////////////////////////////////////////
#ifndef GIL_INTERLEAVED_REF_HPP
#define GIL_INTERLEAVED_REF_HPP
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/vector_c.hpp>
#include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp>
namespace boost { namespace gil {
/////////////////////////////////////////////////////////////////////////
///
/// A model of an interleaved pixel reference. Holds a pointer to the first channel
/// MODELS:
/// MutableHomogeneousPixelConcept
/// MutableHomogeneousColorBaseConcept
/// MutableColorBaseConcept
/// HomogeneousColorBaseConcept
/// ColorBaseConcept
/// HomogeneousPixelBasedConcept
/// PixelBasedConcept
///
/// For planar reference proxies to work properly, all of their methods must be const-qualified
/// and their iterator's reference type must be const-qualified.
/// Mutability of the reference proxy is part of its type (in this case, depends on the mutability of ChannelReference)
/////////////////////////////////////////////////////////////////////////
template <typename ChannelReference, // Models ChannelConcept. A channel reference, unsigned char& or const unsigned char&
typename Layout> // A layout (includes the color space and channel ordering)
struct interleaved_ref {
private:
typedef typename channel_traits<ChannelReference>::value_type channel_t;
typedef typename channel_traits<ChannelReference>::reference channel_reference_t;
typedef typename channel_traits<ChannelReference>::const_reference channel_const_reference_t;
typedef typename channel_traits<ChannelReference>::pointer channel_pointer_t;
public:
// Required by ColorBaseConcept
typedef Layout layout_t;
// Copy construction from a compatible type. The copy constructor of references is shallow. The channels themselves are not copied.
interleaved_ref(const interleaved_ref& p) : _channels(p._channels) {}
template <typename P> interleaved_ref(const P& p) : _channels(p._channels) { check_compatible<P>(); }
template <typename P> bool operator==(const P& p) const { check_compatible<P>(); return static_equal(*this,p); }
template <typename P> bool operator!=(const P& p) const { return !(*this==p); }
// Required by MutableColorBaseConcept
// Assignment from a compatible type
const interleaved_ref& operator=(const interleaved_ref& p) const { static_copy(p,*this); return *this; }
template <typename P> const interleaved_ref& operator=(const P& p) const { check_compatible<P>(); static_copy(p,*this); return *this; }
// Required by PixelConcept
typedef pixel<channel_t, layout_t> value_type;
typedef interleaved_ref reference;
typedef interleaved_ref<channel_const_reference_t, layout_t> const_reference;
static const bool is_mutable = channel_traits<ChannelReference>::is_mutable;
// Required by HomogeneousPixelConcept
ChannelReference operator[](std::size_t i) const { return _channels[i]; }
// Custom constructor (not part of any concept)
explicit interleaved_ref(channel_pointer_t channels) : _channels(channels) {}
// This is needed for the reference proxy to work properly
const interleaved_ref* operator->() const { return this; }
private:
channel_pointer_t _channels;
template <typename Pixel> static void check_compatible() { gil_function_requires<PixelsCompatibleConcept<Pixel,interleaved_ref> >(); }
};
// Required by ColorBaseConcept
template <typename ChannelReference, typename Layout, int K>
struct kth_element_type<interleaved_ref<ChannelReference,Layout>,K> {
typedef ChannelReference type;
};
template <typename ChannelReference, typename Layout, int K>
struct kth_element_reference_type<interleaved_ref<ChannelReference,Layout>,K> {
typedef ChannelReference type;
};
template <typename ChannelReference, typename Layout, int K>
struct kth_element_const_reference_type<interleaved_ref<ChannelReference,Layout>,K> {
typedef ChannelReference type;
// typedef typename channel_traits<ChannelReference>::const_reference type;
};
// Required by ColorBaseConcept
template <int K, typename ChannelReference, typename Layout>
typename element_reference_type<interleaved_ref<ChannelReference,Layout> >::type
at_c(const interleaved_ref<ChannelReference,Layout>& p) { return p[K]; };
// Required by HomogeneousColorBaseConcept
template <typename ChannelReference, typename Layout>
typename element_reference_type<interleaved_ref<ChannelReference,Layout> >::type
dynamic_at_c(const interleaved_ref<ChannelReference,Layout>& p, std::size_t n) { return p[n]; };
namespace detail {
struct swap_fn_t {
template <typename T> void operator()(T& x, T& y) const {
using std::swap;
swap(x,y);
}
};
}
// Required by MutableColorBaseConcept. The default std::swap does not do the right thing for proxy references - it swaps the references, not the values
template <typename ChannelReference, typename Layout>
void swap(const interleaved_ref<ChannelReference,Layout>& x, const interleaved_ref<ChannelReference,Layout>& y) {
static_for_each(x,y,detail::swap_fn_t());
};
// Required by PixelConcept
template <typename ChannelReference, typename Layout>
struct is_pixel<interleaved_ref<ChannelReference,Layout> > : public boost::mpl::true_ {};
// Required by PixelBasedConcept
template <typename ChannelReference, typename Layout>
struct color_space_type<interleaved_ref<ChannelReference,Layout> > {
typedef typename Layout::color_space_t type;
};
// Required by PixelBasedConcept
template <typename ChannelReference, typename Layout>
struct channel_mapping_type<interleaved_ref<ChannelReference,Layout> > {
typedef typename Layout::channel_mapping_t type;
};
// Required by PixelBasedConcept
template <typename ChannelReference, typename Layout>
struct is_planar<interleaved_ref<ChannelReference,Layout> > : mpl::false_ {};
// Required by HomogeneousPixelBasedConcept
template <typename ChannelReference, typename Layout>
struct channel_type<interleaved_ref<ChannelReference,Layout> > {
typedef typename channel_traits<ChannelReference>::value_type type;
};
} } // namespace boost::gil
#endif
|
