1 //
2 // Copyright 2005-2007 Adobe Systems Incorporated
3 // Copyright 2018-2020 Mateusz Loskot <mateusz at loskot dot net>
4 //
5 // Distributed under the Boost Software License, Version 1.0
6 // See accompanying file LICENSE_1_0.txt or copy at
7 // http://www.boost.org/LICENSE_1_0.txt
8 //
9 #include <boost/gil/channel_algorithm.hpp>
10
11 #include <boost/core/lightweight_test.hpp>
12
13 #include <cstdint>
14
15 #include "test_fixture.hpp"
16
17 namespace gil = boost::gil;
18 namespace fixture = boost::gil::test::fixture;
19
20 template <typename ChannelFixtureBase>
21 struct test_convert_to
22 {
23 using channel_t = typename fixture::channel<ChannelFixtureBase>::channel_t;
24 using channel_value_t = typename fixture::channel<ChannelFixtureBase>::channel_value_t;
25
26 template <typename Channel>
fromtest_convert_to27 static void from(Channel src_min_v, Channel src_max_v)
28 {
29 channel_value_t min_v = gil::channel_convert<channel_t>(src_min_v);
30 channel_value_t max_v = gil::channel_convert<channel_t>(src_max_v);
31 fixture::channel_minmax_value<channel_value_t> expect;
32 BOOST_TEST_EQ(min_v, expect.min_v_);
33 BOOST_TEST_EQ(max_v, expect.max_v_);
34 }
35 };
36
37 //--- Test gil::channel_convert from integral channels to all byte channels -------------
38 template <typename SourceChannel, typename TargetChannel>
test_channel_value_convert_from_integral()39 void test_channel_value_convert_from_integral()
40 {
41 fixture::channel_minmax_value<SourceChannel> f;
42
43 using channel_t = TargetChannel;
44 // byte channel
45 test_convert_to<fixture::channel_value<channel_t>>::from(f.min_v_, f.max_v_);
46 test_convert_to<fixture::channel_reference<channel_t&>>::from(f.min_v_, f.max_v_);
47 test_convert_to<fixture::channel_reference<channel_t const&>>::from(f.min_v_, f.max_v_);
48
49 // packed_channel_reference
50 {
51 using channels565_t = fixture::packed_channels565<std::uint16_t>;
52 test_convert_to<typename channels565_t::fixture_0_5_t>::from(f.min_v_, f.max_v_);
53 test_convert_to<typename channels565_t::fixture_5_6_t>::from(f.min_v_, f.max_v_);
54 test_convert_to<typename channels565_t::fixture_11_5_t>::from(f.min_v_, f.max_v_);
55 }
56 // packed_dynamic_channel_reference
57 {
58 using channels565_t = fixture::packed_dynamic_channels565<std::uint16_t>;
59 test_convert_to<typename channels565_t::fixture_5_t>::from(f.min_v_, f.max_v_);
60 test_convert_to<typename channels565_t::fixture_6_t>::from(f.min_v_, f.max_v_);
61 }
62 }
63
64 struct test_channel_value_convert_from_uint8_t
65 {
66 template <typename Channel>
operator ()test_channel_value_convert_from_uint8_t67 void operator()(Channel const &)
68 {
69 using channel_t = Channel;
70 test_channel_value_convert_from_integral<std::uint8_t, channel_t>();
71 }
runtest_channel_value_convert_from_uint8_t72 static void run()
73 {
74 boost::mp11::mp_for_each<fixture::channel_byte_types>(test_channel_value_convert_from_uint8_t{});
75 }
76 };
77
78 struct test_channel_value_convert_from_int8_t
79 {
80 template <typename Channel>
operator ()test_channel_value_convert_from_int8_t81 void operator()(Channel const &)
82 {
83 using channel_t = Channel;
84 test_channel_value_convert_from_integral<std::int8_t, channel_t>();
85 }
runtest_channel_value_convert_from_int8_t86 static void run()
87 {
88 boost::mp11::mp_for_each<fixture::channel_byte_types>(test_channel_value_convert_from_int8_t{});
89 }
90 };
91
92 struct test_channel_value_convert_from_uint16_t
93 {
94 template <typename Channel>
operator ()test_channel_value_convert_from_uint16_t95 void operator()(Channel const &)
96 {
97 using channel_t = Channel;
98 test_channel_value_convert_from_integral<std::uint16_t, channel_t>();
99 }
runtest_channel_value_convert_from_uint16_t100 static void run()
101 {
102 boost::mp11::mp_for_each<fixture::channel_byte_types>(test_channel_value_convert_from_uint16_t{});
103 }
104 };
105
106 struct test_channel_value_convert_from_int16_t
107 {
108 template <typename Channel>
operator ()test_channel_value_convert_from_int16_t109 void operator()(Channel const &)
110 {
111 using channel_t = Channel;
112 test_channel_value_convert_from_integral<std::int16_t, channel_t>();
113 }
runtest_channel_value_convert_from_int16_t114 static void run()
115 {
116 boost::mp11::mp_for_each<fixture::channel_byte_types>(test_channel_value_convert_from_int16_t{});
117 }
118 };
119
120 struct test_channel_value_convert_from_uint32_t
121 {
122 template <typename Channel>
operator ()test_channel_value_convert_from_uint32_t123 void operator()(Channel const &)
124 {
125 using channel_t = Channel;
126 test_channel_value_convert_from_integral<std::uint32_t, channel_t>();
127 }
runtest_channel_value_convert_from_uint32_t128 static void run()
129 {
130 boost::mp11::mp_for_each<fixture::channel_byte_types>(test_channel_value_convert_from_uint32_t{});
131 }
132 };
133
134 struct test_channel_value_convert_from_int32_t
135 {
136 template <typename Channel>
operator ()test_channel_value_convert_from_int32_t137 void operator()(Channel const &)
138 {
139 using channel_t = Channel;
140 test_channel_value_convert_from_integral<std::int32_t, channel_t>();
141 }
runtest_channel_value_convert_from_int32_t142 static void run()
143 {
144 boost::mp11::mp_for_each<fixture::channel_byte_types>(test_channel_value_convert_from_int32_t{});
145 }
146 };
147
148 // FIXME: gil::float32_t <-> gil::float64_t seems not supported
149
150 //--- Test gil::channel_convert from gil::float32_t to all integer channels -------------
151 struct test_channel_value_convert_from_float32_t
152 {
153 template <typename Channel>
operator ()test_channel_value_convert_from_float32_t154 void operator()(Channel const &)
155 {
156 using channel_t = Channel;
157 fixture::channel_minmax_value<gil::float32_t> f;
158 test_convert_to<fixture::channel_value<channel_t>>::from(f.min_v_, f.max_v_);
159 }
runtest_channel_value_convert_from_float32_t160 static void run()
161 {
162 boost::mp11::mp_for_each<fixture::channel_integer_types>(test_channel_value_convert_from_float32_t{});
163 }
164 };
165
166 struct test_channel_reference_convert_from_float32_t
167 {
168 template <typename Channel>
operator ()test_channel_reference_convert_from_float32_t169 void operator()(Channel const &)
170 {
171 using channel_t = Channel;
172 fixture::channel_minmax_value<gil::float32_t> f;
173 test_convert_to<fixture::channel_reference<channel_t&>>::from(f.min_v_, f.max_v_);
174 }
runtest_channel_reference_convert_from_float32_t175 static void run()
176 {
177 boost::mp11::mp_for_each<fixture::channel_integer_types>(test_channel_reference_convert_from_float32_t{});
178 }
179 };
180
181 struct test_channel_reference_const_from_float32_t
182 {
183 template <typename Channel>
operator ()test_channel_reference_const_from_float32_t184 void operator()(Channel const &)
185 {
186 using channel_t = Channel;
187 fixture::channel_minmax_value<gil::float32_t> f;
188 test_convert_to<fixture::channel_reference<channel_t const &>>::from(f.min_v_, f.max_v_);
189 }
runtest_channel_reference_const_from_float32_t190 static void run()
191 {
192 boost::mp11::mp_for_each<fixture::channel_integer_types>(test_channel_reference_const_from_float32_t{});
193 }
194 };
195
196 //--- Test gil::channel_convert from gil::float64_t to all integer channels -------------
197
198 struct test_channel_value_convert_from_float64_t
199 {
200 template <typename Channel>
operator ()test_channel_value_convert_from_float64_t201 void operator()(Channel const &)
202 {
203 using channel_t = Channel;
204 fixture::channel_minmax_value<gil::float64_t> f;
205 test_convert_to<fixture::channel_value<channel_t>>::from(f.min_v_, f.max_v_);
206 }
runtest_channel_value_convert_from_float64_t207 static void run()
208 {
209 boost::mp11::mp_for_each<fixture::channel_integer_types>(test_channel_value_convert_from_float64_t{});
210 }
211 };
212
213 struct test_channel_reference_convert_from_float64_t
214 {
215 template <typename Channel>
operator ()test_channel_reference_convert_from_float64_t216 void operator()(Channel const &)
217 {
218 using channel_t = Channel;
219 fixture::channel_minmax_value<gil::float64_t> f;
220 test_convert_to<fixture::channel_reference<channel_t &>>::from(f.min_v_, f.max_v_);
221 }
runtest_channel_reference_convert_from_float64_t222 static void run()
223 {
224 boost::mp11::mp_for_each<fixture::channel_integer_types>(test_channel_reference_convert_from_float64_t{});
225 }
226 };
227
228 struct test_channel_reference_const_convert_from_float64_t
229 {
230 template <typename Channel>
operator ()test_channel_reference_const_convert_from_float64_t231 void operator()(Channel const &)
232 {
233 using channel_t = Channel;
234 fixture::channel_minmax_value<gil::float64_t> f;
235 test_convert_to<fixture::channel_reference<channel_t const &>>::from(f.min_v_, f.max_v_);
236 }
runtest_channel_reference_const_convert_from_float64_t237 static void run()
238 {
239 boost::mp11::mp_for_each<fixture::channel_integer_types>(test_channel_reference_const_convert_from_float64_t{});
240 }
241 };
242
main()243 int main()
244 {
245 test_channel_value_convert_from_uint8_t::run();
246 test_channel_value_convert_from_int8_t::run();
247 test_channel_value_convert_from_uint16_t::run();
248 test_channel_value_convert_from_int16_t::run();
249 test_channel_value_convert_from_uint32_t::run();
250 test_channel_value_convert_from_int32_t::run();
251
252 test_channel_value_convert_from_float32_t::run();
253 test_channel_reference_convert_from_float32_t::run();
254 test_channel_reference_const_from_float32_t::run();
255
256 test_channel_value_convert_from_float64_t::run();
257 test_channel_reference_convert_from_float64_t::run();
258 test_channel_reference_const_convert_from_float64_t::run();
259
260 return ::boost::report_errors();
261 }
262