libs/gil/test/extension/numeric/matrix3x2.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/extension/numeric/affine.hpp>
   9 #include <boost/gil/extension/numeric/resample.hpp>
  10 #include <boost/gil/extension/numeric/sampler.hpp>
  11 #include <boost/gil.hpp>
  12
  13 #define BOOST_TEST_MODULE test_ext_numeric_matrix3x2
  14 #include "unit_test.hpp"
  15
  16 namespace gil = boost::gil;
  17
  18 namespace {
  19 constexpr double HALF_PI = 1.57079632679489661923;
  20 }
  21
  22 BOOST_AUTO_TEST_CASE(matrix3x2_default_constructor)
  23 {
  24     gil::matrix3x2<int> m1;
  25     BOOST_TEST(m1.a == 1);
  26     BOOST_TEST(m1.b == 0);
  27     BOOST_TEST(m1.c == 0);
  28     BOOST_TEST(m1.d == 1);
  29     BOOST_TEST(m1.e == 0);
  30     BOOST_TEST(m1.f == 0);
  31 }
  32
  33 BOOST_AUTO_TEST_CASE(matrix3x2_parameterized_constructor)
  34 {
  35     gil::matrix3x2<int> m1(1, 2, 3, 4, 5, 6);
  36     BOOST_TEST(m1.a == 1);
  37     BOOST_TEST(m1.b == 2);
  38     BOOST_TEST(m1.c == 3);
  39     BOOST_TEST(m1.d == 4);
  40     BOOST_TEST(m1.e == 5);
  41     BOOST_TEST(m1.f == 6);
  42 }
  43
  44 BOOST_AUTO_TEST_CASE(matrix3x2_copy_constructor)
  45 {
  46     gil::matrix3x2<int> m1(1, 2, 3, 4, 5, 6);
  47     gil::matrix3x2<int> m2(m1);
  48     BOOST_TEST(m2.a == 1);
  49     BOOST_TEST(m2.b == 2);
  50     BOOST_TEST(m2.c == 3);
  51     BOOST_TEST(m2.d == 4);
  52     BOOST_TEST(m2.e == 5);
  53     BOOST_TEST(m2.f == 6);
  54 }
  55
  56 BOOST_AUTO_TEST_CASE(matrix3x2_assignment_operator)
  57 {
  58     gil::matrix3x2<int> m1(1, 2, 3, 4, 5, 6);
  59     gil::matrix3x2<int> m2;
  60     m2 = m1;
  61     BOOST_TEST(m2.a == 1);
  62     BOOST_TEST(m2.b == 2);
  63     BOOST_TEST(m2.c == 3);
  64     BOOST_TEST(m2.d == 4);
  65     BOOST_TEST(m2.e == 5);
  66     BOOST_TEST(m2.f == 6);
  67 }
  68
  69 BOOST_AUTO_TEST_CASE(matrix3x2_multiplication_assignment)
  70 {
  71     gil::matrix3x2<int> m1;
  72     gil::matrix3x2<int> m2;
  73     m2 *= m1;
  74     BOOST_TEST(m2.a == 1);
  75     BOOST_TEST(m2.b == 0);
  76     BOOST_TEST(m2.c == 0);
  77     BOOST_TEST(m2.d == 1);
  78     BOOST_TEST(m2.e == 0);
  79     BOOST_TEST(m2.f == 0);
  80
  81     gil::matrix3x2<int> m3(0, 0, 0, 0, 0, 0);
  82     m2 *= m3;
  83     BOOST_TEST(m2.a == 0);
  84     BOOST_TEST(m2.b == 0);
  85     BOOST_TEST(m2.c == 0);
  86     BOOST_TEST(m2.d == 0);
  87     BOOST_TEST(m2.e == 0);
  88     BOOST_TEST(m2.f == 0);
  89 }
  90
  91 BOOST_AUTO_TEST_CASE(matrix3x2_matrix3x2_multiplication)
  92 {
  93     gil::matrix3x2<int> m1;
  94     gil::matrix3x2<int> m2(0, 0, 0, 0, 0, 0);
  95     gil::matrix3x2<int> m3;
  96     m3 = m1 * m2;
  97     BOOST_TEST(m3.a == 0);
  98     BOOST_TEST(m3.b == 0);
  99     BOOST_TEST(m3.c == 0);
 100     BOOST_TEST(m3.d == 0);
 101     BOOST_TEST(m3.e == 0);
 102     BOOST_TEST(m3.f == 0);
 103 }
 104
 105 BOOST_AUTO_TEST_CASE(matrix3x2_vector_multiplication)
 106 {
 107     gil::matrix3x2<int> m1;
 108     gil::point<int> v1{2, 4};
 109
 110     gil::point<int> v2 = v1 * m1;
 111     BOOST_TEST(v2.x == 2);
 112     BOOST_TEST(v2.y == 4);
 113
 114     gil::point<int> v3 = gil::transform(m1, v1);
 115     BOOST_TEST(v3.x == 2);
 116     BOOST_TEST(v3.y == 4);
 117 }
 118
 119 BOOST_AUTO_TEST_CASE(matrix3x2_get_rotate)
 120 {
 121     auto m1 = gil::matrix3x2<double>::get_rotate(HALF_PI);
 122     BOOST_TEST(m1.a == std::cos(HALF_PI), btt::tolerance(0.03));
 123     BOOST_TEST(m1.b == 1);
 124     BOOST_TEST(m1.c == -1);
 125     BOOST_TEST(m1.d == std::cos(HALF_PI), btt::tolerance(0.03));
 126     BOOST_TEST(m1.e == 0);
 127     BOOST_TEST(m1.f == 0);
 128 }
 129
 130 BOOST_AUTO_TEST_CASE(matrix3x2_get_scale)
 131 {
 132     gil::matrix3x2<int> m1;
 133     m1 = gil::matrix3x2<int>::get_scale(2);
 134     BOOST_TEST(m1.a == 2);
 135     BOOST_TEST(m1.b == 0);
 136     BOOST_TEST(m1.c == 0);
 137     BOOST_TEST(m1.d == 2);
 138     BOOST_TEST(m1.e == 0);
 139     BOOST_TEST(m1.f == 0);
 140     m1 = gil::matrix3x2<int>::get_scale(2, 4);
 141     BOOST_TEST(m1.a == 2);
 142     BOOST_TEST(m1.d == 4);
 143     m1 = gil::matrix3x2<int>::get_scale(gil::point<int>{4, 8});
 144     BOOST_TEST(m1.a == 4);
 145     BOOST_TEST(m1.d == 8);
 146 }
 147
 148 BOOST_AUTO_TEST_CASE(matrix3x2_get_translate)
 149 {
 150     gil::matrix3x2<int> m1;
 151     m1 = gil::matrix3x2<int>::get_translate(2, 4);
 152     BOOST_TEST(m1.a == 1);
 153     BOOST_TEST(m1.b == 0);
 154     BOOST_TEST(m1.c == 0);
 155     BOOST_TEST(m1.d == 1);
 156     BOOST_TEST(m1.e == 2);
 157     BOOST_TEST(m1.f == 4);
 158     m1 = gil::matrix3x2<int>::get_translate(gil::point<int>{4, 8});
 159     BOOST_TEST(m1.e == 4);
 160     BOOST_TEST(m1.f == 8);
 161 }
 162
 163 BOOST_AUTO_TEST_CASE(matrix3x2_transform)
 164 {
 165     gil::matrix3x2<int> m1;
 166     gil::point<int> v1{2, 4};
 167     gil::point<int> v2 = gil::transform(m1, v1);
 168     BOOST_TEST(v2.x == 2);
 169     BOOST_TEST(v2.y == 4);
 170 }