[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

include/hpp/fcl/collision_data.h

@@ -989,12 +989,12 @@ struct HPP_FCL_DLLAPI DistanceRequest : QueryRequest {
   /// Nearest points are always computed and are the points of the shapes that
   /// achieve a distance of `DistanceResult::min_distance`.
   HPP_FCL_DEPRECATED_MESSAGE(
-      Nearest points are always computed
-      : they are the points of the shapes that achieve a distance of
+      Nearest points are always computed : they are the points of the shapes
+          that achieve a distance of
       `DistanceResult::min_distance`
-            .\n Use `enable_signed_distance` if you want to compute a signed
-                minimum distance(and thus its corresponding nearest points)
-            .)
+              .\n Use `enable_signed_distance` if you want to compute a signed
+                  minimum distance(and thus its corresponding nearest points)
+              .)
   bool enable_nearest_points;
 
   /// @brief whether to compute the penetration depth when objects are in

python/collision-geometries.cc

@@ -575,7 +575,7 @@ void exposeCollisionGeometries() {
            "Check whether two AABB are overlaping and return the overloaping "
            "part if true.")
 
-      .def("distance", (FCL_REAL(AABB::*)(const AABB&) const) & AABB::distance,
+      .def("distance", (FCL_REAL(AABB::*)(const AABB&) const)&AABB::distance,
            bp::args("self", "other"), "Distance between two AABBs.")
       //    .def("distance",
       //         AABB_distance_proxy,
@@ -640,10 +640,10 @@ void exposeCollisionGeometries() {
 #endif
       ;
 
-  def("translate", (AABB(*)(const AABB&, const Vec3f&)) & translate,
+  def("translate", (AABB(*)(const AABB&, const Vec3f&))&translate,
       bp::args("aabb", "t"), "Translate the center of AABB by t");
 
-  def("rotate", (AABB(*)(const AABB&, const Matrix3f&)) & rotate,
+  def("rotate", (AABB(*)(const AABB&, const Matrix3f&))&rotate,
       bp::args("aabb", "R"), "Rotate the AABB object by R");
 
   if (!eigenpy::register_symbolic_link_to_registered_type<

src/BV/OBB.cpp

@@ -311,30 +311,29 @@ inline FCL_REAL obbDisjoint_check_B_axis(const Matrix3f& B, const Vec3f& T,
 }
 
 template <int ib, int jb = (ib + 1) % 3, int kb = (ib + 2) % 3>
-struct HPP_FCL_LOCAL obbDisjoint_check_Ai_cross_Bi {
-  static inline bool run(int ia, int ja, int ka, const Matrix3f& B,
-                         const Vec3f& T, const Vec3f& a, const Vec3f& b,
-                         const Matrix3f& Bf, const FCL_REAL& breakDistance2,
-                         FCL_REAL& squaredLowerBoundDistance) {
-    FCL_REAL sinus2 = 1 - Bf(ia, ib) * Bf(ia, ib);
-    if (sinus2 < 1e-6) return false;
-
-    const FCL_REAL s = T[ka] * B(ja, ib) - T[ja] * B(ka, ib);
-
-    const FCL_REAL diff = fabs(s) - (a[ja] * Bf(ka, ib) + a[ka] * Bf(ja, ib) +
-                                     b[jb] * Bf(ia, kb) + b[kb] * Bf(ia, jb));
-    // We need to divide by the norm || Aia x Bib ||
-    // As ||Aia|| = ||Bib|| = 1, (Aia | Bib)^2  = cosine^2
-    if (diff > 0) {
-      squaredLowerBoundDistance = diff * diff / sinus2;
-      if (squaredLowerBoundDistance > breakDistance2) {
-        return true;
-      }
-    }
-    return false;
+struct HPP_FCL_LOCAL obbDisjoint_check_Ai_cross_Bi{static inline bool run(
+    int ia, int ja, int ka, const Matrix3f& B, const Vec3f& T, const Vec3f& a,
+    const Vec3f& b, const Matrix3f& Bf, const FCL_REAL& breakDistance2,
+    FCL_REAL& squaredLowerBoundDistance){FCL_REAL sinus2 =
+                                             1 - Bf(ia, ib) * Bf(ia, ib);
+if (sinus2 < 1e-6) return false;
+
+const FCL_REAL s = T[ka] * B(ja, ib) - T[ja] * B(ka, ib);
+
+const FCL_REAL diff = fabs(s) - (a[ja] * Bf(ka, ib) + a[ka] * Bf(ja, ib) +
+                                 b[jb] * Bf(ia, kb) + b[kb] * Bf(ia, jb));
+// We need to divide by the norm || Aia x Bib ||
+// As ||Aia|| = ||Bib|| = 1, (Aia | Bib)^2  = cosine^2
+if (diff > 0) {
+  squaredLowerBoundDistance = diff * diff / sinus2;
+  if (squaredLowerBoundDistance > breakDistance2) {
+    return true;
   }
-};
+}
+return false;
 }  // namespace internal
+};  // namespace fcl
+}  // namespace hpp
 
 // B, T orientation and position of 2nd OBB in frame of 1st OBB,
 // a extent of 1st OBB,

src/collision_func_matrix.cpp

@@ -99,66 +99,61 @@ BVH_SHAPE_DEFAULT_TO_ORIENTED(OBBRSS);
 ///         - 0 if the query should be made with non-aligned object frames.
 template <typename T_BVH, typename T_SH,
           int _Options = details::bvh_shape_traits<T_BVH, T_SH>::Options>
-struct HPP_FCL_LOCAL BVHShapeCollider {
-  static std::size_t collide(const CollisionGeometry* o1,
-                             const Transform3f& tf1,
-                             const CollisionGeometry* o2,
-                             const Transform3f& tf2, const GJKSolver* nsolver,
-                             const CollisionRequest& request,
-                             CollisionResult& result) {
+struct HPP_FCL_LOCAL BVHShapeCollider{static std::size_t collide(
+    const CollisionGeometry* o1, const Transform3f& tf1,
+    const CollisionGeometry* o2, const Transform3f& tf2,
+    const GJKSolver* nsolver, const CollisionRequest& request,
+    CollisionResult& result){
     if (request.isSatisfied(result)) return result.numContacts();
 
-    if (request.security_margin < 0)
-      HPP_FCL_THROW_PRETTY(
-          "Negative security margin are not handled yet for BVHModel",
-          std::invalid_argument);
+if (request.security_margin < 0)
+  HPP_FCL_THROW_PRETTY(
+      "Negative security margin are not handled yet for BVHModel",
+      std::invalid_argument);
 
-    if (_Options & RelativeTransformationIsIdentity)
-      return aligned(o1, tf1, o2, tf2, nsolver, request, result);
-    else
-      return oriented(o1, tf1, o2, tf2, nsolver, request, result);
-  }
+if (_Options & RelativeTransformationIsIdentity)
+  return aligned(o1, tf1, o2, tf2, nsolver, request, result);
+else
+  return oriented(o1, tf1, o2, tf2, nsolver, request, result);
+}  // namespace fcl
 
-  static std::size_t aligned(const CollisionGeometry* o1,
-                             const Transform3f& tf1,
-                             const CollisionGeometry* o2,
-                             const Transform3f& tf2, const GJKSolver* nsolver,
-                             const CollisionRequest& request,
-                             CollisionResult& result) {
-    if (request.isSatisfied(result)) return result.numContacts();
+static std::size_t aligned(const CollisionGeometry* o1, const Transform3f& tf1,
+                           const CollisionGeometry* o2, const Transform3f& tf2,
+                           const GJKSolver* nsolver,
+                           const CollisionRequest& request,
+                           CollisionResult& result) {
+  if (request.isSatisfied(result)) return result.numContacts();
 
-    MeshShapeCollisionTraversalNode<T_BVH, T_SH,
-                                    RelativeTransformationIsIdentity>
-        node(request);
-    const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
-    BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
-    Transform3f tf1_tmp = tf1;
-    const T_SH* obj2 = static_cast<const T_SH*>(o2);
+  MeshShapeCollisionTraversalNode<T_BVH, T_SH, RelativeTransformationIsIdentity>
+      node(request);
+  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
+  BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
+  Transform3f tf1_tmp = tf1;
+  const T_SH* obj2 = static_cast<const T_SH*>(o2);
 
-    initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, result);
-    fcl::collide(&node, request, result);
+  initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, result);
+  fcl::collide(&node, request, result);
 
-    delete obj1_tmp;
-    return result.numContacts();
-  }
+  delete obj1_tmp;
+  return result.numContacts();
+}
 
-  static std::size_t oriented(const CollisionGeometry* o1,
-                              const Transform3f& tf1,
-                              const CollisionGeometry* o2,
-                              const Transform3f& tf2, const GJKSolver* nsolver,
-                              const CollisionRequest& request,
-                              CollisionResult& result) {
-    if (request.isSatisfied(result)) return result.numContacts();
+static std::size_t oriented(const CollisionGeometry* o1, const Transform3f& tf1,
+                            const CollisionGeometry* o2, const Transform3f& tf2,
+                            const GJKSolver* nsolver,
+                            const CollisionRequest& request,
+                            CollisionResult& result) {
+  if (request.isSatisfied(result)) return result.numContacts();
 
-    MeshShapeCollisionTraversalNode<T_BVH, T_SH, 0> node(request);
-    const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
-    const T_SH* obj2 = static_cast<const T_SH*>(o2);
+  MeshShapeCollisionTraversalNode<T_BVH, T_SH, 0> node(request);
+  const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
+  const T_SH* obj2 = static_cast<const T_SH*>(o2);
 
-    initialize(node, *obj1, tf1, *obj2, tf2, nsolver, result);
-    fcl::collide(&node, request, result);
-    return result.numContacts();
-  }
-};
+  initialize(node, *obj1, tf1, *obj2, tf2, nsolver, result);
+  fcl::collide(&node, request, result);
+  return result.numContacts();
+}
+};  // namespace hpp
 
 /// @brief Collider functor for HeightField data structure
 /// \tparam _Options takes two values.

src/distance_func_matrix.cpp

@@ -84,26 +84,25 @@ HPP_FCL_LOCAL FCL_REAL distance_function_not_implemented(
 }
 
 template <typename T_BVH, typename T_SH>
-struct HPP_FCL_LOCAL BVHShapeDistancer {
-  static FCL_REAL distance(const CollisionGeometry* o1, const Transform3f& tf1,
-                           const CollisionGeometry* o2, const Transform3f& tf2,
-                           const GJKSolver* nsolver,
-                           const DistanceRequest& request,
-                           DistanceResult& result) {
+struct HPP_FCL_LOCAL BVHShapeDistancer{static FCL_REAL distance(
+    const CollisionGeometry* o1, const Transform3f& tf1,
+    const CollisionGeometry* o2, const Transform3f& tf2,
+    const GJKSolver* nsolver, const DistanceRequest& request,
+    DistanceResult& result){
     if (request.isSatisfied(result)) return result.min_distance;
-    MeshShapeDistanceTraversalNode<T_BVH, T_SH> node;
-    const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
-    BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
-    Transform3f tf1_tmp = tf1;
-    const T_SH* obj2 = static_cast<const T_SH*>(o2);
+MeshShapeDistanceTraversalNode<T_BVH, T_SH> node;
+const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
+BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
+Transform3f tf1_tmp = tf1;
+const T_SH* obj2 = static_cast<const T_SH*>(o2);
 
-    initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, request, result);
-    fcl::distance(&node);
+initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, request, result);
+fcl::distance(&node);
 
-    delete obj1_tmp;
-    return result.min_distance;
-  }
-};
+delete obj1_tmp;
+return result.min_distance;
+}  // namespace fcl
+};  // namespace hpp
 
 namespace details {
 
@@ -169,34 +168,33 @@ struct HPP_FCL_LOCAL BVHShapeDistancer<OBBRSS, T_SH> {
 };
 
 template <typename T_HF, typename T_SH>
-struct HPP_FCL_LOCAL HeightFieldShapeDistancer {
-  static FCL_REAL distance(const CollisionGeometry* o1, const Transform3f& tf1,
-                           const CollisionGeometry* o2, const Transform3f& tf2,
-                           const GJKSolver* nsolver,
-                           const DistanceRequest& request,
-                           DistanceResult& result) {
-    HPP_FCL_UNUSED_VARIABLE(o1);
-    HPP_FCL_UNUSED_VARIABLE(tf1);
-    HPP_FCL_UNUSED_VARIABLE(o2);
-    HPP_FCL_UNUSED_VARIABLE(tf2);
-    HPP_FCL_UNUSED_VARIABLE(nsolver);
-    HPP_FCL_UNUSED_VARIABLE(request);
-    // TODO(jcarpent)
-    HPP_FCL_THROW_PRETTY(
-        "Distance between a height field and a shape is not implemented",
-        std::invalid_argument);
-    //    if(request.isSatisfied(result)) return result.min_distance;
-    //    HeightFieldShapeDistanceTraversalNode<T_HF, T_SH> node;
-    //
-    //    const HeightField<T_HF>* obj1 = static_cast<const HeightField<T_HF>*
-    //    >(o1); const T_SH* obj2 = static_cast<const T_SH*>(o2);
-    //
-    //    initialize(node, *obj1, tf1, *obj2, tf2, nsolver, request, result);
-    //    fcl::distance(&node);
-
-    return result.min_distance;
-  }
-};
+struct HPP_FCL_LOCAL HeightFieldShapeDistancer{static FCL_REAL distance(
+    const CollisionGeometry* o1, const Transform3f& tf1,
+    const CollisionGeometry* o2, const Transform3f& tf2,
+    const GJKSolver* nsolver, const DistanceRequest& request,
+    DistanceResult& result){HPP_FCL_UNUSED_VARIABLE(o1);
+HPP_FCL_UNUSED_VARIABLE(tf1);
+HPP_FCL_UNUSED_VARIABLE(o2);
+HPP_FCL_UNUSED_VARIABLE(tf2);
+HPP_FCL_UNUSED_VARIABLE(nsolver);
+HPP_FCL_UNUSED_VARIABLE(request);
+// TODO(jcarpent)
+HPP_FCL_THROW_PRETTY(
+    "Distance between a height field and a shape is not implemented",
+    std::invalid_argument);
+//    if(request.isSatisfied(result)) return result.min_distance;
+//    HeightFieldShapeDistanceTraversalNode<T_HF, T_SH> node;
+//
+//    const HeightField<T_HF>* obj1 = static_cast<const HeightField<T_HF>*
+//    >(o1); const T_SH* obj2 = static_cast<const T_SH*>(o2);
+//
+//    initialize(node, *obj1, tf1, *obj2, tf2, nsolver, request, result);
+//    fcl::distance(&node);
+
+return result.min_distance;
+}
+}
+;
 
 template <typename T_BVH>
 FCL_REAL BVHDistance(const CollisionGeometry* o1, const Transform3f& tf1,

src/traits_traversal.h

@@ -19,7 +19,7 @@ namespace fcl {
 // TraversalTraitsCollision for collision_func_matrix.cpp
 
 template <typename TypeA, typename TypeB>
-struct HPP_FCL_LOCAL TraversalTraitsCollision {};
+struct HPP_FCL_LOCAL TraversalTraitsCollision{};
 
 #ifdef HPP_FCL_HAS_OCTOMAP
 
@@ -63,7 +63,7 @@ struct HPP_FCL_LOCAL TraversalTraitsCollision<HeightField<T_HF>, OcTree> {
 // TraversalTraitsDistance for distance_func_matrix.cpp
 
 template <typename TypeA, typename TypeB>
-struct HPP_FCL_LOCAL TraversalTraitsDistance {};
+struct HPP_FCL_LOCAL TraversalTraitsDistance{};
 
 #ifdef HPP_FCL_HAS_OCTOMAP
 

src/traversal/traversal_recurse.cpp

@@ -212,11 +212,10 @@ struct HPP_FCL_LOCAL BVT {
 };
 
 /** @brief Comparer between two BVT */
-struct HPP_FCL_LOCAL BVT_Comparer {
-  bool operator()(const BVT& lhs, const BVT& rhs) const {
-    return lhs.d > rhs.d;
-  }
-};
+struct HPP_FCL_LOCAL BVT_Comparer{
+    bool operator()(const BVT& lhs, const BVT& rhs) const {return lhs.d > rhs.d;
+}  // namespace fcl
+};  // namespace hpp
 
 struct HPP_FCL_LOCAL BVTQ {
   BVTQ() : qsize(2) {}