Deprecating Quaternion3f in favor of Quatf

lmontaut · Jan 2, 2024 · 2307511 · 2307511
1 parent c2c84e3
commit 2307511
Show file tree

Hide file tree

Showing 10 changed files with 38 additions and 39 deletions.
diff --git a/include/hpp/fcl/math/transform.h b/include/hpp/fcl/math/transform.h
@@ -38,14 +38,16 @@
 #ifndef HPP_FCL_TRANSFORM_H
 #define HPP_FCL_TRANSFORM_H
 
+#include <hpp/fcl/fwd.hh>
 #include <hpp/fcl/data_types.h>
 
 namespace hpp {
 namespace fcl {
 
-typedef Eigen::Quaternion<FCL_REAL> Quaternion3f;
+HPP_FCL_DEPRECATED typedef Eigen::Quaternion<FCL_REAL> Quaternion3f;
+typedef Eigen::Quaternion<FCL_REAL> Quatf;
 
-static inline std::ostream& operator<<(std::ostream& o, const Quaternion3f& q) {
+static inline std::ostream& operator<<(std::ostream& o, const Quatf& q) {
   o << "(" << q.w() << " " << q.x() << " " << q.y() << " " << q.z() << ")";
   return o;
 }
@@ -74,14 +76,14 @@ class HPP_FCL_DLLAPI Transform3f {
 
   /// @brief Construct transform from rotation and translation
   template <typename Vector3Like>
-  Transform3f(const Quaternion3f& q_, const Eigen::MatrixBase<Vector3Like>& T_)
+  Transform3f(const Quatf& q_, const Eigen::MatrixBase<Vector3Like>& T_)
       : R(q_.toRotationMatrix()), T(T_) {}
 
   /// @brief Construct transform from rotation
   Transform3f(const Matrix3f& R_) : R(R_), T(Vec3f::Zero()) {}
 
   /// @brief Construct transform from rotation
-  Transform3f(const Quaternion3f& q_) : R(q_), T(Vec3f::Zero()) {}
+  Transform3f(const Quatf& q_) : R(q_), T(Vec3f::Zero()) {}
 
   /// @brief Construct transform from translation
   Transform3f(const Vec3f& T_) : R(Matrix3f::Identity()), T(T_) {}
@@ -115,7 +117,7 @@ class HPP_FCL_DLLAPI Transform3f {
   inline Matrix3f& rotation() { return R; }
 
   /// @brief get quaternion
-  inline Quaternion3f getQuatRotation() const { return Quaternion3f(R); }
+  inline Quatf getQuatRotation() const { return Quatf(R); }
 
   /// @brief set transform from rotation and translation
   template <typename Matrix3Like, typename Vector3Like>
@@ -126,7 +128,7 @@ class HPP_FCL_DLLAPI Transform3f {
   }
 
   /// @brief set transform from rotation and translation
-  inline void setTransform(const Quaternion3f& q_, const Vec3f& T_) {
+  inline void setTransform(const Quatf& q_, const Vec3f& T_) {
     R = q_.toRotationMatrix();
     T = T_;
   }
@@ -144,9 +146,7 @@ class HPP_FCL_DLLAPI Transform3f {
   }
 
   /// @brief set transform from rotation
-  inline void setQuatRotation(const Quaternion3f& q_) {
-    R = q_.toRotationMatrix();
-  }
+  inline void setQuatRotation(const Quatf& q_) { R = q_.toRotationMatrix(); }
 
   /// @brief transform a given vector by the transform
   template <typename Derived>
@@ -206,9 +206,9 @@ class HPP_FCL_DLLAPI Transform3f {
 };
 
 template <typename Derived>
-inline Quaternion3f fromAxisAngle(const Eigen::MatrixBase<Derived>& axis,
-                                  FCL_REAL angle) {
-  return Quaternion3f(Eigen::AngleAxis<FCL_REAL>(angle, axis));
+inline Quatf fromAxisAngle(const Eigen::MatrixBase<Derived>& axis,
+                           FCL_REAL angle) {
+  return Quatf(Eigen::AngleAxis<FCL_REAL>(angle, axis));
 }
 
 }  // namespace fcl

diff --git a/python/math.cc b/python/math.cc
@@ -77,10 +77,9 @@ void exposeMaths() {
       .def(dv::init<Transform3f>())
       .def(dv::init<Transform3f, const Matrix3f::MatrixBase&,
                     const Vec3f::MatrixBase&>())
-      .def(dv::init<Transform3f, const Quaternion3f&,
-                    const Vec3f::MatrixBase&>())
+      .def(dv::init<Transform3f, const Quatf&, const Vec3f::MatrixBase&>())
       .def(dv::init<Transform3f, const Matrix3f&>())
-      .def(dv::init<Transform3f, const Quaternion3f&>())
+      .def(dv::init<Transform3f, const Quatf&>())
       .def(dv::init<Transform3f, const Vec3f&>())
       .def(dv::init<Transform3f, const Transform3f&>())
 
@@ -102,7 +101,7 @@ void exposeMaths() {
                            &Transform3f::setTransform<Matrix3f, Vec3f>))
       .def(dv::member_func(
           "setTransform",
-          static_cast<void (Transform3f::*)(const Quaternion3f&, const Vec3f&)>(
+          static_cast<void (Transform3f::*)(const Quatf&, const Vec3f&)>(
               &Transform3f::setTransform)))
       .def(dv::member_func("setIdentity", &Transform3f::setIdentity))
       .def(dv::member_func("Identity", &Transform3f::Identity))

diff --git a/src/BV/OBB.cpp b/src/BV/OBB.cpp
@@ -116,10 +116,10 @@ inline OBB merge_largedist(const OBB& b1, const OBB& b2) {
 inline OBB merge_smalldist(const OBB& b1, const OBB& b2) {
   OBB b;
   b.To = (b1.To + b2.To) * 0.5;
-  Quaternion3f q0(b1.axes), q1(b2.axes);
+  Quatf q0(b1.axes), q1(b2.axes);
   if (q0.dot(q1) < 0) q1.coeffs() *= -1;
 
-  Quaternion3f q((q0.coeffs() + q1.coeffs()).normalized());
+  Quatf q((q0.coeffs() + q1.coeffs()).normalized());
   b.axes = q.toRotationMatrix();
 
   Vec3f vertex[8], diff;

diff --git a/test/bvh_models.cpp b/test/bvh_models.cpp
@@ -206,15 +206,15 @@ void testBVHModelTriangles() {
 
   pose.setTranslation(Vec3f(0, 0, 0));
   FCL_REAL sqrt2_2 = std::sqrt(2) / 2;
-  pose.setQuatRotation(Quaternion3f(sqrt2_2, sqrt2_2, 0, 0));
+  pose.setQuatRotation(Quatf(sqrt2_2, sqrt2_2, 0, 0));
   cropped.reset(BVHExtract(*model, pose, aabb));
   BOOST_REQUIRE(cropped);
   BOOST_CHECK(cropped->build_state == BVH_BUILD_STATE_PROCESSED);
   BOOST_CHECK_EQUAL(cropped->num_vertices, model->num_vertices - 6);
   BOOST_CHECK_EQUAL(cropped->num_tris, model->num_tris - 2);
 
   pose.setTranslation(-Vec3f(1, 1, 1));
-  pose.setQuatRotation(Quaternion3f::Identity());
+  pose.setQuatRotation(Quatf::Identity());
   cropped.reset(BVHExtract(*model, pose, aabb));
   BOOST_CHECK(!cropped);
 

diff --git a/test/geometric_shapes.cpp b/test/geometric_shapes.cpp
@@ -239,12 +239,12 @@ BOOST_AUTO_TEST_CASE(shapeIntersection_cylinderbox) {
   Box s2(1.6, 0.6, 0.025);
 
   Transform3f tf1(
-      Quaternion3f(0.5279170511703305, -0.50981118132505521,
-                   -0.67596178682051911, 0.0668715876735793),
+      Quatf(0.5279170511703305, -0.50981118132505521, -0.67596178682051911,
+            0.0668715876735793),
       Vec3f(0.041218354748013122, 1.2022554710435607, 0.77338855025700015));
 
   Transform3f tf2(
-      Quaternion3f(0.70738826916719977, 0, 0, 0.70682518110536596),
+      Quatf(0.70738826916719977, 0, 0, 0.70682518110536596),
       Vec3f(-0.29936284351096382, 0.80023864435868775, 0.71750000000000003));
 
   GJKSolver solver;
@@ -285,8 +285,8 @@ BOOST_AUTO_TEST_CASE(shapeIntersection_cylinderbox) {
   s1 = Cylinder(0.06, 0.1);
   tf1.setTranslation(
       Vec3f(-0.66734052046473924, 0.22219183277457269, 0.76825248755616293));
-  tf1.setQuatRotation(Quaternion3f(0.52613359459338371, 0.32189408354839893,
-                                   0.70415587451837913, -0.35175580165512249));
+  tf1.setQuatRotation(Quatf(0.52613359459338371, 0.32189408354839893,
+                            0.70415587451837913, -0.35175580165512249));
   res = solver.shapeDistance(s1, tf1, s2, tf2, distance, p1, p2, normal);
 }
 
@@ -450,7 +450,7 @@ BOOST_AUTO_TEST_CASE(shapeIntersection_boxbox) {
   // FCL_REAL depth;
   Vec3f normal;
 
-  Quaternion3f q;
+  Quatf q;
   q = AngleAxis((FCL_REAL)3.140 / 6, UnitZ);
 
   tf1 = Transform3f();
@@ -3402,7 +3402,7 @@ BOOST_AUTO_TEST_CASE(shapeIntersectionGJK_boxbox) {
   // FCL_REAL depth;
   Vec3f normal;
 
-  Quaternion3f q;
+  Quatf q;
   q = AngleAxis((FCL_REAL)3.140 / 6, UnitZ);
 
   tf1 = Transform3f();

diff --git a/test/gjk.cpp b/test/gjk.cpp
@@ -49,7 +49,7 @@ using hpp::fcl::FCL_REAL;
 using hpp::fcl::GJKSolver;
 using hpp::fcl::GJKVariant;
 using hpp::fcl::Matrix3f;
-using hpp::fcl::Quaternion3f;
+using hpp::fcl::Quatf;
 using hpp::fcl::Transform3f;
 using hpp::fcl::TriangleP;
 using hpp::fcl::Vec3f;
@@ -103,8 +103,8 @@ void test_gjk_distance_triangle_triangle(
       Q2_loc = Vec3f(-10.926, -1.284259033203125, 3.7281499023437501);
       Q3_loc = Vec3f(-10.926, -1.2866180419921875, 3.72335400390625);
       Transform3f tf(
-          Quaternion3f(-0.42437287410898855, -0.26862477561450587,
-                       -0.46249645019513175, 0.73064726592483387),
+          Quatf(-0.42437287410898855, -0.26862477561450587,
+                -0.46249645019513175, 0.73064726592483387),
           Vec3f(-12.824601270753471, -1.6840516940066426, 3.8914453043793844));
       tf1 = tf;
     } else if (i == 1) {
@@ -323,8 +323,8 @@ void test_gjk_unit_sphere(FCL_REAL center_distance, Vec3f ray,
   Sphere sphere(1.);
 
   typedef Eigen::Matrix<FCL_REAL, 4, 1> Vec4f;
-  Transform3f tf0(Quaternion3f(Vec4f::Random().normalized()), Vec3f::Zero()),
-      tf1(Quaternion3f(Vec4f::Random().normalized()), center_distance * ray);
+  Transform3f tf0(Quatf(Vec4f::Random().normalized()), Vec3f::Zero()),
+      tf1(Quatf(Vec4f::Random().normalized()), center_distance * ray);
 
   details::MinkowskiDiff shape;
   shape.set(&sphere, &sphere, tf0, tf1);

diff --git a/test/math.cpp b/test/math.cpp
@@ -111,7 +111,7 @@ Vec3f rotate(Vec3f input, FCL_REAL w, Vec3f vec) {
 }
 
 BOOST_AUTO_TEST_CASE(quaternion) {
-  Quaternion3f q1(Quaternion3f::Identity()), q2, q3;
+  Quatf q1(Quatf::Identity()), q2, q3;
   q2 = fromAxisAngle(Vec3f(0, 0, 1), M_PI / 2);
   q3 = q2.inverse();
 
@@ -124,7 +124,7 @@ BOOST_AUTO_TEST_CASE(quaternion) {
 }
 
 BOOST_AUTO_TEST_CASE(transform) {
-  Quaternion3f q = fromAxisAngle(Vec3f(0, 0, 1), M_PI / 2);
+  Quatf q = fromAxisAngle(Vec3f(0, 0, 1), M_PI / 2);
   Vec3f T(0, 1, 2);
   Transform3f tf(q, T);
 

diff --git a/test/obb.cpp b/test/obb.cpp
@@ -70,7 +70,7 @@ void randomTransform(Matrix3f& B, Vec3f& T, const Vec3f& a, const Vec3f& b,
   T = (Vec3f::Random() / sqrt(3)) * 1.5 * N;
   // T.setZero();
 
-  Quaternion3f q;
+  Quatf q;
   q.coeffs().setRandom();
   q.normalize();
   B = q;
@@ -1204,7 +1204,7 @@ BenchmarkResult benchmark_obb_case(const Matrix3f& B, const Vec3f& T,
     result.failure = false;
   }
   if (result.failure) {
-    std::cerr << "\nR = " << Quaternion3f(B).coeffs().transpose().format(py_fmt)
+    std::cerr << "\nR = " << Quatf(B).coeffs().transpose().format(py_fmt)
               << "\nT = " << T.transpose().format(py_fmt)
               << "\na = " << a.transpose().format(py_fmt)
               << "\nb = " << b.transpose().format(py_fmt)

diff --git a/test/utility.cpp b/test/utility.cpp
@@ -365,8 +365,8 @@ std::string getNodeTypeName(NODE_TYPE node_type) {
     return std::string("invalid");
 }
 
-Quaternion3f makeQuat(FCL_REAL w, FCL_REAL x, FCL_REAL y, FCL_REAL z) {
-  Quaternion3f q;
+Quatf makeQuat(FCL_REAL w, FCL_REAL x, FCL_REAL y, FCL_REAL z) {
+  Quatf q;
   q.w() = w;
   q.x() = x;
   q.y() = y;

diff --git a/test/utility.h b/test/utility.h
@@ -179,7 +179,7 @@ bool defaultDistanceFunction(CollisionObject* o1, CollisionObject* o2,
 
 std::string getNodeTypeName(NODE_TYPE node_type);
 
-Quaternion3f makeQuat(FCL_REAL w, FCL_REAL x, FCL_REAL y, FCL_REAL z);
+Quatf makeQuat(FCL_REAL w, FCL_REAL x, FCL_REAL y, FCL_REAL z);
 
 std::ostream& operator<<(std::ostream& os, const Transform3f& tf);