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
31namespace 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
50template< typename Pixel, bool IsPlanar = false, typename Alloc=std::allocator<unsigned char> >
51class image {
52public:
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
165private:
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
246template <typename Pixel, bool IsPlanar, typename Alloc>
247void swap(image<Pixel, IsPlanar, Alloc>& im1,image<Pixel, IsPlanar, Alloc>& im2) {
248 im1.swap(im2);
249}
250
251template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2>
252bool 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}
257template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2>
258bool 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
267template <typename Pixel, bool IsPlanar, typename Alloc> inline
268const 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
271template <typename Pixel, bool IsPlanar, typename Alloc> inline
272const 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
281template <typename Pixel, bool IsPlanar, typename Alloc>
282struct channel_type<image<Pixel,IsPlanar,Alloc> > : public channel_type<Pixel> {};
283
284template <typename Pixel, bool IsPlanar, typename Alloc>
285struct color_space_type<image<Pixel,IsPlanar,Alloc> > : public color_space_type<Pixel> {};
286
287template <typename Pixel, bool IsPlanar, typename Alloc>
288struct channel_mapping_type<image<Pixel,IsPlanar,Alloc> > : public channel_mapping_type<Pixel> {};
289
290template <typename Pixel, bool IsPlanar, typename Alloc>
291struct 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

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