dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/collision/fcl/FCLCollisionDetector.hpp

@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COLLISION_FCL_FCLCOLLISIONDETECTOR_HPP_
+#define DART_COLLISION_FCL_FCLCOLLISIONDETECTOR_HPP_
+
+#include <dart/collision/CollisionDetector.hpp>
+#include <dart/collision/fcl/FCLTypes.hpp>
+
+#include <vector>
+
+namespace dart {
+namespace collision {
+
+class FCLCollisionObject;
+
+class FCLCollisionDetector : public CollisionDetector
+{
+public:
+  using CollisionDetector::createCollisionGroup;
+
+  static std::shared_ptr<FCLCollisionDetector> create();
+
+  /// Whether to use analytic collision checking for primitive shapes.
+  ///
+  /// PRIMITIVE: Use FCL's analytic collision checking for primitive shapes.
+  /// MESH: Don't use it. Instead, use approximate mesh shapes for the primitive
+  /// shapes. The contact result is probably less accurate than the analytic
+  /// result.
+  ///
+  /// Warning: FCL's primitive shape support is not complete. FCL 0.4.0 improved
+  /// the support alot, but it still returns single contact point for a shape
+  /// pair except for box-box collision. For this reason, we recommend using
+  /// MESH until FCL fully supports primitive shapes.
+  enum PrimitiveShape
+  {
+    PRIMITIVE = 0,
+    MESH
+  };
+
+  /// Whether to use FCL's contact point computation.
+  ///
+  /// FCL: Use FCL's contact point computation.
+  /// DART: Use DART's own contact point computation
+  ///
+  /// Warning: FCL's contact computation is not correct. See:
+  /// https://github.com/flexible-collision-library/fcl/issues/106
+  /// We recommend using DART until it's fixed in FCL.
+  enum ContactPointComputationMethod
+  {
+    FCL = 0,
+    DART
+  };
+
+  /// Constructor
+  virtual ~FCLCollisionDetector();
+
+  // Documentation inherited
+  std::shared_ptr<CollisionDetector> cloneWithoutCollisionObjects()
+      const override;
+
+  // Documentation inherited
+  const std::string& getType() const override;
+
+  /// Get collision detector type for this class
+  static const std::string& getStaticType();
+
+  // Documentation inherited
+  std::unique_ptr<CollisionGroup> createCollisionGroup() override;
+
+  // Documentation inherited
+  bool collide(
+      CollisionGroup* group,
+      const CollisionOption& option = CollisionOption(false, 1u, nullptr),
+      CollisionResult* result = nullptr) override;
+
+  // Documentation inherited
+  bool collide(
+      CollisionGroup* group1,
+      CollisionGroup* group2,
+      const CollisionOption& option = CollisionOption(false, 1u, nullptr),
+      CollisionResult* result = nullptr) override;
+
+  // Documentation inherited
+  double distance(
+      CollisionGroup* group,
+      const DistanceOption& option = DistanceOption(false, 0.0, nullptr),
+      DistanceResult* result = nullptr) override;
+
+  // Documentation inherited
+  double distance(
+      CollisionGroup* group1,
+      CollisionGroup* group2,
+      const DistanceOption& option = DistanceOption(false, 0.0, nullptr),
+      DistanceResult* result = nullptr) override;
+
+  /// Set primitive shape type
+  void setPrimitiveShapeType(PrimitiveShape type);
+
+  /// Get primitive shape type
+  PrimitiveShape getPrimitiveShapeType() const;
+
+  /// Set contact point computation method
+  void setContactPointComputationMethod(ContactPointComputationMethod method);
+
+  /// Get contact point computation method
+  ContactPointComputationMethod getContactPointComputationMethod() const;
+
+protected:
+  /// Constructor
+  FCLCollisionDetector();
+
+  // Documentation inherited
+  std::unique_ptr<CollisionObject> createCollisionObject(
+      const dynamics::ShapeFrame* shapeFrame) override;
+
+  void refreshCollisionObject(CollisionObject* object) override;
+
+  /// Return fcl::CollisionGeometry associated with give Shape. New
+  /// fcl::CollisionGeome will be created if it hasn't created yet.
+  std::shared_ptr<dart::collision::fcl::CollisionGeometry>
+  claimFCLCollisionGeometry(const dynamics::ConstShapePtr& shape);
+
+protected:
+  PrimitiveShape mPrimitiveShapeType;
+
+  ContactPointComputationMethod mContactPointComputationMethod;
+
+private:
+  /// This deleter is responsible for deleting fcl::CollisionGeometry and
+  /// removing it from mShapeMap when it is not shared by any CollisionObjects.
+  class FCLCollisionGeometryDeleter final
+  {
+  public:
+    FCLCollisionGeometryDeleter(
+        FCLCollisionDetector* cd, const dynamics::ConstShapePtr& shape);
+
+    void operator()(dart::collision::fcl::CollisionGeometry* geom) const;
+
+  private:
+    FCLCollisionDetector* mFCLCollisionDetector;
+
+    dynamics::ConstShapePtr mShape;
+  };
+
+  /// Information for a shape that was generated by this collision detector
+  struct ShapeInfo final
+  {
+    /// A weak reference to the shape
+    std::weak_ptr<dart::collision::fcl::CollisionGeometry> mShape;
+
+    /// The last version of the shape, as known by this collision detector
+    std::size_t mLastKnownVersion;
+  };
+
+  /// Create fcl::CollisionGeometry with the custom deleter
+  /// FCLCollisionGeometryDeleter
+  std::shared_ptr<dart::collision::fcl::CollisionGeometry>
+  createFCLCollisionGeometry(
+      const dynamics::ConstShapePtr& shape,
+      FCLCollisionDetector::PrimitiveShape type,
+      const FCLCollisionGeometryDeleter& deleter);
+
+private:
+  using ShapeMap = std::map<dynamics::ConstShapePtr, ShapeInfo>;
+
+  ShapeMap mShapeMap;
+
+  static Registrar<FCLCollisionDetector> mRegistrar;
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_FCL_FCLCOLLISIONDETECTOR_HPP_

include/dart/collision/fcl/FCLCollisionGroup.hpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COLLISION_FCL_FCLCOLLISIONGROUP_HPP_
+#define DART_COLLISION_FCL_FCLCOLLISIONGROUP_HPP_
+
+#include <dart/collision/CollisionGroup.hpp>
+#include <dart/collision/fcl/BackwardCompatibility.hpp>
+
+namespace dart {
+namespace collision {
+
+class CollisionObject;
+class FCLCollisionObjectUserData;
+
+class FCLCollisionGroup : public CollisionGroup
+{
+public:
+  friend class FCLCollisionDetector;
+
+  using FCLCollisionManager
+      = dart::collision::fcl::DynamicAABBTreeCollisionManager;
+
+  /// Constructor
+  FCLCollisionGroup(const CollisionDetectorPtr& collisionDetector);
+
+  /// Destructor
+  virtual ~FCLCollisionGroup() = default;
+
+protected:
+  using CollisionGroup::updateEngineData;
+
+  // Documentation inherited
+  void initializeEngineData() override;
+
+  // Documentation inherited
+  void addCollisionObjectToEngine(CollisionObject* object) override;
+
+  // Documentation inherited
+  void addCollisionObjectsToEngine(
+      const std::vector<CollisionObject*>& collObjects) override;
+
+  // Documentation inherited
+  void removeCollisionObjectFromEngine(CollisionObject* object) override;
+
+  // Documentation inherited
+  void removeAllCollisionObjectsFromEngine() override;
+
+  // Documentation inherited
+  void updateCollisionGroupEngineData() override;
+
+  /// Return FCL collision manager that is also a broad-phase algorithm
+  FCLCollisionManager* getFCLCollisionManager();
+
+  /// Return FCL collision manager that is also a broad-phase algorithm
+  const FCLCollisionManager* getFCLCollisionManager() const;
+
+protected:
+  /// FCL broad-phase algorithm
+  std::unique_ptr<FCLCollisionManager> mBroadPhaseAlg;
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_FCL_FCLCOLLISIONGROUP_HPP_

include/dart/collision/fcl/FCLCollisionObject.hpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COLLISION_FCL_FCLCOLLISIONOBJECT_HPP_
+#define DART_COLLISION_FCL_FCLCOLLISIONOBJECT_HPP_
+
+#include <dart/collision/CollisionObject.hpp>
+#include <dart/collision/fcl/BackwardCompatibility.hpp>
+
+namespace dart {
+namespace collision {
+
+class FCLCollisionObject : public CollisionObject
+{
+public:
+  friend class FCLCollisionDetector;
+
+  /// Return FCL collision object
+  dart::collision::fcl::CollisionObject* getFCLCollisionObject();
+
+  /// Return FCL collision object
+  const dart::collision::fcl::CollisionObject* getFCLCollisionObject() const;
+
+protected:
+  /// Constructor
+  FCLCollisionObject(
+      CollisionDetector* collisionDetector,
+      const dynamics::ShapeFrame* shapeFrame,
+      const std::shared_ptr<dart::collision::fcl::CollisionGeometry>&
+          fclCollGeom);
+
+  // Documentation inherited
+  void updateEngineData() override;
+
+protected:
+  /// FCL collision object
+  std::unique_ptr<dart::collision::fcl::CollisionObject> mFCLCollisionObject;
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_FCL_FCLCOLLISIONOBJECT_HPP_

include/dart/collision/fcl/FCLTypes.hpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COLLISION_FCL_FCLTTYPES_HPP_
+#define DART_COLLISION_FCL_FCLTTYPES_HPP_
+
+#include <dart/collision/fcl/BackwardCompatibility.hpp>
+
+#include <Eigen/Dense>
+
+namespace dart {
+namespace collision {
+
+class FCLTypes
+{
+public:
+  /// Convert FCL vector3 type to Eigen vector3 type
+  static Eigen::Vector3d convertVector3(
+      const dart::collision::fcl::Vector3& _vec);
+
+  /// Convert FCL matrix3x3 type to Eigen matrix3x3 type
+  static dart::collision::fcl::Matrix3 convertMatrix3x3(
+      const Eigen::Matrix3d& _R);
+
+  /// Convert FCL transformation type to Eigen transformation type
+  static dart::collision::fcl::Transform3 convertTransform(
+      const Eigen::Isometry3d& _T);
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_FCL_FCLTTYPES_HPP_

include/dart/collision/fcl/TriTriIntersectionTest.hpp

@@ -0,0 +1,17 @@
+// Automatically generated backward compatibility header
+// This file is DEPRECATED and will be removed in a future release
+//
+// DEPRECATED: TriTriIntersectionTest.hpp is deprecated.
+// Please use tri_tri_intersection_test.hpp instead.
+//
+// This header will be removed in DART 8.0.
+
+#ifndef DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+#if defined(_MSC_VER)
+#  pragma message("Warning: TriTriIntersectionTest.hpp is deprecated. Use tri_tri_intersection_test.hpp instead.")
+#elif defined(__GNUC__) || defined(__clang__)
+#  warning "TriTriIntersectionTest.hpp is deprecated. Use tri_tri_intersection_test.hpp instead."
+#endif
+#endif // DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+
+#include "dart/collision/fcl//tri_tri_intersection_test.hpp"

include/dart/collision/fcl/all.hpp

@@ -0,0 +1,9 @@
+// Automatically generated file by cmake
+
+#include "dart/collision/fcl/BackwardCompatibility.hpp"
+#include "dart/collision/fcl/CollisionShapes.hpp"
+#include "dart/collision/fcl/FCLCollisionDetector.hpp"
+#include "dart/collision/fcl/FCLCollisionGroup.hpp"
+#include "dart/collision/fcl/FCLCollisionObject.hpp"
+#include "dart/collision/fcl/FCLTypes.hpp"
+#include "dart/collision/fcl/tri_tri_intersection_test.hpp"

include/dart/collision/fcl/fcl.hpp

@@ -0,0 +1,14 @@
+// Automatically generated file by cmake
+
+// DEPRECATED: This header is deprecated and will be removed in the next major release.
+// Please use <dart/collision/fcl/all.hpp> instead of <dart/collision/fcl/fcl.hpp>
+
+#ifndef DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+#if defined(_MSC_VER)
+#  pragma message("Warning: dart/collision/fcl/fcl.hpp is deprecated. Use dart/collision/fcl/all.hpp instead.")
+#elif defined(__GNUC__) || defined(__clang__)
+#  warning "dart/collision/fcl/fcl.hpp is deprecated. Use dart/collision/fcl/all.hpp instead."
+#endif
+#endif // DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+
+#include "dart/collision/fcl/all.hpp"