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 | #ifndef GIL_IMAGE_H |
13 | #define GIL_IMAGE_H |
14 | |
15 | //////////////////////////////////////////////////////////////////////////////////////// |
16 | /// \file |
17 | /// \brief Templated image |
18 | /// \author Lubomir Bourdev and Hailin Jin \n |
19 | /// Adobe Systems Incorporated |
20 | /// \date 2005-2007 \n Last updated on February 12, 2007 |
21 | /// |
22 | //////////////////////////////////////////////////////////////////////////////////////// |
23 | |
24 | #include <cstddef> |
25 | #include <memory> |
26 | #include "gil_config.hpp" |
27 | #include "image_view.hpp" |
28 | #include "metafunctions.hpp" |
29 | #include "algorithm.hpp" |
30 | |
31 | namespace boost { namespace gil { |
32 | |
33 | //#ifdef _MSC_VER |
34 | //#pragma warning(push) |
35 | //#pragma warning(disable : 4244) // conversion from 'gil::image<V,Alloc>::coord_t' to 'int', possible loss of data (visual studio compiler doesn't realize that the two types are the same) |
36 | //#endif |
37 | |
38 | //////////////////////////////////////////////////////////////////////////////////////// |
39 | /// \ingroup ImageModel PixelBasedModel |
40 | /// \brief container interface over image view. Models ImageConcept, PixelBasedConcept |
41 | /// |
42 | /// A 2D container whose elements are pixels. It is templated over the pixel type, a boolean |
43 | /// indicating whether it should be planar, and an optional allocator. |
44 | /// |
45 | /// Note that its element type does not have to be a pixel. \p image can be instantiated with any Regular element, |
46 | /// in which case it models the weaker RandomAccess2DImageConcept and does not model PixelBasedConcept |
47 | /// |
48 | //////////////////////////////////////////////////////////////////////////////////////// |
49 | |
50 | template< typename Pixel, bool IsPlanar = false, typename Alloc=std::allocator<unsigned char> > |
51 | class image { |
52 | public: |
53 | typedef typename Alloc::template rebind<unsigned char>::other allocator_type; |
54 | typedef typename view_type_from_pixel<Pixel, IsPlanar>::type view_t; |
55 | typedef typename view_t::const_t const_view_t; |
56 | typedef typename view_t::point_t point_t; |
57 | typedef typename view_t::coord_t coord_t; |
58 | typedef typename view_t::value_type value_type; |
59 | typedef coord_t x_coord_t; |
60 | typedef coord_t y_coord_t; |
61 | |
62 | const point_t& dimensions() const { return _view.dimensions(); } |
63 | x_coord_t width() const { return _view.width(); } |
64 | y_coord_t height() const { return _view.height(); } |
65 | |
66 | explicit image(std::size_t alignment=0, |
67 | const Alloc alloc_in = Alloc()) : |
68 | _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {} |
69 | |
70 | // Create with dimensions and optional initial value and alignment |
71 | image(const point_t& dimensions, |
72 | std::size_t alignment=0, |
73 | const Alloc alloc_in = Alloc()) : _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) { |
74 | allocate_and_default_construct(dimensions); |
75 | } |
76 | image(x_coord_t width, y_coord_t height, |
77 | std::size_t alignment=0, |
78 | const Alloc alloc_in = Alloc()) : _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) { |
79 | allocate_and_default_construct(dimensions: point_t(width,height)); |
80 | } |
81 | image(const point_t& dimensions, |
82 | const Pixel& p_in, |
83 | std::size_t alignment, |
84 | const Alloc alloc_in = Alloc()) : |
85 | _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) { |
86 | allocate_and_fill(dimensions, p_in); |
87 | } |
88 | image(x_coord_t width, y_coord_t height, |
89 | const Pixel& p_in, |
90 | std::size_t alignment, |
91 | const Alloc alloc_in = Alloc()) : |
92 | _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) { |
93 | allocate_and_fill(dimensions: point_t(width,height),p_in); |
94 | } |
95 | |
96 | image(const image& img) : |
97 | _memory(0), _align_in_bytes(img._align_in_bytes), _alloc(img._alloc) { |
98 | allocate_and_copy(img.dimensions(),img._view); |
99 | } |
100 | |
101 | template <typename P2, bool IP2, typename Alloc2> |
102 | image(const image<P2,IP2,Alloc2>& img) : |
103 | _memory(0), _align_in_bytes(img._align_in_bytes), _alloc(img._alloc) { |
104 | allocate_and_copy(img.dimensions(),img._view); |
105 | } |
106 | image& operator=(const image& img) { |
107 | if (dimensions() == img.dimensions()) |
108 | copy_pixels(img._view,_view); |
109 | else { |
110 | image tmp(img); |
111 | swap(img&: tmp); |
112 | } |
113 | return *this; |
114 | } |
115 | |
116 | template <typename Img> |
117 | image& operator=(const Img& img) { |
118 | if (dimensions() == img.dimensions()) |
119 | copy_pixels(img._view,_view); |
120 | else { |
121 | image tmp(img); |
122 | swap(img&: tmp); |
123 | } |
124 | return *this; |
125 | } |
126 | |
127 | ~image() { |
128 | destruct_pixels(_view); |
129 | deallocate(dimensions: _view.dimensions()); |
130 | } |
131 | |
132 | Alloc& allocator() { return _alloc; } |
133 | Alloc const& allocator() const { return _alloc; } |
134 | |
135 | void swap(image& img) { // required by MutableContainerConcept |
136 | using std::swap; |
137 | swap(_align_in_bytes, img._align_in_bytes); |
138 | swap(_memory, img._memory); |
139 | swap(_view, img._view); |
140 | swap(_alloc, img._alloc); |
141 | } |
142 | |
143 | void recreate(const point_t& dims, std::size_t alignment=0, const Alloc alloc_in = Alloc()) { |
144 | if (dims!=_view.dimensions() || _align_in_bytes!=alignment || alloc_in!=_alloc) { |
145 | image tmp(dims, alignment, alloc_in); |
146 | swap(img&: tmp); |
147 | } |
148 | } |
149 | void recreate(x_coord_t width, y_coord_t height, std::size_t alignment=0, const Alloc alloc_in = Alloc()) { |
150 | recreate(point_t(width,height),alignment,alloc_in); |
151 | } |
152 | void recreate(const point_t& dims, |
153 | const Pixel& p_in, std::size_t alignment, const Alloc alloc_in = Alloc()) { |
154 | if (dims!=_view.dimensions() || _align_in_bytes!=alignment || alloc_in!=_alloc) { |
155 | image tmp(dims, p_in, alignment, alloc_in); |
156 | swap(img&: tmp); |
157 | } |
158 | } |
159 | void recreate(x_coord_t width, y_coord_t height, |
160 | const Pixel& p_in, std::size_t alignment, const Alloc alloc_in = Alloc()) { |
161 | recreate(point_t(width,height),p_in,alignment,alloc_in); |
162 | } |
163 | |
164 | view_t _view; // contains pointer to the pixels, the image size and ways to navigate pixels |
165 | private: |
166 | unsigned char* _memory; |
167 | std::size_t _align_in_bytes; |
168 | allocator_type _alloc; |
169 | |
170 | void allocate_and_default_construct(const point_t& dimensions) { |
171 | try { |
172 | allocate_(dimensions,mpl::bool_<IsPlanar>()); |
173 | default_construct_pixels(_view); |
174 | } catch(...) { deallocate(dimensions); throw; } |
175 | } |
176 | |
177 | void allocate_and_fill(const point_t& dimensions, const Pixel& p_in) { |
178 | try { |
179 | allocate_(dimensions,mpl::bool_<IsPlanar>()); |
180 | uninitialized_fill_pixels(_view, p_in); |
181 | } catch(...) { deallocate(dimensions); throw; } |
182 | } |
183 | |
184 | template <typename View> |
185 | void allocate_and_copy(const point_t& dimensions, const View& v) { |
186 | try { |
187 | allocate_(dimensions,mpl::bool_<IsPlanar>()); |
188 | uninitialized_copy_pixels(v,_view); |
189 | } catch(...) { deallocate(dimensions); throw; } |
190 | } |
191 | |
192 | void deallocate(const point_t& dimensions) { |
193 | if (_memory) _alloc.deallocate(_memory, total_allocated_size_in_bytes(dimensions)); |
194 | } |
195 | |
196 | std::size_t total_allocated_size_in_bytes(const point_t& dimensions) const { |
197 | |
198 | typedef typename view_t::x_iterator x_iterator; |
199 | |
200 | // when value_type is a non-pixel, like int or float, num_channels< ... > doesn't work. |
201 | const std::size_t _channels_in_image = mpl::eval_if< is_pixel< value_type > |
202 | , num_channels< view_t > |
203 | , mpl::int_< 1 > |
204 | >::type::value; |
205 | |
206 | std::size_t size_in_units = get_row_size_in_memunits(width: dimensions.x)*dimensions.y; |
207 | |
208 | if (IsPlanar) |
209 | size_in_units = size_in_units * _channels_in_image ; |
210 | |
211 | // return the size rounded up to the nearest byte |
212 | return ( size_in_units + byte_to_memunit< x_iterator >::value - 1 ) |
213 | / byte_to_memunit<x_iterator>::value |
214 | + ( _align_in_bytes > 0 ? _align_in_bytes - 1 : 0 ); // add extra padding in case we need to align the first image pixel |
215 | } |
216 | |
217 | std::size_t get_row_size_in_memunits(x_coord_t width) const { // number of units per row |
218 | std::size_t size_in_memunits = width*memunit_step(typename view_t::x_iterator()); |
219 | if (_align_in_bytes>0) { |
220 | std::size_t alignment_in_memunits=_align_in_bytes*byte_to_memunit<typename view_t::x_iterator>::value; |
221 | return align(val: size_in_memunits, alignment: alignment_in_memunits); |
222 | } |
223 | return size_in_memunits; |
224 | } |
225 | |
226 | void allocate_(const point_t& dimensions, mpl::false_) { // if it throws and _memory!=0 the client must deallocate _memory |
227 | _memory=_alloc.allocate(total_allocated_size_in_bytes(dimensions)); |
228 | unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align(val: (std::size_t)_memory,alignment: _align_in_bytes) : _memory; |
229 | _view=view_t(dimensions,typename view_t::locator(typename view_t::x_iterator(tmp),get_row_size_in_memunits(width: dimensions.x))); |
230 | } |
231 | |
232 | void allocate_(const point_t& dimensions, mpl::true_) { // if it throws and _memory!=0 the client must deallocate _memory |
233 | std::size_t row_size=get_row_size_in_memunits(width: dimensions.x); |
234 | std::size_t plane_size=row_size*dimensions.y; |
235 | _memory=_alloc.allocate(total_allocated_size_in_bytes(dimensions)); |
236 | unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align(val: (std::size_t)_memory,alignment: _align_in_bytes) : _memory; |
237 | typename view_t::x_iterator first; |
238 | for (int i=0; i<num_channels<view_t>::value; ++i) { |
239 | dynamic_at_c(first,i) = (typename channel_type<view_t>::type*)tmp; |
240 | memunit_advance(dynamic_at_c(first,i), plane_size*i); |
241 | } |
242 | _view=view_t(dimensions, typename view_t::locator(first, row_size)); |
243 | } |
244 | }; |
245 | |
246 | template <typename Pixel, bool IsPlanar, typename Alloc> |
247 | void swap(image<Pixel, IsPlanar, Alloc>& im1,image<Pixel, IsPlanar, Alloc>& im2) { |
248 | im1.swap(im2); |
249 | } |
250 | |
251 | template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2> |
252 | bool operator==(const image<Pixel1,IsPlanar1,Alloc1>& im1,const image<Pixel2,IsPlanar2,Alloc2>& im2) { |
253 | if ((void*)(&im1)==(void*)(&im2)) return true; |
254 | if (const_view(im1).dimensions()!=const_view(im2).dimensions()) return false; |
255 | return equal_pixels(const_view(im1),const_view(im2)); |
256 | } |
257 | template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2> |
258 | bool operator!=(const image<Pixel1,IsPlanar1,Alloc1>& im1,const image<Pixel2,IsPlanar2,Alloc2>& im2) {return !(im1==im2);} |
259 | |
260 | ///@{ |
261 | /// \name view, const_view |
262 | /// \brief Get an image view from an image |
263 | |
264 | /// \ingroup ImageModel |
265 | |
266 | /// \brief Returns the non-constant-pixel view of an image |
267 | template <typename Pixel, bool IsPlanar, typename Alloc> inline |
268 | const typename image<Pixel,IsPlanar,Alloc>::view_t& view(image<Pixel,IsPlanar,Alloc>& img) { return img._view; } |
269 | |
270 | /// \brief Returns the constant-pixel view of an image |
271 | template <typename Pixel, bool IsPlanar, typename Alloc> inline |
272 | const typename image<Pixel,IsPlanar,Alloc>::const_view_t const_view(const image<Pixel,IsPlanar,Alloc>& img) { |
273 | return static_cast<const typename image<Pixel,IsPlanar,Alloc>::const_view_t>(img._view); |
274 | } |
275 | ///@} |
276 | |
277 | ///////////////////////////// |
278 | // PixelBasedConcept |
279 | ///////////////////////////// |
280 | |
281 | template <typename Pixel, bool IsPlanar, typename Alloc> |
282 | struct channel_type<image<Pixel,IsPlanar,Alloc> > : public channel_type<Pixel> {}; |
283 | |
284 | template <typename Pixel, bool IsPlanar, typename Alloc> |
285 | struct color_space_type<image<Pixel,IsPlanar,Alloc> > : public color_space_type<Pixel> {}; |
286 | |
287 | template <typename Pixel, bool IsPlanar, typename Alloc> |
288 | struct channel_mapping_type<image<Pixel,IsPlanar,Alloc> > : public channel_mapping_type<Pixel> {}; |
289 | |
290 | template <typename Pixel, bool IsPlanar, typename Alloc> |
291 | struct is_planar<image<Pixel,IsPlanar,Alloc> > : public mpl::bool_<IsPlanar> {}; |
292 | |
293 | //#ifdef _MSC_VER |
294 | //#pragma warning(pop) |
295 | //#endif |
296 | |
297 | } } // namespace boost::gil |
298 | |
299 | #endif |
300 | |