--[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",

examples/web_apps/webxr_hand_demo/js/vr_demo.js

@@ -307,8 +307,8 @@ export class VRDemo {
 
       handInfo.push({
         index: handIndex,
-        pos: Module.toVec3f(handPos),
-        rot: Module.toVec4f(handRot),
+        pos: handPos,
+        rot: handRot,
         gripButton: buttonStates[0],
         spawnButton: buttonStates[1]
       });

src/esp/agent/Agent.cpp

@@ -4,23 +4,20 @@
 
 #include "Agent.h"
 
-#include <Magnum/EigenIntegration/GeometryIntegration.h>
-#include <Magnum/EigenIntegration/Integration.h>
-
 #include "esp/scene/ObjectControls.h"
 #include "esp/sensor/Sensor.h"
 
-using Magnum::EigenIntegration::cast;
-
 namespace esp {
 namespace agent {
 
+namespace Mn = Magnum;
+
 const std::set<std::string> Agent::BodyActions = {"moveRight",   "moveLeft",
                                                   "moveForward", "moveBackward",
                                                   "turnLeft",    "turnRight"};
 
 Agent::Agent(scene::SceneNode& agentNode, const AgentConfiguration& cfg)
-    : Magnum::SceneGraph::AbstractFeature3D(agentNode),
+    : Mn::SceneGraph::AbstractFeature3D(agentNode),
       configuration_(cfg),
       controls_(scene::ObjectControls::create()) {
   agentNode.setType(scene::SceneNodeType::AGENT);
@@ -45,9 +42,8 @@ bool Agent::act(const std::string& actionName) {
       }
     }
     return true;
-  } else {
-    return false;
   }
+  return false;
 }
 
 bool Agent::hasAction(const std::string& actionName) const {
@@ -61,20 +57,22 @@ void Agent::reset() {
 
 void Agent::getState(const AgentState::ptr& state) const {
   // TODO this should be done less hackishly
-  state->position = cast<vec3f>(node().absoluteTransformation().translation());
-  state->rotation = quatf(node().rotation()).coeffs();
+  state->position = node().absoluteTransformation().translation();
+  // doing this for x,y,z,w format of state's rotation.
+  auto rot = node().rotation();
+  state->rotation = Mn::Vector4(rot.vector(), rot.scalar());
   // TODO other state members when implemented
 }
 
 void Agent::setState(const AgentState& state,
                      const bool resetSensors /*= true*/) {
-  node().setTranslation(Magnum::Vector3(state.position));
+  node().setTranslation(Mn::Vector3(state.position));
 
-  const Eigen::Map<const quatf> rot(state.rotation.data());
-  CORRADE_ASSERT(std::abs(rot.norm() - 1.0) <
-                     2.0 * Magnum::Math::TypeTraits<float>::epsilon(),
+  const Mn::Quaternion rot =
+      Mn::Quaternion(state.rotation.xyz(), state.rotation.w());
+  CORRADE_ASSERT(rot.isNormalized(),
                  state.rotation << " not a valid rotation", );
-  node().setRotation(Magnum::Quaternion(quatf(rot)).normalized());
+  node().setRotation(rot);
 
   if (resetSensors) {
     for (auto& p : node().getNodeSensors()) {

src/esp/agent/Agent.h

@@ -10,7 +10,6 @@
 #include <string>
 
 #include "esp/core/Esp.h"
-#include "esp/core/EspEigen.h"
 #include "esp/scene/SceneNode.h"
 
 namespace esp {
@@ -31,13 +30,13 @@ struct AgentState {
   /**
    * @brief the position of the agent
    */
-  vec3f position = {0, 0, 0};
+  Magnum::Vector3 position{0, 0, 0};
   /**
    * @brief the agent's rotation. TODO : This exposes the rotation quaternion
-   * x,y,z,w as vec4f for pybind11 interop, replace with quatf when we have
-   * custom pybind11 type conversion for quaternions
+   * x,y,z,w as Magnum Vector4 for pybind11 interop, replace with quatf when we
+   * have custom pybind11 type conversion for quaternions
    */
-  vec4f rotation = {0, 0, 0, 1};
+  Magnum::Vector4 rotation = {0, 0, 0, 1};
   ESP_SMART_POINTERS(AgentState)
 };
 

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)
@@ -3486,8 +3481,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);
@@ -3534,8 +3528,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(