Boost GIL

read_and_convert_image.hpp
1 //
2 // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
3 //
4 // Distributed under the Boost Software License, Version 1.0
5 // See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt
7 //
8 #ifndef BOOST_GIL_IO_READ_AND_CONVERT_IMAGE_HPP
9 #define BOOST_GIL_IO_READ_AND_CONVERT_IMAGE_HPP
10 
11 #include <boost/gil/io/base.hpp>
12 #include <boost/gil/io/conversion_policies.hpp>
13 #include <boost/gil/io/device.hpp>
14 #include <boost/gil/io/get_reader.hpp>
15 #include <boost/gil/io/path_spec.hpp>
16 
17 #include <boost/mpl/and.hpp>
18 #include <boost/type_traits/is_base_and_derived.hpp>
19 
20 #include <type_traits>
21 
22 namespace boost{ namespace gil {
23 
25 
32 template <typename Reader, typename Image>
33 inline
34 void read_and_convert_image(Reader& reader, Image& img,
35  typename std::enable_if
36  <
37  mpl::and_
38  <
39  detail::is_reader<Reader>,
40  is_format_tag<typename Reader::format_tag_t>
41  >::value
42  >::type* /*dummy*/ = nullptr)
43 {
44  reader.init_image(img, reader._settings);
45  reader.apply(view(img));
46 }
47 
54 template <typename Device, typename Image, typename ColorConverter, typename FormatTag>
55 inline
56 void read_and_convert_image(
57  Device& device,
58  Image& img,
59  image_read_settings<FormatTag> const& settings,
60  ColorConverter const& cc,
61  typename std::enable_if
62  <
63  mpl::and_
64  <
65  detail::is_read_device<FormatTag, Device>,
66  is_format_tag<FormatTag>
67  >::value
68  >::type* /*dummy*/ = nullptr)
69 {
70  using read_and_convert_t = detail::read_and_convert<ColorConverter>;
71  using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type;
72 
73  reader_t reader = make_reader(device, settings, read_and_convert_t{cc});
74  read_and_convert_image(reader, img);
75 }
76 
83 template <typename String, typename Image, typename ColorConverter, typename FormatTag>
84 inline
85 void read_and_convert_image(
86  String const& file_name,
87  Image& img,
88  image_read_settings<FormatTag> const& settings,
89  ColorConverter const& cc,
90  typename std::enable_if
91  <
92  mpl::and_
93  <
94  is_format_tag<FormatTag>,
95  detail::is_supported_path_spec<String>
96  >::value
97  >::type* /*dummy*/ = nullptr)
98 {
99  using read_and_convert_t = detail::read_and_convert<ColorConverter>;
100  using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type;
101 
102  reader_t reader = make_reader(file_name, settings, read_and_convert_t{cc});
103  read_and_convert_image(reader, img);
104 }
105 
112 template <typename String, typename Image, typename ColorConverter, typename FormatTag>
113 inline
114 void read_and_convert_image(
115  String const& file_name,
116  Image& img,
117  ColorConverter const& cc,
118  FormatTag const& tag,
119  typename std::enable_if
120  <
121  mpl::and_
122  <
123  is_format_tag<FormatTag>,
124  detail::is_supported_path_spec<String>
125  >::value
126  >::type* /*dummy*/ = nullptr)
127 {
128  using read_and_convert_t = detail::read_and_convert<ColorConverter>;
129  using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type;
130 
131  reader_t reader = make_reader(file_name, tag, read_and_convert_t{cc});
132  read_and_convert_image(reader, img);
133 }
134 
141 template <typename Device, typename Image, typename ColorConverter, typename FormatTag>
142 inline
143 void read_and_convert_image(
144  Device& device,
145  Image& img,
146  ColorConverter const& cc,
147  FormatTag const& tag,
148  typename std::enable_if
149  <
150  mpl::and_
151  <
152  detail::is_read_device<FormatTag, Device>,
153  is_format_tag<FormatTag>
154  >::value
155  >::type* /*dummy*/ = nullptr)
156 {
157  using read_and_convert_t = detail::read_and_convert<ColorConverter>;
158  using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type;
159 
160  reader_t reader = make_reader(device, tag, read_and_convert_t{cc});
161  read_and_convert_image(reader, img);
162 }
163 
169 template <typename String, typename Image, typename FormatTag>
170 inline void read_and_convert_image(
171  String const& file_name,
172  Image& img,
173  image_read_settings<FormatTag> const& settings,
174  typename std::enable_if
175  <
176  mpl::and_
177  <
178  is_format_tag<FormatTag>,
179  detail::is_supported_path_spec<String>
180  >::value
181  >::type* /*dummy*/ = nullptr)
182 {
183  using read_and_convert_t = detail::read_and_convert<default_color_converter>;
184  using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type;
185 
186  reader_t reader = make_reader(file_name, settings, read_and_convert_t{});
187  read_and_convert_image(reader, img);
188 }
189 
195 template <typename Device, typename Image, typename FormatTag>
196 inline void read_and_convert_image(
197  Device& device,
198  Image& img,
199  image_read_settings<FormatTag> const& settings,
200  typename std::enable_if
201  <
202  mpl::and_
203  <
204  detail::is_read_device<FormatTag, Device>,
205  is_format_tag<FormatTag>
206  >::value
207  >::type* /*dummy*/ = nullptr)
208 {
209  using read_and_convert_t = detail::read_and_convert<default_color_converter>;
210  using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type;
211 
212  reader_t reader = make_reader(device, settings, read_and_convert_t{});
213  read_and_convert_image(reader, img);
214 }
215 
221 template <typename String, typename Image, typename FormatTag>
222 inline
223 void read_and_convert_image(
224  String const& file_name,
225  Image& img,
226  FormatTag const& tag,
227  typename std::enable_if
228  <
229  mpl::and_
230  <
231  is_format_tag<FormatTag>,
232  detail::is_supported_path_spec<String>
233  >::value
234  >::type* /*dummy*/ = nullptr)
235 {
236  using read_and_convert_t = detail::read_and_convert<default_color_converter>;
237  using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type;
238 
239  reader_t reader = make_reader(file_name, tag, read_and_convert_t{});
240  read_and_convert_image(reader, img);
241 }
242 
248 template <typename Device, typename Image, typename FormatTag>
249 inline void read_and_convert_image(
250  Device& device,
251  Image& img,
252  FormatTag const& tag,
253  typename std::enable_if
254  <
255  mpl::and_
256  <
257  detail::is_read_device<FormatTag, Device>,
258  is_format_tag<FormatTag>
259  >::value
260  >::type* /*dummy*/ = nullptr)
261 {
262  using read_and_convert_t = detail::read_and_convert<default_color_converter>;
263  using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type;
264 
265  reader_t reader = make_reader(device, tag, read_and_convert_t{});
266  read_and_convert_image(reader, img);
267 }
268 
269 }} // namespace boost::gil
270 
271 #endif
boost
Definition: algorithm.hpp:30
boost::gil::read_and_convert_image
void read_and_convert_image(Reader &reader, Image &img, typename std::enable_if< mpl::and_< detail::is_reader< Reader >, is_format_tag< typename Reader::format_tag_t > >::value >::type *=nullptr)
Reads and color-converts an image. Image memory is allocated.
Definition: read_and_convert_image.hpp:34
boost::gil::detail::is_read_device
Definition: device.hpp:592
boost::gil::view
const image< Pixel, IsPlanar, Alloc >::view_t & view(image< Pixel, IsPlanar, Alloc > &img)
Returns the non-constant-pixel view of an image.
Definition: image.hpp:460
boost::gil::get_reader
Helper metafunction to generate image reader type.
Definition: get_reader.hpp:27
Generated by  doxygen 1.8.13