format file

Author: Huangzizhou

src/ipc/collision_mesh.cpp

@@ -1,16 +1,15 @@
 #include "collision_mesh.hpp"
 
 #include <ipc/distance/point_edge.hpp>
-
 #include <ipc/utils/area_gradient.hpp>
 #include <ipc/utils/eigen_ext.hpp>
-#include <ipc/utils/math.hpp>
 #include <ipc/utils/local_to_global.hpp>
 #include <ipc/utils/logger.hpp>
+#include <ipc/utils/math.hpp>
 #include <ipc/utils/unordered_map_and_set.hpp>
 
-#include <tbb/parallel_for.h>
 #include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
 
 namespace ipc {
 
@@ -134,13 +133,11 @@ void CollisionMesh::construct_edges_to_faces()
 {
     if (dim() == 2)
         return;
-    
+
     m_edges_to_faces.setOnes(num_edges(), 2);
     m_edges_to_faces *= -1;
-    for (int f = 0; f < m_faces_to_edges.rows(); f++)
-    {
-        for (int le = 0; le < 3; le++)
-        {
+    for (int f = 0; f < m_faces_to_edges.rows(); f++) {
+        for (int le = 0; le < 3; le++) {
             if (m_edges_to_faces(m_faces_to_edges(f, le), 0) < 0)
                 m_edges_to_faces(m_faces_to_edges(f, le), 0) = f;
             else if (m_edges_to_faces(m_faces_to_edges(f, le), 1) < 0)
@@ -278,7 +275,7 @@ void CollisionMesh::init_areas()
             m_vertices_to_edges[m_edges(i, j)].push_back(i);
         }
     }
-    
+
     m_vertices_to_faces.resize(num_vertices());
     for (int i = 0; i < m_faces.rows(); i++) {
         for (int j = 0; j < m_faces.cols(); j++) {
@@ -513,9 +510,11 @@ Eigen::MatrixXi CollisionMesh::construct_faces_to_edges(
     return faces_to_edges;
 }
 
-double CollisionMesh::edge_length(const int &edge_id) const
+double CollisionMesh::edge_length(const int& edge_id) const
 {
-    return (m_rest_positions.row(m_edges(edge_id, 0)) - m_rest_positions.row(m_edges(edge_id, 1))).norm();
+    return (m_rest_positions.row(m_edges(edge_id, 0))
+            - m_rest_positions.row(m_edges(edge_id, 1)))
+        .norm();
 }
 
 double CollisionMesh::max_edge_length() const
@@ -526,59 +525,54 @@ double CollisionMesh::max_edge_length() const
     return val;
 }
 
-std::vector<long> CollisionMesh::find_vertex_adjacent_vertices(const long &v) const
+std::vector<long>
+CollisionMesh::find_vertex_adjacent_vertices(const long& v) const
 {
     std::vector<long> neighbors;
-    if (dim() == 2)
-    {
+    if (dim() == 2) {
         neighbors.assign(2, -1);
-        for (long i : vertex_edge_adjacencies()[v])
-        {
+        for (long i : vertex_edge_adjacencies()[v]) {
             if (edges()(i, 0) == v)
                 neighbors[0] = edges()(i, 1);
             else if (edges()(i, 1) == v)
                 neighbors[1] = edges()(i, 0);
             else
                 throw std::runtime_error("Invalid edge-vertex adjacency!");
         }
-    }
-    else
-    {
-        if (vertices_to_faces()[v].size() > 0)
-        {
-            // construct a map of neighboring vertices, it maps every neighbor to the next counter-clockwise neighbor
+    } else {
+        if (vertices_to_faces()[v].size() > 0) {
+            // construct a map of neighboring vertices, it maps every neighbor
+            // to the next counter-clockwise neighbor
             std::unordered_map<long, long> map;
-            for (auto f : vertices_to_faces()[v])
-            {
-                for (int lv = 0; lv < 3; lv++)
-                {
-                    if (faces()(f, lv) == v)
-                    {
-                        map[faces()(f, (lv+1)%3)] = faces()(f, (lv+2)%3);
+            for (auto f : vertices_to_faces()[v]) {
+                for (int lv = 0; lv < 3; lv++) {
+                    if (faces()(f, lv) == v) {
+                        map[faces()(f, (lv + 1) % 3)] =
+                            faces()(f, (lv + 2) % 3);
                         break;
                     }
                 }
             }
             if (vertices_to_faces()[v].size() != map.size())
-                throw std::runtime_error("Non-manifold vertex! Map size smaller than neighbor!");
-            
+                throw std::runtime_error(
+                    "Non-manifold vertex! Map size smaller than neighbor!");
+
             // verify that the neighboring vertices form a loop
             auto iter = map.find(map.begin()->first);
-            while (neighbors.empty() || iter->first != neighbors.front())
-            {
+            while (neighbors.empty() || iter->first != neighbors.front()) {
                 neighbors.push_back(iter->first);
                 iter = map.find(iter->second);
-                if (iter == map.end())
-                {
-                    logger().error("neighbor faces {}, map {}", vertices_to_faces()[v].size(), map);
-                    throw std::runtime_error("Non-manifold vertex! Cannot find next neighbor!");
+                if (iter == map.end()) {
+                    logger().error(
+                        "neighbor faces {}, map {}",
+                        vertices_to_faces()[v].size(), map);
+                    throw std::runtime_error(
+                        "Non-manifold vertex! Cannot find next neighbor!");
                 }
             }
             if (neighbors.size() != map.size())
                 throw std::runtime_error("Non-manifold vertex!");
-        }
-        else
-        {
+        } else {
             for (int eid : vertices_to_edges()[v])
                 neighbors.push_back(
                     edges()(eid, 0) == v ? edges()(eid, 1) : edges()(eid, 0));