Fix normal collision python init

Author: zfergus

python/src/collisions/normal/edge_edge.cpp

@@ -21,24 +21,20 @@ void define_edge_edge_normal_collision(py::module_& m)
                 const EdgeEdgeDistanceType>(),
             py::arg("candidate"), py::arg("eps_x"),
             py::arg("dtype") = EdgeEdgeDistanceType::AUTO)
-        .def(
-            py::init<
-                const long, const long, const double, const double,
-                const Eigen::SparseVector<double>&,
-                const EdgeEdgeDistanceType>(),
-            py::arg("edge0_id"), py::arg("edge1_id"), py::arg("eps_x"),
-            py::arg("weight"), py::arg("weight_gradient"),
-            py::arg("dtype") = EdgeEdgeDistanceType::AUTO)
+        // .def(
+        //     py::init<
+        //         const long, const long, const double, const double,
+        //         const Eigen::SparseVector<double>&,
+        //         const EdgeEdgeDistanceType>(),
+        //     py::arg("edge0_id"), py::arg("edge1_id"), py::arg("eps_x"),
+        //     py::arg("weight"), py::arg("weight_gradient"),
+        //     py::arg("dtype") = EdgeEdgeDistanceType::AUTO)
         .def("__eq__", &EdgeEdgeNormalCollision::operator==, py::arg("other"))
         .def("__ne__", &EdgeEdgeNormalCollision::operator!=, py::arg("other"))
         .def("__lt__", &EdgeEdgeNormalCollision::operator<, py::arg("other"))
         .def_readwrite(
             "eps_x", &EdgeEdgeNormalCollision::eps_x,
-            R"ipc_Qu8mg5v7(
-            Mollifier activation threshold.
-
-            edge_edge_mollifier
-            )ipc_Qu8mg5v7")
+            "Mollifier activation threshold.")
         .def_readwrite(
             "dtype", &EdgeEdgeNormalCollision::dtype,
             R"ipc_Qu8mg5v7(
@@ -47,3 +43,4 @@ void define_edge_edge_normal_collision(py::module_& m)
             Some EE collisions are mollified EV or VV collisions.
             )ipc_Qu8mg5v7");
 }
+}

python/src/collisions/normal/edge_vertex.cpp

@@ -9,11 +9,12 @@ void define_edge_vertex_normal_collision(py::module_& m)
 {
     py::class_<EdgeVertexNormalCollision, EdgeVertexCandidate, NormalCollision>(
         m, "EdgeVertexNormalCollision")
-        .def(py::init<const EdgeVertexCandidate&>(), py::arg("candidate"))
-        .def(
-            py::init<
-                const long, const long, const double,
-                const Eigen::SparseVector<double>&>(),
-            py::arg("edge_id"), py::arg("vertex_id"), py::arg("weight"),
-            py::arg("weight_gradient"));
+        .def(py::init<long, long>(), py::arg("edge_id"), py::arg("vertex_id"))
+        .def(py::init<const EdgeVertexCandidate&>(), py::arg("candidate"));
+    // .def(
+    //     py::init<
+    //         const long, const long, const double,
+    //         const Eigen::SparseVector<double>&>(),
+    //     py::arg("edge_id"), py::arg("vertex_id"), py::arg("weight"),
+    //     py::arg("weight_gradient"));
 }

python/src/collisions/normal/face_vertex.cpp

@@ -9,11 +9,14 @@ void define_face_vertex_normal_collision(py::module_& m)
 {
     py::class_<FaceVertexNormalCollision, FaceVertexCandidate, NormalCollision>(
         m, "FaceVertexNormalCollision")
-        .def(py::init<const FaceVertexCandidate&>(), py::arg("candidate"))
         .def(
-            py::init<
-                const long, const long, const double,
-                const Eigen::SparseVector<double>&>(),
-            py::arg("face_id"), py::arg("vertex_id"), py::arg("weight"),
-            py::arg("weight_gradient"));
+            py::init<long, long>(), "", py::arg("face_id"),
+            py::arg("vertex_id"))
+        .def(py::init<const FaceVertexCandidate&>(), py::arg("candidate"));
+    // .def(
+    //     py::init<
+    //         const long, const long, const double,
+    //         const Eigen::SparseVector<double>&>(),
+    //     py::arg("face_id"), py::arg("vertex_id"), py::arg("weight"),
+    //     py::arg("weight_gradient"));
 }

python/src/collisions/normal/vertex_vertex.cpp

@@ -10,8 +10,14 @@ void define_vertex_vertex_normal_collision(py::module_& m)
     py::class_<
         VertexVertexNormalCollision, VertexVertexCandidate, NormalCollision>(
         m, "VertexVertexNormalCollision")
-        .def(py::init<const VertexVertexCandidate&>(), py::arg("vv_candidate"))
         .def(
             py::init<long, long>(), "", py::arg("vertex0_id"),
-            py::arg("vertex1_id"));
+            py::arg("vertex1_id"))
+        .def(py::init<const VertexVertexCandidate&>(), py::arg("vv_candidate"));
+    // .def(
+    //     py::init<
+    //         const long, const long, const double,
+    //         const Eigen::SparseVector<double>&>(),
+    //     py::arg("vertex0_id"), py::arg("vertex1_id"), py::arg("weight"),
+    //     py::arg("weight_gradient"));
 }

src/ipc/collisions/normal/normal_collisions.cpp

@@ -168,8 +168,8 @@ void NormalCollisions::build(
     // Cull the candidates by measuring the distance and dropping those that are
     // greater than dhat.
     const double offset_sqr = (dmin + dhat) * (dmin + dhat);
-    auto is_active = [&](double distance_squared) {
-        return distance_squared < offset_sqr;
+    auto is_active = [&](double distance_sqr) {
+        return distance_sqr < offset_sqr;
     };
 
     tbb::enumerable_thread_specific<NormalCollisionsBuilder> storage(

src/ipc/collisions/normal/normal_collisions_builder.cpp

@@ -71,9 +71,9 @@ void NormalCollisionsBuilder::add_edge_vertex_collisions(
         const auto [v, e0, e1, _] =
             candidates[i].vertices(vertices, mesh.edges(), mesh.faces());
         const PointEdgeDistanceType dtype = point_edge_distance_type(v, e0, e1);
-        const double distance_squared = point_edge_distance(v, e0, e1, dtype);
+        const double distance_sqr = point_edge_distance(v, e0, e1, dtype);
 
-        if (!is_active(distance_squared))
+        if (!is_active(distance_sqr))
             continue;
 
         // ÷ 2 to handle double counting for correct integration
@@ -143,10 +143,10 @@ void NormalCollisionsBuilder::add_edge_edge_collisions(
         const EdgeEdgeDistanceType actual_dtype =
             edge_edge_distance_type(ea0, ea1, eb0, eb1);
 
-        const double distance_squared =
+        const double distance_sqr =
             edge_edge_distance(ea0, ea1, eb0, eb1, actual_dtype);
 
-        if (!is_active(distance_squared))
+        if (!is_active(distance_sqr))
             continue;
 
         const double eps_x = edge_edge_mollifier_threshold(
@@ -242,10 +242,10 @@ void NormalCollisionsBuilder::add_face_vertex_collisions(
         // Compute distance type
         const PointTriangleDistanceType dtype =
             point_triangle_distance_type(v, f0, f1, f2);
-        const double distance_squared =
+        const double distance_sqr =
             point_triangle_distance(v, f0, f1, f2, dtype);
 
-        if (!is_active(distance_squared))
+        if (!is_active(distance_sqr))
             continue;
 
         // ÷ 4 to handle double counting and PT + EE for correct integration