formatting

Former-commit-id: ad2fdad45729a96ab528bcad78517982c223aed2

include/igl/outer_element.cpp

@@ -21,53 +21,60 @@ IGL_INLINE void igl::outer_vertex(
         const Eigen::PlainObjectBase<DerivedF> & F,
         const Eigen::PlainObjectBase<DerivedI> & I,
         IndexType & v_index,
-        Eigen::PlainObjectBase<DerivedA> & A) {
-    // Algorithm: 
-    //    Find an outer vertex (i.e. vertex reachable from infinity)
-    //    Return the vertex with the largest X value.
-    //    If there is a tie, pick the one with largest Y value.
-    //    If there is still a tie, pick the one with the largest Z value.
-    //    If there is still a tie, then there are duplicated vertices within the
-    //    mesh, which violates the precondition.
-    const size_t INVALID = std::numeric_limits<size_t>::max();
-    const size_t num_selected_faces = I.rows();
-    std::vector<size_t> candidate_faces;
-    size_t outer_vid = INVALID;
-    typename DerivedV::Scalar outer_val = 0;
-    for (size_t i=0; i<num_selected_faces; i++) {
-        size_t f = I(i);
-        for (size_t j=0; j<3; j++) {
-            auto v = F(f, j);
-            auto vx = V(v, 0);
-            if (outer_vid == INVALID || vx > outer_val) {
-                outer_val = vx;
-                outer_vid = v;
-                candidate_faces = {f};
-            } else if (v == outer_vid) {
-                candidate_faces.push_back(f);
-            } else if (vx == outer_val) {
-                // Break tie.
-                auto vy = V(v,1);
-                auto vz = V(v, 2);
-                auto outer_y = V(outer_vid, 1);
-                auto outer_z = V(outer_vid, 2);
-                assert(!(vy == outer_y && vz == outer_z));
-                bool replace = (vy > outer_y) ||
-                    ((vy == outer_y) && (vz > outer_z));
-                if (replace) {
-                    outer_val = vx;
-                    outer_vid = v;
-                    candidate_faces = {f};
-                }
-            }
+        Eigen::PlainObjectBase<DerivedA> & A)
+{
+  // Algorithm: 
+  //    Find an outer vertex (i.e. vertex reachable from infinity)
+  //    Return the vertex with the largest X value.
+  //    If there is a tie, pick the one with largest Y value.
+  //    If there is still a tie, pick the one with the largest Z value.
+  //    If there is still a tie, then there are duplicated vertices within the
+  //    mesh, which violates the precondition.
+  const size_t INVALID = std::numeric_limits<size_t>::max();
+  const size_t num_selected_faces = I.rows();
+  std::vector<size_t> candidate_faces;
+  size_t outer_vid = INVALID;
+  typename DerivedV::Scalar outer_val = 0;
+  for (size_t i=0; i<num_selected_faces; i++)
+  {
+    size_t f = I(i);
+    for (size_t j=0; j<3; j++)
+    {
+      auto v = F(f, j);
+      auto vx = V(v, 0);
+      if (outer_vid == INVALID || vx > outer_val)
+      {
+        outer_val = vx;
+        outer_vid = v;
+        candidate_faces = {f};
+      } else if (v == outer_vid)
+      {
+        candidate_faces.push_back(f);
+      } else if (vx == outer_val)
+      {
+        // Break tie.
+        auto vy = V(v,1);
+        auto vz = V(v, 2);
+        auto outer_y = V(outer_vid, 1);
+        auto outer_z = V(outer_vid, 2);
+        assert(!(vy == outer_y && vz == outer_z));
+        bool replace = (vy > outer_y) ||
+          ((vy == outer_y) && (vz > outer_z));
+        if (replace)
+        {
+          outer_val = vx;
+          outer_vid = v;
+          candidate_faces = {f};
         }
+      }
     }
+  }
 
-    assert(outer_vid != INVALID);
-    assert(candidate_faces.size() > 0);
-    v_index = outer_vid;
-    A.resize(candidate_faces.size());
-    std::copy(candidate_faces.begin(), candidate_faces.end(), A.data());
+  assert(outer_vid != INVALID);
+  assert(candidate_faces.size() > 0);
+  v_index = outer_vid;
+  A.resize(candidate_faces.size());
+  std::copy(candidate_faces.begin(), candidate_faces.end(), A.data());
 }
 
 template<
@@ -78,88 +85,94 @@ template<
     typename DerivedA
     >
 IGL_INLINE void igl::outer_edge(
-        const Eigen::PlainObjectBase<DerivedV> & V,
-        const Eigen::PlainObjectBase<DerivedF> & F,
-        const Eigen::PlainObjectBase<DerivedI> & I,
-        IndexType & v1,
-        IndexType & v2,
-        Eigen::PlainObjectBase<DerivedA> & A) {
-    // Algorithm:
-    //    Find an outer vertex first.
-    //    Find the incident edge with largest slope when projected onto XY plane.
-    //    If there is still a tie, break it using the projected slope onto ZX plane.
-    //    If there is still a tie, then there are multiple overlapping edges,
-    //    which violates the precondition.
-    typedef typename DerivedV::Scalar Scalar;
-    typedef typename DerivedV::Index Index;
-    typedef typename Eigen::Matrix<Scalar, 3, 1> ScalarArray3;
-    typedef typename Eigen::Matrix<typename DerivedF::Scalar, 3, 1> IndexArray3;
-    const size_t INVALID = std::numeric_limits<size_t>::max();
-
-    Index outer_vid;
-    Eigen::Matrix<Index,Eigen::Dynamic,1> candidate_faces;
-    outer_vertex(V, F, I, outer_vid, candidate_faces);
-    const ScalarArray3& outer_v = V.row(outer_vid);
-    assert(candidate_faces.size() > 0);
-
-    auto get_vertex_index = [&](const IndexArray3& f, Index vid) -> Index 
-    {
-        if (f[0] == vid) return 0;
-        if (f[1] == vid) return 1;
-        if (f[2] == vid) return 2;
-        assert(false);
-        return -1;
-    };
-
-    Scalar outer_slope_YX = 0;
-    Scalar outer_slope_ZX = 0;
-    size_t outer_opp_vid = INVALID;
-    bool infinite_slope_detected = false;
-    std::vector<Index> incident_faces;
-    auto check_and_update_outer_edge = [&](Index opp_vid, Index fid) {
-        if (opp_vid == outer_opp_vid) {
-            incident_faces.push_back(fid);
-            return;
-        }
-
-        const ScalarArray3 opp_v = V.row(opp_vid);
-        if (!infinite_slope_detected && outer_v[0] != opp_v[0]) {
-            // Finite slope
-            const ScalarArray3 diff = opp_v - outer_v;
-            const Scalar slope_YX = diff[1] / diff[0];
-            const Scalar slope_ZX = diff[2] / diff[0];
-            if (outer_opp_vid == INVALID ||
-                    slope_YX > outer_slope_YX ||
-                    (slope_YX == outer_slope_YX &&
-                     slope_ZX > outer_slope_ZX)) {
-                outer_opp_vid = opp_vid;
-                outer_slope_YX = slope_YX;
-                outer_slope_ZX = slope_ZX;
-                incident_faces = {fid};
-            }
-        } else if (!infinite_slope_detected) {
-            // Infinite slope
-            outer_opp_vid = opp_vid;
-            infinite_slope_detected = true;
-            incident_faces = {fid};
-        }
-    };
-
-    const auto num_candidate_faces = candidate_faces.size();
-    for (size_t i=0; i<num_candidate_faces; i++) {
-        const Index fid = candidate_faces(i);
-        const IndexArray3& f = F.row(fid);
-        size_t id = get_vertex_index(f, outer_vid);
-        Index next_vid = f((id+1)%3);
-        Index prev_vid = f((id+2)%3);
-        check_and_update_outer_edge(next_vid, fid);
-        check_and_update_outer_edge(prev_vid, fid);
-    }
-
-    v1 = outer_vid;
-    v2 = outer_opp_vid;
-    A.resize(incident_faces.size());
-    std::copy(incident_faces.begin(), incident_faces.end(), A.data());
+       const Eigen::PlainObjectBase<DerivedV> & V,
+       const Eigen::PlainObjectBase<DerivedF> & F,
+       const Eigen::PlainObjectBase<DerivedI> & I,
+       IndexType & v1,
+       IndexType & v2,
+       Eigen::PlainObjectBase<DerivedA> & A) {
+   // Algorithm:
+   //    Find an outer vertex first.
+   //    Find the incident edge with largest slope when projected onto XY
+   //      plane.
+   //    If there is still a tie, break it using the projected slope onto ZX
+   //      plane.
+   //    If there is still a tie, then there are multiple overlapping edges,
+   //      which violates the precondition.
+   typedef typename DerivedV::Scalar Scalar;
+   typedef typename DerivedV::Index Index;
+   typedef typename Eigen::Matrix<Scalar, 3, 1> ScalarArray3;
+   typedef typename Eigen::Matrix<typename DerivedF::Scalar, 3, 1> IndexArray3;
+   const size_t INVALID = std::numeric_limits<size_t>::max();
+
+   Index outer_vid;
+   Eigen::Matrix<Index,Eigen::Dynamic,1> candidate_faces;
+   outer_vertex(V, F, I, outer_vid, candidate_faces);
+   const ScalarArray3& outer_v = V.row(outer_vid);
+   assert(candidate_faces.size() > 0);
+
+   auto get_vertex_index = [&](const IndexArray3& f, Index vid) -> Index 
+   {
+     if (f[0] == vid) return 0;
+     if (f[1] == vid) return 1;
+     if (f[2] == vid) return 2;
+     assert(false);
+     return -1;
+   };
+
+   Scalar outer_slope_YX = 0;
+   Scalar outer_slope_ZX = 0;
+   size_t outer_opp_vid = INVALID;
+   bool infinite_slope_detected = false;
+   std::vector<Index> incident_faces;
+   auto check_and_update_outer_edge = [&](Index opp_vid, Index fid) {
+     if (opp_vid == outer_opp_vid)
+     {
+       incident_faces.push_back(fid);
+       return;
+     }
+
+     const ScalarArray3 opp_v = V.row(opp_vid);
+     if (!infinite_slope_detected && outer_v[0] != opp_v[0]) 
+     {
+       // Finite slope
+       const ScalarArray3 diff = opp_v - outer_v;
+       const Scalar slope_YX = diff[1] / diff[0];
+       const Scalar slope_ZX = diff[2] / diff[0];
+       if (outer_opp_vid == INVALID ||
+               slope_YX > outer_slope_YX ||
+               (slope_YX == outer_slope_YX &&
+                slope_ZX > outer_slope_ZX)) {
+           outer_opp_vid = opp_vid;
+           outer_slope_YX = slope_YX;
+           outer_slope_ZX = slope_ZX;
+           incident_faces = {fid};
+       }
+     } else if (!infinite_slope_detected)
+     {
+       // Infinite slope
+       outer_opp_vid = opp_vid;
+       infinite_slope_detected = true;
+       incident_faces = {fid};
+     }
+   };
+
+   const size_t num_candidate_faces = candidate_faces.size();
+   for (size_t i=0; i<num_candidate_faces; i++) 
+   {
+     const Index fid = candidate_faces(i);
+     const IndexArray3& f = F.row(fid);
+     size_t id = get_vertex_index(f, outer_vid);
+     Index next_vid = f((id+1)%3);
+     Index prev_vid = f((id+2)%3);
+     check_and_update_outer_edge(next_vid, fid);
+     check_and_update_outer_edge(prev_vid, fid);
+   }
+
+   v1 = outer_vid;
+   v2 = outer_opp_vid;
+   A.resize(incident_faces.size());
+   std::copy(incident_faces.begin(), incident_faces.end(), A.data());
 }
 
 template<