--[BE][WIP] Remove Eigen dependency

examples/demo_runner.py

@@ -302,21 +302,21 @@ def do_time_steps(self):
     def print_semantic_scene(self):
         if self._sim_settings["print_semantic_scene"]:
             scene = self._sim.semantic_scene
-            print(f"House center:{scene.aabb.center} dims:{scene.aabb.sizes}")
+            print(f"House center:{scene.aabb.center} dims:{scene.aabb.size}")
             for level in scene.levels:
                 print(
                     f"Level id:{level.id}, center:{level.aabb.center},"
-                    f" dims:{level.aabb.sizes}"
+                    f" dims:{level.aabb.size}"
                 )
                 for region in level.regions:
                     print(
                         f"Region id:{region.id}, category:{region.category.name()},"
-                        f" center:{region.aabb.center}, dims:{region.aabb.sizes}"
+                        f" center:{region.aabb.center}, dims:{region.aabb.size}"
                     )
                     for obj in region.objects:
                         print(
                             f"Object id:{obj.id}, category:{obj.category.name()},"
-                            f" center:{obj.aabb.center}, dims:{obj.aabb.sizes}"
+                            f" center:{obj.aabb.center}, dims:{obj.aabb.size}"
                         )
             input("Press Enter to continue...")
 

examples/tutorials/nb_python/ECCV_2020_Navigation.py

@@ -375,23 +375,23 @@ def print_scene_recur(scene, limit_output=10):
     print(
         f"House has {len(scene.levels)} levels, {len(scene.regions)} regions and {len(scene.objects)} objects"
     )
-    print(f"House center:{scene.aabb.center} dims:{scene.aabb.sizes}")
+    print(f"House center:{scene.aabb.center} dims:{scene.aabb.size}")
 
     count = 0
     for level in scene.levels:
         print(
             f"Level id:{level.id}, center:{level.aabb.center},"
-            f" dims:{level.aabb.sizes}"
+            f" dims:{level.aabb.size}"
         )
         for region in level.regions:
             print(
                 f"Region id:{region.id}, category:{region.category.name()},"
-                f" center:{region.aabb.center}, dims:{region.aabb.sizes}"
+                f" center:{region.aabb.center}, dims:{region.aabb.size}"
             )
             for obj in region.objects:
                 print(
                     f"Object id:{obj.id}, category:{obj.category.name()},"
-                    f" center:{obj.aabb.center}, dims:{obj.aabb.sizes}"
+                    f" center:{obj.aabb.center}, dims:{obj.aabb.size}"
                 )
                 count += 1
                 if count >= limit_output:

examples/tutorials/notebooks/ECCV_2020_Navigation.ipynb

@@ -450,23 +450,23 @@
     "    print(\n",
     "        f\"House has {len(scene.levels)} levels, {len(scene.regions)} regions and {len(scene.objects)} objects\"\n",
     "    )\n",
-    "    print(f\"House center:{scene.aabb.center} dims:{scene.aabb.sizes}\")\n",
+    "    print(f\"House center:{scene.aabb.center} dims:{scene.aabb.size}\")\n",
     "\n",
     "    count = 0\n",
     "    for level in scene.levels:\n",
     "        print(\n",
     "            f\"Level id:{level.id}, center:{level.aabb.center},\"\n",
-    "            f\" dims:{level.aabb.sizes}\"\n",
+    "            f\" dims:{level.aabb.size}\"\n",
     "        )\n",
     "        for region in level.regions:\n",
     "            print(\n",
     "                f\"Region id:{region.id}, category:{region.category.name()},\"\n",
-    "                f\" center:{region.aabb.center}, dims:{region.aabb.sizes}\"\n",
+    "                f\" center:{region.aabb.center}, dims:{region.aabb.size}\"\n",
     "            )\n",
     "            for obj in region.objects:\n",
     "                print(\n",
     "                    f\"Object id:{obj.id}, category:{obj.category.name()},\"\n",
-    "                    f\" center:{obj.aabb.center}, dims:{obj.aabb.sizes}\"\n",
+    "                    f\" center:{obj.aabb.center}, dims:{obj.aabb.size}\"\n",
     "                )\n",
     "                count += 1\n",
     "                if count >= limit_output:\n",

src/esp/assets/GenericSemanticMeshData.cpp

@@ -19,6 +19,7 @@
 #include <Magnum/PixelFormat.h>
 #include <Magnum/Shaders/GenericGL.h>
 
+#include "esp/core/Utility.h"
 #include "esp/geo/Geo.h"
 #include "esp/scene/SemanticScene.h"
 
@@ -65,8 +66,7 @@ GenericSemanticMeshData::buildSemanticMeshData(
   if (semanticFilename.find(".ply") != std::string::npos) {
     // Generic Semantic PLY meshes have -Z gravity
     const auto T_esp_scene =
-        Mn::Quaternion{quatf::FromTwoVectors(-vec3f::UnitZ(), geo::ESP_GRAVITY)}
-            .toMatrix();
+        Mn::Quaternion::rotation(geo::ESP_FRONT, geo::ESP_GRAVITY).toMatrix();
     for (auto& xyz : semanticMeshData->cpu_vbo_) {
       xyz = T_esp_scene * xyz;
     }
@@ -307,7 +307,7 @@ GenericSemanticMeshData::buildSemanticMeshData(
   // display or save report denoting presence of semantic object-defined colors
   // in mesh
   return semanticMeshData;
-}  // GenericSemanticMeshData::buildSemanticMeshData
+}  // namespace assets
 
 std::vector<std::unique_ptr<GenericSemanticMeshData>>
 GenericSemanticMeshData::partitionSemanticMeshData(

src/esp/assets/MeshData.h

@@ -8,21 +8,20 @@
 #include <vector>
 
 #include "esp/core/Esp.h"
-#include "esp/core/EspEigen.h"
 
 namespace esp {
 namespace assets {
 
 //! Raw mesh data storage
 struct MeshData {
   //! Vertex positions
-  std::vector<vec3f> vbo;
+  std::vector<Magnum::Vector3> vbo;
   //! Vertex normals
-  std::vector<vec3f> nbo;
+  std::vector<Magnum::Vector3> nbo;
   //! Texture coordinates
-  std::vector<vec2f> tbo;
+  std::vector<Magnum::Vector2> tbo;
   //! Vertex colors
-  std::vector<vec3f> cbo;
+  std::vector<Magnum::Vector3> cbo;
   //! Index buffer
   std::vector<uint32_t> ibo;
 

src/esp/assets/MeshMetaData.h

@@ -140,9 +140,9 @@ struct MeshMetaData {
    * @param frame target frame in world space
    */
   void setRootFrameOrientation(const geo::CoordinateFrame& frame) {
-    const quatf& transform = frame.rotationFrameToWorld();
-    Magnum::Matrix4 R = Magnum::Matrix4::from(
-        Magnum::Quaternion(transform).toMatrix(), Magnum::Vector3());
+    const Magnum::Quaternion& transform = frame.rotationFrameToWorld();
+    Magnum::Matrix4 R =
+        Magnum::Matrix4::from(transform.toMatrix(), Magnum::Vector3());
     root.transformFromLocalToParent = R * root.transformFromLocalToParent;
   }
 };

src/esp/assets/ResourceManager.cpp

@@ -20,8 +20,6 @@
 #include <Corrade/Utility/Path.h>
 #include <Corrade/Utility/Resource.h>
 #include <Corrade/Utility/String.h>
-#include <Magnum/EigenIntegration/GeometryIntegration.h>
-#include <Magnum/EigenIntegration/Integration.h>
 #include <Magnum/GL/Context.h>
 #include <Magnum/GL/Extensions.h>
 #include <Magnum/GL/TextureFormat.h>
@@ -686,11 +684,8 @@ esp::geo::CoordinateFrame ResourceManager::buildFrameFromAttributes(
     const Mn::Vector3& up,
     const Mn::Vector3& front,
     const Mn::Vector3& origin) {
-  const vec3f upEigen{Mn::EigenIntegration::cast<vec3f>(up)};
-  const vec3f frontEigen{Mn::EigenIntegration::cast<vec3f>(front)};
-  if (upEigen.isOrthogonal(frontEigen)) {
-    const vec3f originEigen{Mn::EigenIntegration::cast<vec3f>(origin)};
-    esp::geo::CoordinateFrame frame{upEigen, frontEigen, originEigen};
+  if (abs(Mn::Math::dot(up, front)) < Mn::Math::TypeTraits<float>::epsilon()) {
+    esp::geo::CoordinateFrame frame{up, front, origin};
     return frame;
   }
   ESP_DEBUG(Mn::Debug::Flag::NoSpace)
@@ -3470,8 +3465,7 @@ void ResourceManager::joinHierarchy(
           << "` so skipping join.";
     } else {
       for (const auto& pos : meshData.positions) {
-        mesh.vbo.push_back(Mn::EigenIntegration::cast<vec3f>(
-            transformFromLocalToWorld.transformPoint(pos)));
+        mesh.vbo.push_back(transformFromLocalToWorld.transformPoint(pos));
       }
       for (const auto& index : meshData.indices) {
         mesh.ibo.push_back(index + lastIndex);
@@ -3518,8 +3512,7 @@ void ResourceManager::joinSemanticHierarchy(
 
     // Save the vertices
     for (const auto& pos : vertices) {
-      mesh.vbo.push_back(Mn::EigenIntegration::cast<vec3f>(
-          transformFromLocalToWorld.transformPoint(pos)));
+      mesh.vbo.push_back(transformFromLocalToWorld.transformPoint(pos));
     }
 
     // Save the indices

src/esp/bindings/Bindings.cpp

@@ -14,17 +14,6 @@
 namespace py = pybind11;
 using py::literals::operator""_a;
 
-namespace esp {
-
-void initEspBindings(py::module& m) {
-  // ==== box3f ====
-  py::class_<box3f>(m, "BBox")
-      .def_property_readonly("sizes", &box3f::sizes)
-      .def_property_readonly("center", &box3f::center);
-}
-
-}  // namespace esp
-
 PYBIND11_MODULE(habitat_sim_bindings, m) {
   m.attr("cuda_enabled") =
 #ifdef ESP_BUILD_WITH_CUDA
@@ -59,7 +48,6 @@ PYBIND11_MODULE(habitat_sim_bindings, m) {
 
   py::bind_map<std::map<std::string, std::string>>(m, "MapStringString");
 
-  esp::initEspBindings(m);
   esp::core::config::initConfigBindings(m);
   esp::core::initCoreBindings(m);
   esp::geo::initGeoBindings(m);

src/esp/bindings/GeoBindings.cpp

@@ -7,8 +7,6 @@
 #include "esp/geo/Geo.h"
 #include "esp/geo/OBB.h"
 
-#include <Magnum/EigenIntegration/GeometryIntegration.h>
-
 namespace Mn = Magnum;
 namespace py = pybind11;
 using py::literals::operator""_a;
@@ -23,18 +21,17 @@ void initGeoBindings(py::module& m) {
   geo.attr("GRAVITY") = ESP_GRAVITY;
   geo.attr("FRONT") = ESP_FRONT;
   geo.attr("BACK") = ESP_BACK;
-  geo.attr("LEFT") = ESP_FRONT.cross(ESP_GRAVITY);
-  geo.attr("RIGHT") = ESP_FRONT.cross(ESP_UP);
+  geo.attr("LEFT") = Mn::Math::cross(ESP_FRONT, ESP_GRAVITY);
+  geo.attr("RIGHT") = Mn::Math::cross(ESP_FRONT, ESP_UP);
 
   // ==== OBB ====
   py::class_<OBB>(m, "OBB", R"(This is an OBB.)")
-      .def(py::init([](const vec3f& center, const vec3f& dimensions,
+      .def(py::init([](const Mn::Vector3& center, const Mn::Vector3& dimensions,
                        const Mn::Quaternion& rotation) {
-             return OBB(center, dimensions,
-                        Mn::EigenIntegration::cast<quatf>(rotation));
+             return OBB(center, dimensions, rotation);
            }),
            "center"_a, "dimensions"_a, "rotation"_a)
-      .def(py::init<box3f&>())
+      .def(py::init<Mn::Range3D&>())
       .def(
           "contains", &OBB::contains,
           R"(Returns whether world coordinate point p is contained in this OBB within threshold distance epsilon.)")
@@ -48,7 +45,7 @@ void initGeoBindings(py::module& m) {
       .def(
           "rotate",
           [](OBB& self, const Mn::Quaternion& rotation) {
-            return self.rotate(Mn::EigenIntegration::cast<quatf>(rotation));
+            return self.rotate(rotation);
           },
           R"(Rotate this OBB by the given rotation and return reference to self.)")
       .def_property_readonly("center", &OBB::center, R"(Centroid of this OBB.)")
@@ -59,15 +56,19 @@ void initGeoBindings(py::module& m) {
       .def_property_readonly("half_extents", &OBB::halfExtents,
                              R"(Half-extents of this OBB (dimensions).)")
       .def_property_readonly(
-          "rotation", [](const OBB& self) { return self.rotation().coeffs(); },
+          // Return as an array of format [x,y,z,w] to retain existing
+          // expectations
+          "rotation",
+          [](const OBB& self) {
+            const Mn::Quaternion q = self.rotation();
+            return Mn::Vector4(q.vector(), q.scalar());
+          },
           R"(Quaternion representing rotation of this OBB.)")
       .def_property_readonly(
-          "local_to_world",
-          [](const OBB& self) { return self.localToWorld().matrix(); },
+          "local_to_world", [](const OBB& self) { return self.localToWorld(); },
           R"(Transform from local [0,1]^3 coordinates to world coordinates.)")
       .def_property_readonly(
-          "world_to_local",
-          [](const OBB& self) { return self.worldToLocal().matrix(); },
+          "world_to_local", [](const OBB& self) { return self.worldToLocal(); },
           R"(Transform from world coordinates to local [0,1]^3 coordinates.)");
 
   geo.def(

src/esp/bindings/SceneBindings.cpp

@@ -253,11 +253,11 @@ void initSceneBindings(
       .def_static(
           "load_mp3d_house",
           [](const std::string& filename, SemanticScene& scene,
-             const vec4f& rotation) {
+             const Mn::Vector4& rotation) {
             // numpy doesn't have a quaternion equivalent, use vec4
             // instead
-            return SemanticScene::loadMp3dHouse(
-                filename, scene, Eigen::Map<const quatf>(rotation.data()));
+            return SemanticScene::loadMp3dHouse(filename, scene,
+                                                {rotation.xyz(), rotation.w()});
           },
           R"(
         Loads a SemanticScene from a Matterport3D House format file into passed

src/esp/bindings/ShortestPathBindings.cpp

@@ -174,24 +174,25 @@ void initShortestPathBindings(py::module& m) {
           R"(Finds the shortest path between a start point and the closest of a set of end points (in geodesic distance) on the navigation mesh using MultiGoalShortestPath module. Path variable is filled if successful. Returns boolean success.)")
       .def("try_step", &PathFinder::tryStep<Magnum::Vector3>, "start"_a,
            "end"_a)
-      .def("try_step", &PathFinder::tryStep<vec3f>, "start"_a, "end"_a)
+      .def("try_step", &PathFinder::tryStep<Magnum::Vector3>, "start"_a,
+           "end"_a)
+      .def("try_step_no_sliding",
+           &PathFinder::tryStepNoSliding<Magnum::Vector3>, "start"_a, "end"_a)
       .def("try_step_no_sliding",
            &PathFinder::tryStepNoSliding<Magnum::Vector3>, "start"_a, "end"_a)
-      .def("try_step_no_sliding", &PathFinder::tryStepNoSliding<vec3f>,
-           "start"_a, "end"_a)
       .def("snap_point", &PathFinder::snapPoint<Magnum::Vector3>, "point"_a,
            "island_index"_a = ID_UNDEFINED)
-      .def("snap_point", &PathFinder::snapPoint<vec3f>, "point"_a,
+      .def("snap_point", &PathFinder::snapPoint<Magnum::Vector3>, "point"_a,
            "island_index"_a = ID_UNDEFINED)
       .def(
           "get_island", &PathFinder::getIsland<Magnum::Vector3>, "point"_a,
           R"(Query the island closest to a point. Snaps the point to the NavMesh first, so check the snap distance also if unsure.)")
       .def(
-          "get_island", &PathFinder::getIsland<vec3f>, "point"_a,
+          "get_island", &PathFinder::getIsland<Magnum::Vector3>, "point"_a,
           R"(Query the island closest to a point. Snaps the point to the NavMesh first, so check the snap distance also if unsure.)")
       .def(
           "island_radius",
-          [](PathFinder& self, const vec3f& pt) {
+          [](PathFinder& self, const Magnum::Vector3& pt) {
             return self.islandRadius(pt);
           },
           "pt"_a,