libs/gil/test/extension/numeric/pixel_numeric_operations.cpp

   1 //
   2 // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net>
   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 #include <boost/gil.hpp>
   9 #include <boost/gil/extension/numeric/pixel_numeric_operations.hpp>
  10
  11 #include <tuple>
  12 #include <type_traits>
  13
  14 #define BOOST_TEST_MODULE test_ext_numeric_pixel_numeric_operations
  15 #include "unit_test.hpp"
  16 #include "unit_test_utility.hpp"
  17 #include "core/image/test_fixture.hpp" // random_value
  18 #include "core/pixel/test_fixture.hpp"
  19
  20 namespace gil = boost::gil;
  21 namespace fixture = boost::gil::test::fixture;
  22
  23 BOOST_AUTO_TEST_SUITE(pixel_plus_t)
  24
  25 BOOST_AUTO_TEST_CASE_TEMPLATE(plus_integer_same_types, pixel_t, fixture::pixel_integer_types)
  26 {
  27     using channel_t = typename gil::channel_type<pixel_t>::type;
  28     gil::pixel_plus_t<pixel_t, pixel_t, pixel_t> f;
  29     {
  30         pixel_t p0;
  31         gil::static_fill(p0, static_cast<channel_t>(0));
  32         BOOST_TEST(f(p0, p0) == p0);
  33     }
  34     {
  35         pixel_t p1;
  36         gil::static_fill(p1, static_cast<channel_t>(1));
  37         pixel_t r2;
  38         gil::static_fill(r2, static_cast<channel_t>(2));
  39         BOOST_TEST(f(p1, p1) == r2);
  40     }
  41     {
  42         // Generates pixels with consecutive channel values: {1} or {1,2,3} or {1,2,3,4} etc.
  43         fixture::consecutive_value<channel_t> g(1);
  44         pixel_t p;
  45         gil::static_generate(p, [&g]() { return g(); });
  46         auto const r = f(p, p);
  47         BOOST_TEST(r != p);
  48         BOOST_TEST(gil::at_c<0>(r) == (gil::at_c<0>(p) + gil::at_c<0>(p)));
  49     }
  50 }
  51
  52 BOOST_AUTO_TEST_SUITE_END() // pixel_plus_t
  53
  54 BOOST_AUTO_TEST_SUITE(pixel_minus_t)
  55
  56 BOOST_AUTO_TEST_CASE_TEMPLATE(minus_integer_same_types, pixel_t, fixture::pixel_integer_types)
  57 {
  58     using channel_t = typename gil::channel_type<pixel_t>::type;
  59     gil::pixel_minus_t<pixel_t, pixel_t, pixel_t> f;
  60
  61     pixel_t p0;
  62     gil::static_fill(p0, static_cast<channel_t>(0));
  63     BOOST_TEST(f(p0, p0) == p0);
  64     {
  65         pixel_t p1, p2;
  66         gil::static_fill(p1, static_cast<channel_t>(1));
  67         gil::static_fill(p2, static_cast<channel_t>(2));
  68         pixel_t r1;
  69         gil::static_fill(r1, static_cast<channel_t>(1));
  70         BOOST_TEST(f(p2, p1) == r1);
  71     }
  72     {
  73         // Generates pixels with consecutive channel values: {1} or {1,2,3} or {1,2,3,4} etc.
  74         fixture::consecutive_value<channel_t> g(1);
  75         pixel_t p;
  76         gil::static_generate(p, [&g]() { return g(); });
  77         BOOST_TEST(f(p, p) == p0);
  78     }
  79 }
  80
  81 BOOST_AUTO_TEST_SUITE_END() // pixel_minus_t
  82
  83 BOOST_AUTO_TEST_SUITE(pixel_multiplies_scalar_t)
  84
  85 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_multiplies_scalar_integer_same_types, pixel_t, fixture::pixel_integer_types)
  86 {
  87     using channel_t = typename gil::channel_type<pixel_t>::type;
  88     gil::pixel_multiplies_scalar_t<pixel_t, channel_t, pixel_t> f;
  89
  90     pixel_t p0;
  91     gil::static_fill(p0, static_cast<channel_t>(0));
  92     BOOST_TEST(f(p0, 0) == p0);
  93
  94     {
  95         pixel_t p1;
  96         gil::static_fill(p1, static_cast<channel_t>(1));
  97         BOOST_TEST(f(p1, 0) == p0);
  98         BOOST_TEST(f(p1, 1) == p1);
  99     }
 100     {
 101         // Generates pixels with consecutive channel values: {1} or {1,2,3} or {1,2,3,4} etc.
 102         fixture::consecutive_value<channel_t> g(1);
 103         pixel_t p;
 104         gil::static_generate(p, [&g]() { return g(); });
 105
 106         // check first channel value is doubled
 107         auto const r = f(p, 2);
 108         BOOST_TEST(r != p);
 109         BOOST_TEST(gil::at_c<0>(r) == (gil::at_c<0>(p) * 2));
 110     }
 111 }
 112
 113 BOOST_AUTO_TEST_SUITE_END() // pixel_multiplies_scalar_t
 114
 115 BOOST_AUTO_TEST_SUITE(pixel_multiply_t)
 116
 117 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_multiply_integer_same_types, pixel_t, fixture::pixel_integer_types)
 118 {
 119     using channel_t = typename gil::channel_type<pixel_t>::type;
 120     gil::pixel_multiply_t<pixel_t, pixel_t, pixel_t> f;
 121
 122     pixel_t p0;
 123     gil::static_fill(p0, static_cast<channel_t>(0));
 124     BOOST_TEST(f(p0, p0) == p0);
 125
 126     pixel_t p1;
 127     gil::static_fill(p1, static_cast<channel_t>(1));
 128     BOOST_TEST(f(p1, p1) == p1);
 129
 130     pixel_t p2;
 131     gil::static_fill(p2, static_cast<channel_t>(2));
 132     BOOST_TEST(f(p1, p2) == p2);
 133 }
 134
 135 BOOST_AUTO_TEST_SUITE_END() // pixel_multiply_t
 136
 137 BOOST_AUTO_TEST_SUITE(pixel_divides_scalar_t)
 138
 139 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_divides_scalar_integer_same_types, pixel_t, fixture::pixel_integer_types)
 140 {
 141     using channel_t = typename gil::channel_type<pixel_t>::type;
 142     gil::pixel_divides_scalar_t<pixel_t, channel_t, pixel_t> f;
 143
 144     pixel_t p0;
 145     gil::static_fill(p0, static_cast<channel_t>(0));
 146     BOOST_TEST(f(p0, 1) == p0);
 147
 148     pixel_t p1;
 149     gil::static_fill(p1, static_cast<channel_t>(1));
 150     BOOST_TEST(f(p1, 1) == p1);
 151
 152     pixel_t p2;
 153     gil::static_fill(p2, static_cast<channel_t>(2));
 154     BOOST_TEST(f(p2, 2) == p1);
 155 }
 156
 157 BOOST_AUTO_TEST_SUITE_END() // pixel_divides_scalar_t
 158
 159 BOOST_AUTO_TEST_SUITE(pixel_divide_t)
 160
 161 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_divide_integer_same_types, pixel_t, fixture::pixel_integer_types)
 162 {
 163     using channel_t = typename gil::channel_type<pixel_t>::type;
 164     gil::pixel_divide_t<pixel_t, pixel_t, pixel_t> f;
 165
 166     pixel_t p0;
 167     gil::static_fill(p0, static_cast<channel_t>(0));
 168     pixel_t p1;
 169     gil::static_fill(p1, static_cast<channel_t>(1));
 170     BOOST_TEST(f(p0, p1) == p0);
 171     BOOST_TEST(f(p1, p1) == p1);
 172
 173     pixel_t p2;
 174     gil::static_fill(p2, static_cast<channel_t>(2));
 175     BOOST_TEST(f(p2, p1) == p2);
 176 }
 177
 178 BOOST_AUTO_TEST_SUITE_END() // pixel_divide_t
 179
 180 BOOST_AUTO_TEST_SUITE(pixel_halves_t)
 181
 182 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_halves_integer_same_types, pixel_t, fixture::pixel_integer_types)
 183 {
 184     using channel_t = typename gil::channel_type<pixel_t>::type;
 185     gil::pixel_halves_t<pixel_t> f;
 186
 187     pixel_t p0;
 188     gil::static_fill(p0, static_cast<channel_t>(0));
 189     pixel_t p1;
 190     gil::static_fill(p1, static_cast<channel_t>(1));
 191
 192     {
 193         auto p = p0;
 194         BOOST_TEST(f(p) == p0);
 195     }
 196     {
 197         auto p = p1;
 198         BOOST_TEST(f(p) == p0); // truncates toward Zero
 199     }
 200     {
 201         pixel_t p2;
 202         gil::static_fill(p2, static_cast<channel_t>(2));
 203         BOOST_TEST(f(p2) == p1);
 204     }
 205 }
 206
 207 BOOST_AUTO_TEST_SUITE_END() // pixel_halves_t
 208
 209 BOOST_AUTO_TEST_SUITE(pixel_zeros_t)
 210
 211 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_zeros_integer_same_types, pixel_t, fixture::pixel_integer_types)
 212 {
 213     using channel_t = typename gil::channel_type<pixel_t>::type;
 214     gil::pixel_zeros_t<pixel_t> f;
 215
 216     pixel_t p0;
 217     gil::static_fill(p0, static_cast<channel_t>(0));
 218     {
 219         auto p = p0;
 220         BOOST_TEST(f(p) == p0);
 221     }
 222     {
 223         fixture::consecutive_value<channel_t> g(1);
 224         pixel_t p;
 225         gil::static_generate(p, [&g]() { return g(); });
 226         BOOST_TEST(f(p) == p0);
 227     }
 228 }
 229
 230 BOOST_AUTO_TEST_SUITE_END() // pixel_zeros_t
 231
 232 BOOST_AUTO_TEST_SUITE(zero_channels)
 233
 234 BOOST_AUTO_TEST_CASE_TEMPLATE(zero_channels_integer_same_types, pixel_t, fixture::pixel_integer_types)
 235 {
 236     using channel_t = typename gil::channel_type<pixel_t>::type;
 237
 238     pixel_t p0;
 239     gil::static_fill(p0, static_cast<channel_t>(0));
 240     {
 241         auto p = p0;
 242         gil::zero_channels(p);
 243         BOOST_TEST(p == p0);
 244     }
 245     {
 246         fixture::consecutive_value<channel_t> g(1);
 247         pixel_t p;
 248         gil::static_generate(p, [&g]() { return g(); });
 249         gil::zero_channels(p);
 250         BOOST_TEST(p == p0);
 251     }
 252 }
 253
 254 BOOST_AUTO_TEST_SUITE_END() // zero_channels
 255
 256 BOOST_AUTO_TEST_SUITE(pixel_assigns_t)
 257
 258 BOOST_AUTO_TEST_CASE_TEMPLATE(pixel_assigns_integer_same_types, pixel_t, fixture::pixel_integer_types)
 259 {
 260     using channel_t = typename gil::channel_type<pixel_t>::type;
 261     gil::pixel_assigns_t<pixel_t, pixel_t> f;
 262
 263     {
 264         pixel_t p0, r;
 265         gil::static_fill(p0, static_cast<channel_t>(0));
 266         f(p0, r);
 267         BOOST_TEST(p0 == r);
 268     }
 269     {
 270         fixture::consecutive_value<channel_t> g(1);
 271         pixel_t p, r;
 272         gil::static_generate(p, [&g]() { return g(); });
 273         f(p, r);
 274         BOOST_TEST(p == r);
 275     }
 276 }
 277
 278 BOOST_AUTO_TEST_SUITE_END() // pixel_assigns_t