Remove ContinuousCollisionCandidate inheritance

docs/source/cpp-api/candidates.rst

@@ -14,13 +14,6 @@ Collision Stencil
     :allow-dot-graphs:
 
 
-Continuous Collision Candidate
-------------------------------
-
-.. doxygenclass:: ipc::ContinuousCollisionCandidate
-    :allow-dot-graphs:
-
-
 Vertex-Vertex Candidate
 -----------------------
 

docs/source/python-api/candidates.rst

@@ -16,13 +16,6 @@ Collision Stencil
 
 .. .. autoclass:: ipctk.CollisionStencil
 
-Continuous Collision Candidate
-------------------------------
-
-.. autoclass:: ipctk.ContinuousCollisionCandidate
-
-    .. autoclasstoc::
-
 Vertex-Vertex Candidate
 -----------------------
 

python/src/bindings.cpp

@@ -37,7 +37,6 @@ PYBIND11_MODULE(ipctk, m)
     // candidates
     define_candidates(m);
     define_collision_stencil(m);
-    define_continuous_collision_candidate(m);
     define_edge_edge_candidate(m);
     define_edge_face_candidate(m);
     define_edge_vertex_candidate(m);

python/src/candidates/CMakeLists.txt

@@ -1,6 +1,5 @@
 set(SOURCES
   collision_stencil.cpp
-  continuous_collision_candidate.cpp
   edge_edge.cpp
   edge_face.cpp
   edge_vertex.cpp

python/src/candidates/bindings.hpp

@@ -5,7 +5,6 @@
 // candidates
 void define_candidates(py::module_& m);
 void define_collision_stencil(py::module_& m);
-void define_continuous_collision_candidate(py::module_& m);
 void define_edge_edge_candidate(py::module_& m);
 void define_edge_face_candidate(py::module_& m);
 void define_edge_vertex_candidate(py::module_& m);

python/src/candidates/candidates.cpp

@@ -53,7 +53,7 @@ void define_candidates(py::module_& m)
         .def("clear", &Candidates::clear)
         .def(
             "__getitem__",
-            [](Candidates& self, size_t i) -> ContinuousCollisionCandidate& {
+            [](Candidates& self, size_t i) -> CollisionStencil& {
                 return self[i];
             },
             py::return_value_policy::reference)

python/src/candidates/collision_stencil.cpp

@@ -172,5 +172,48 @@ void define_collision_stencil(py::module_& m)
             Returns:
                 Distance Hessian of the stencil w.r.t. the stencil's vertex positions.
             )ipc_Qu8mg5v7",
-            py::arg("positions"));
+            py::arg("positions"))
+        .def(
+            "ccd",
+            [](const CollisionStencil& self, const VectorMax12d& vertices_t0,
+               const VectorMax12d& vertices_t1, const double min_distance,
+               const double tmax, const NarrowPhaseCCD& narrow_phase_ccd) {
+                double toi;
+                bool r = self.ccd(
+                    vertices_t0, vertices_t1, toi, min_distance, tmax,
+                    narrow_phase_ccd);
+                return std::make_tuple(r, toi);
+            },
+            R"ipc_Qu8mg5v7(
+                Perform narrow-phase CCD on the candidate.
+
+                Parameters:
+                    vertices_t0: Stencil vertices at the start of the time step.
+                    vertices_t1: Stencil vertices at the end of the time step.
+                    min_distance: Minimum separation distance between primitives.
+                    tmax: Maximum time (normalized) to look for collisions. Should be in [0, 1].
+                    narrow_phase_ccd: The narrow phase CCD algorithm to use.
+
+                Returns:
+                    Tuple of:
+                    If the candidate had a collision over the time interval.
+                    Computed time of impact (normalized).
+                )ipc_Qu8mg5v7",
+            py::arg("vertices_t0"), py::arg("vertices_t1"),
+            py::arg("min_distance") = 0.0, py::arg("tmax") = 1.0,
+            py::arg("narrow_phase_ccd") = DEFAULT_NARROW_PHASE_CCD)
+        .def(
+            "print_ccd_query",
+            [](const CollisionStencil& self, const VectorMax12d& vertices_t0,
+               const VectorMax12d& vertices_t1) -> void {
+                self.write_ccd_query(std::cout, vertices_t0, vertices_t1);
+            },
+            R"ipc_Qu8mg5v7(
+                Print the CCD query to cout.
+
+                Parameters:
+                                    vertices_t0: Stencil vertices at the start of the time step.
+                    vertices_t1: Stencil vertices at the end of the time step.
+                )ipc_Qu8mg5v7",
+            py::arg("vertices_t0"), py::arg("vertices_t1"));
 }

python/src/candidates/edge_edge.cpp

@@ -7,9 +7,7 @@ using namespace ipc;
 
 void define_edge_edge_candidate(py::module_& m)
 {
-    py::class_<
-        EdgeEdgeCandidate, CollisionStencil, ContinuousCollisionCandidate>(
-        m, "EdgeEdgeCandidate")
+    py::class_<EdgeEdgeCandidate, CollisionStencil>(m, "EdgeEdgeCandidate")
         .def(py::init<long, long>(), py::arg("edge0_id"), py::arg("edge1_id"))
         .def(
             py::init([](std::tuple<long, long> edge_ids) {

python/src/candidates/edge_vertex.cpp

@@ -7,9 +7,7 @@ using namespace ipc;
 
 void define_edge_vertex_candidate(py::module_& m)
 {
-    py::class_<
-        EdgeVertexCandidate, CollisionStencil, ContinuousCollisionCandidate>(
-        m, "EdgeVertexCandidate")
+    py::class_<EdgeVertexCandidate, CollisionStencil>(m, "EdgeVertexCandidate")
         .def(py::init<long, long>(), py::arg("edge_id"), py::arg("vertex_id"))
         .def(
             py::init([](std::tuple<long, long> edge_and_vertex_id) {

python/src/candidates/face_vertex.cpp

@@ -7,9 +7,7 @@ using namespace ipc;
 
 void define_face_vertex_candidate(py::module_& m)
 {
-    py::class_<
-        FaceVertexCandidate, CollisionStencil, ContinuousCollisionCandidate>(
-        m, "FaceVertexCandidate")
+    py::class_<FaceVertexCandidate, CollisionStencil>(m, "FaceVertexCandidate")
         .def(py::init<long, long>(), py::arg("face_id"), py::arg("vertex_id"))
         .def(
             py::init([](std::tuple<long, long> face_and_vertex_id) {

python/src/candidates/vertex_vertex.cpp

@@ -7,8 +7,7 @@ using namespace ipc;
 
 void define_vertex_vertex_candidate(py::module_& m)
 {
-    py::class_<
-        VertexVertexCandidate, CollisionStencil, ContinuousCollisionCandidate>(
+    py::class_<VertexVertexCandidate, CollisionStencil>(
         m, "VertexVertexCandidate")
         .def(
             py::init<long, long>(), py::arg("vertex0_id"),

src/ipc/candidates/CMakeLists.txt

@@ -1,9 +1,8 @@
 set(SOURCES
   candidates.cpp
   candidates.hpp
+  collision_stencil.cpp
   collision_stencil.hpp
-  continuous_collision_candidate.cpp
-  continuous_collision_candidate.hpp
   edge_edge.cpp
   edge_edge.hpp
   edge_face.cpp

src/ipc/candidates/candidates.cpp

@@ -195,7 +195,7 @@ bool Candidates::is_step_collision_free(
 
     // Narrow phase
     for (size_t i = 0; i < size(); i++) {
-        const ContinuousCollisionCandidate& candidate = (*this)[i];
+        const CollisionStencil& candidate = (*this)[i];
 
         double toi;
         bool is_collision = candidate.ccd(
@@ -240,7 +240,7 @@ double Candidates::compute_collision_free_stepsize(
                     tmax = earliest_toi;
                 }
 
-                const ContinuousCollisionCandidate& candidate = (*this)[i];
+                const CollisionStencil& candidate = (*this)[i];
 
                 double toi = std::numeric_limits<double>::infinity(); // output
                 const bool are_colliding = candidate.ccd(
@@ -344,7 +344,7 @@ void Candidates::clear()
     fv_candidates.clear();
 }
 
-ContinuousCollisionCandidate& Candidates::operator[](size_t i)
+CollisionStencil& Candidates::operator[](size_t i)
 {
     if (i < vv_candidates.size()) {
         return vv_candidates[i];
@@ -364,7 +364,7 @@ ContinuousCollisionCandidate& Candidates::operator[](size_t i)
     throw std::out_of_range("Candidate index is out of range!");
 }
 
-const ContinuousCollisionCandidate& Candidates::operator[](size_t i) const
+const CollisionStencil& Candidates::operator[](size_t i) const
 {
     if (i < vv_candidates.size()) {
         return vv_candidates[i];

src/ipc/candidates/candidates.hpp

@@ -49,8 +49,8 @@ class Candidates {
 
     void clear();
 
-    ContinuousCollisionCandidate& operator[](size_t i);
-    const ContinuousCollisionCandidate& operator[](size_t i) const;
+    CollisionStencil& operator[](size_t i);
+    const CollisionStencil& operator[](size_t i) const;
 
     /// @brief Determine if the step is collision free from the set of candidates.
     /// @note Assumes the trajectory is linear.

src/ipc/candidates/continuous_collision_candidate.cpp → src/ipc/candidates/collision_stencil.cpp

@@ -1,8 +1,8 @@
-#include "continuous_collision_candidate.hpp"
+#include "collision_stencil.hpp"
 
 namespace ipc {
 
-std::ostream& ContinuousCollisionCandidate::write_ccd_query(
+std::ostream& CollisionStencil::write_ccd_query(
     std::ostream& out,
     const VectorMax12d& vertices_t0,
     const VectorMax12d& vertices_t1) const

src/ipc/candidates/collision_stencil.hpp

@@ -1,9 +1,11 @@
 #pragma once
 
+#include <ipc/ccd/default_narrow_phase_ccd.hpp>
 #include <ipc/utils/eigen_ext.hpp>
 
 #include <array>
 #include <limits>
+#include <ostream>
 
 namespace ipc {
 
@@ -161,6 +163,33 @@ class CollisionStencil {
     /// @return Coefficients of the stencil.
     virtual VectorMax4d
     compute_coefficients(const VectorMax12d& positions) const = 0;
+
+    /// @brief Perform narrow-phase CCD on the candidate.
+    /// @param[in] vertices_t0 Stencil vertices at the start of the time step.
+    /// @param[in] vertices_t1 Stencil vertices at the end of the time step.
+    /// @param[out] toi Computed time of impact (normalized).
+    /// @param[in] min_distance Minimum separation distance between primitives.
+    /// @param[in] tmax Maximum time (normalized) to look for collisions.
+    /// @param[in] narrow_phase_ccd The narrow phase CCD algorithm to use.
+    /// @return If the candidate had a collision over the time interval.
+    virtual bool
+    ccd(const VectorMax12d& vertices_t0,
+        const VectorMax12d& vertices_t1,
+        double& toi,
+        const double min_distance = 0.0,
+        const double tmax = 1.0,
+        const NarrowPhaseCCD& narrow_phase_ccd =
+            DEFAULT_NARROW_PHASE_CCD) const = 0;
+
+    /// @brief Write the CCD query to a stream.
+    /// @param out Stream to write to.
+    /// @param vertices_t0 Stencil vertices at the start of the time step.
+    /// @param vertices_t1 Stencil vertices at the end of the time step.
+    /// @return The stream.
+    std::ostream& write_ccd_query(
+        std::ostream& out,
+        const VectorMax12d& vertices_t0,
+        const VectorMax12d& vertices_t1) const;
 };
 
 } // namespace ipc

src/ipc/candidates/edge_edge.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ipc/candidates/continuous_collision_candidate.hpp>
+#include <ipc/candidates/collision_stencil.hpp>
 #include <ipc/distance/distance_type.hpp>
 
 #include <Eigen/Core>
@@ -9,7 +9,7 @@
 
 namespace ipc {
 
-class EdgeEdgeCandidate : public ContinuousCollisionCandidate {
+class EdgeEdgeCandidate : virtual public CollisionStencil {
 public:
     EdgeEdgeCandidate(long edge0_id, long edge1_id);
 
@@ -43,7 +43,6 @@ class EdgeEdgeCandidate : public ContinuousCollisionCandidate {
     compute_coefficients(const VectorMax12d& positions) const override;
 
     // ------------------------------------------------------------------------
-    // ContinuousCollisionCandidate
 
     bool
     ccd(const VectorMax12d& vertices_t0,