Add tests

SimoxUtility/tests/json/EigenConversionTest.cpp

@@ -160,4 +160,14 @@ BOOST_AUTO_TEST_CASE(test_Matrix4f_transform_from_pos_ori)
 }
 
 
+BOOST_AUTO_TEST_CASE(test_from_json_Vector3d)
+{
+    nlohmann::json j = nlohmann::json::parse("[ 100.0, -200.0, 0.0 ]");
+    Eigen::Vector3d v = j.get<Eigen::Vector3d>();
+    BOOST_CHECK_EQUAL(v.x(), 100);
+    BOOST_CHECK_EQUAL(v.y(), -200);
+    BOOST_CHECK_EQUAL(v.z(), 0);
+}
+
+
 BOOST_AUTO_TEST_SUITE_END()

SimoxUtility/tests/shapes/AABB_center_extents.json

+{
+  "center": [
+    45.0,
+    90.0,
+    135.0
+  ],
+  "extents": [
+    110.0,
+    220.0,
+    330.0
+  ]
+}

SimoxUtility/tests/shapes/AABB_min_max.json

+{
+  "min": [
+    -10.0,
+    -20.0,
+    -30.0
+  ],
+  "max": [
+    100.0,
+    200.0,
+    300.0
+  ]
+}

SimoxUtility/tests/shapes/CMakeLists.txt

 
 ADD_SU_TEST( OrientedBoxTest )
 ADD_SU_TEST( XYConstrainedOrientedBoxTest )
+ADD_SU_TEST( JsonConversionsTest )
+
+
+SET(TEST_FILES
+    AABB_center_extents.json
+    AABB_min_max.json
+    OrientedBox_pos_ori_dimensions.json
+    OrientedBox_position_orientation_extents.json
+)
+
+foreach (FILENAME IN LISTS TEST_FILES)
+    configure_file("${FILENAME}" "${Simox_TEST_DIR}/${FILENAME}" COPYONLY)
+endforeach()

SimoxUtility/tests/shapes/JsonConversionsTest.cpp

+/**
+* @package    SimoxUtility
+* @author     Raphael Grimm
+* @copyright  2019 Raphael Grimm
+*/
+
+#define BOOST_TEST_MODULE SimoxUtility/shapes/OrientedBoxTest
+
+#include <random>
+#include <iostream>
+
+#include <boost/test/included/unit_test.hpp>
+
+#include <filesystem>
+
+#include <SimoxUtility/shapes/json_conversions.h>
+#include <SimoxUtility/shapes/OrientedBox.h>
+#include <SimoxUtility/shapes/AxisAlignedBoundingBox.h>
+#include <SimoxUtility/json/io.h>
+
+
+#include <SimoxUtility/json/util.h>
+#include <SimoxUtility/json/eigen_conversion.h>
+
+
+namespace
+{
+    static const std::vector<std::string> JSON_AABB_FILENAMES = {
+        "AABB_center_extents.json",
+        "AABB_min_max.json",
+    };
+    static const std::vector<std::string> JSON_ORIENTED_BOX_FILENAMES = {
+        "OrientedBox_position_orientation_extents.json",
+        "OrientedBox_pos_ori_dimensions.json",
+    };
+
+    const float PRECF = 1e-3f;
+    const double PRECD = 1e-3;
+}
+
+#define BOOST_CHECK_EQUAL_VECTOR(lhs, rhs, prec) \
+    BOOST_TEST_INFO((lhs).transpose() << " == " << (rhs).transpose()); \
+    BOOST_CHECK_LE(((lhs) - (rhs)).norm(), prec);
+
+
+namespace
+{
+    template <typename Float>
+    void test_read_OrientedBox_type(const Float prec)
+    {
+        namespace fs = std::filesystem;
+
+        for (const std::string& filename : JSON_ORIENTED_BOX_FILENAMES)
+        {
+            BOOST_TEST_CONTEXT("File " << filename)
+            {
+                BOOST_REQUIRE(fs::is_regular_file(filename));
+
+                const nlohmann::json j = nlohmann::read_json(filename);
+
+                const simox::OrientedBox<float> ob = j.get<simox::OrientedBox<float>>();
+                BOOST_CHECK_EQUAL_VECTOR(ob.center(), Eigen::Vector3f(10, -20, 0), prec);
+                BOOST_CHECK_EQUAL_VECTOR(ob.rotation(), Eigen::Quaternionf(0.707f, 0, 0.707f, 0).toRotationMatrix(), prec);
+                BOOST_CHECK_EQUAL_VECTOR(ob.dimensions(), Eigen::Vector3f(100, 200, 300), prec * Float(1e2));
+            }
+        }
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(test_read_AABB)
+{
+    namespace fs = std::filesystem;
+    float prec = 1e-4f;
+
+    for (const std::string& filename : JSON_AABB_FILENAMES)
+    {
+        BOOST_TEST_CONTEXT("File " << filename)
+        {
+            BOOST_REQUIRE(fs::is_regular_file(filename));
+
+            const nlohmann::json j = nlohmann::read_json(filename);
+
+            const simox::AxisAlignedBoundingBox aabb = j.get<simox::AxisAlignedBoundingBox>();
+            BOOST_CHECK_EQUAL_VECTOR(aabb.center(), Eigen::Vector3f(45, 90, 135), prec);
+            BOOST_CHECK_EQUAL_VECTOR(aabb.extents(), Eigen::Vector3f(110, 220, 330), prec);
+            BOOST_CHECK_EQUAL_VECTOR(aabb.min(), Eigen::Vector3f(-10, -20, -30), prec);
+            BOOST_CHECK_EQUAL_VECTOR(aabb.max(), Eigen::Vector3f(100, 200, 300), prec);
+        }
+    }
+}
+
+
+BOOST_AUTO_TEST_CASE(test_read_OrientedBox_float)
+{
+    test_read_OrientedBox_type<float>(PRECF);
+}
+
+BOOST_AUTO_TEST_CASE(test_read_OrientedBox_double)
+{
+    test_read_OrientedBox_type<double>(PRECD);
+}

SimoxUtility/tests/shapes/OrientedBoxTest.cpp

@@ -82,3 +82,29 @@ BOOST_AUTO_TEST_CASE(test_OrientedBox)
               Eigen::Vector3d::Random().cwiseAbs() * 10);
     }
 }
+
+
+#define BOOST_CHECK_EQUAL_VECTOR(lhs, rhs, prec) \
+    BOOST_TEST_INFO((lhs).transpose() << " == " << (rhs).transpose()); \
+    BOOST_CHECK_LE(((lhs) - (rhs)).norm(), prec);
+
+
+BOOST_AUTO_TEST_CASE(test_OrientedBox_from_pos_ori_extents)
+{
+    const Eigen::Vector3f pos(10, -20, 0);
+    const Eigen::Quaternionf quat = Eigen::Quaternionf(0.707f, 0, 0.707f, 0).normalized();
+    const Eigen::Matrix3f ori = quat.toRotationMatrix();
+    const Eigen::Vector3f extents(100, 200, 300);
+
+    const Eigen::Vector3f corner = pos - ori * extents / 2;
+
+    const simox::OrientedBox<float> ob(corner,
+                                        ori.col(0) * extents(0),
+                                        ori.col(1) * extents(1),
+                                        ori.col(2) * extents(2));
+
+    static const double prec = 1e-4;
+    BOOST_CHECK_EQUAL_VECTOR(ob.center(), pos, prec);
+    BOOST_CHECK_EQUAL_VECTOR(ob.rotation(), ori, prec);
+    BOOST_CHECK_EQUAL_VECTOR(ob.dimensions(), extents, prec);
+}

SimoxUtility/tests/shapes/OrientedBox_pos_ori_dimensions.json

+{
+  "dimensions": [
+    100.0,
+    200.0,
+    300.0
+  ],
+  "ori": {
+    "qw": 0.707,
+    "qx": 0.0,
+    "qy": 0.707,
+    "qz": 0.0
+  },
+  "pos": [
+    10.0,
+    -20.0,
+    0.0
+  ]
+}

SimoxUtility/tests/shapes/OrientedBox_position_orientation_extents.json

+{
+  "extents": [
+    100.0,
+    200.0,
+    300.0
+  ],
+  "orientation": {
+    "qw": 0.707,
+    "qx": 0.0,
+    "qy": 0.707,
+    "qz": 0.0
+  },
+  "position": [
+    10.0,
+    -20.0,
+    0.0
+  ]
+}