templates, warnings, formatting

Former-commit-id: a551329a58f0ce180a085224a90681ec6fbec03a

include/igl/cgal/order_facets_around_edge.cpp

@@ -1,324 +1,355 @@
 #include "order_facets_around_edge.h"
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 
-namespace igl {
-    namespace cgal {
-        namespace order_facets_around_edges_helper {
-            template<typename T>
-            std::vector<size_t> index_sort(const std::vector<T>& data) {
-                const size_t len = data.size();
-                std::vector<size_t> order(len);
-                for (size_t i=0; i<len; i++) order[i] = i;
-
-                auto comp = [&](size_t i, size_t j) {
-                    return data[i] < data[j];
-                };
-                std::sort(order.begin(), order.end(), comp);
-                return order;
-            }
+namespace igl
+{
+  namespace cgal
+  {
+    namespace order_facets_around_edges_helper
+    {
+      template<typename T>
+        std::vector<size_t> index_sort(const std::vector<T>& data)
+        {
+          const size_t len = data.size();
+          std::vector<size_t> order(len);
+          for (size_t i=0; i<len; i++)
+          {
+            order[i] = i;
+          }
+          auto comp = [&](size_t i, size_t j)
+          {
+            return data[i] < data[j];
+          };
+          std::sort(order.begin(), order.end(), comp);
+          return order;
         }
     }
+  }
 }
 
 // adj_faces contains signed index starting from +- 1.
 template<
-    typename DerivedV,
-    typename DerivedF,
-    typename DerivedI >
+  typename DerivedV,
+  typename DerivedF,
+  typename DerivedI >
 void igl::cgal::order_facets_around_edge(
-    const Eigen::PlainObjectBase<DerivedV>& V,
-    const Eigen::PlainObjectBase<DerivedF>& F,
-    size_t s, size_t d, 
-    const std::vector<int>& adj_faces,
-    Eigen::PlainObjectBase<DerivedI>& order) {
-
-    using namespace igl::cgal::order_facets_around_edges_helper;
-
-    // Although we only need exact predicates in the algorithm,
-    // exact constructions are needed to avoid degeneracies due to
-    // casting to double.
-    typedef CGAL::Exact_predicates_exact_constructions_kernel K;
-    typedef K::Point_3 Point_3;
-    typedef K::Plane_3 Plane_3;
-
-    auto get_face_index = [&](int adj_f)->size_t{
-        return abs(adj_f) - 1;
-    };
-
-    auto get_opposite_vertex = [&](size_t fid)->size_t {
-        if (F(fid, 0) != s && F(fid, 0) != d) return F(fid, 0);
-        if (F(fid, 1) != s && F(fid, 1) != d) return F(fid, 1);
-        if (F(fid, 2) != s && F(fid, 2) != d) return F(fid, 2);
-        assert(false);
-        return -1;
-    };
-
-    // Handle base cases
-    if (adj_faces.size() == 0) {
-        order.resize(0, 1);
-        return;
-    } else if (adj_faces.size() == 1) {
-        order.resize(1, 1);
+  const Eigen::PlainObjectBase<DerivedV>& V,
+  const Eigen::PlainObjectBase<DerivedF>& F,
+  size_t s, 
+  size_t d, 
+  const std::vector<int>& adj_faces,
+  Eigen::PlainObjectBase<DerivedI>& order)
+{
+  using namespace igl::cgal::order_facets_around_edges_helper;
+
+  // Although we only need exact predicates in the algorithm,
+  // exact constructions are needed to avoid degeneracies due to
+  // casting to double.
+  typedef CGAL::Exact_predicates_exact_constructions_kernel K;
+  typedef K::Point_3 Point_3;
+  typedef K::Plane_3 Plane_3;
+
+  auto get_face_index = [&](int adj_f)->size_t
+  {
+    return abs(adj_f) - 1;
+  };
+
+  auto get_opposite_vertex = [&](size_t fid)->size_t
+  {
+    typedef typename DerivedF::Scalar Index;
+    if (F(fid, 0) != (Index)s && F(fid, 0) != (Index)d) return F(fid, 0);
+    if (F(fid, 1) != (Index)s && F(fid, 1) != (Index)d) return F(fid, 1);
+    if (F(fid, 2) != (Index)s && F(fid, 2) != (Index)d) return F(fid, 2);
+    assert(false);
+    return -1;
+  };
+
+  // Handle base cases
+  if (adj_faces.size() == 0) 
+  {
+    order.resize(0, 1);
+    return;
+  } else if (adj_faces.size() == 1)
+  {
+    order.resize(1, 1);
+    order(0, 0) = 0;
+    return;
+  } else if (adj_faces.size() == 2)
+  {
+    const size_t o1 = get_opposite_vertex(get_face_index(adj_faces[0]));
+    const size_t o2 = get_opposite_vertex(get_face_index(adj_faces[1]));
+    const Point_3 ps(V(s, 0), V(s, 1), V(s, 2));
+    const Point_3 pd(V(d, 0), V(d, 1), V(d, 2));
+    const Point_3 p1(V(o1, 0), V(o1, 1), V(o1, 2));
+    const Point_3 p2(V(o2, 0), V(o2, 1), V(o2, 2));
+    order.resize(2, 1);
+    switch (CGAL::orientation(ps, pd, p1, p2))
+    {
+      case CGAL::POSITIVE:
+        order(0, 0) = 1;
+        order(1, 0) = 0;
+        break;
+      case CGAL::NEGATIVE:
         order(0, 0) = 0;
-        return;
-    } else if (adj_faces.size() == 2) {
-        const size_t o1 =
-            get_opposite_vertex(get_face_index(adj_faces[0]));
-        const size_t o2 =
-            get_opposite_vertex(get_face_index(adj_faces[1]));
-        const Point_3 ps(V(s, 0), V(s, 1), V(s, 2));
-        const Point_3 pd(V(d, 0), V(d, 1), V(d, 2));
-        const Point_3 p1(V(o1, 0), V(o1, 1), V(o1, 2));
-        const Point_3 p2(V(o2, 0), V(o2, 1), V(o2, 2));
-        order.resize(2, 1);
-        switch (CGAL::orientation(ps, pd, p1, p2)) {
-            case CGAL::POSITIVE:
-                order(0, 0) = 1;
-                order(1, 0) = 0;
-                break;
-            case CGAL::NEGATIVE:
-                order(0, 0) = 0;
-                order(1, 0) = 1;
-                break;
-            case CGAL::COPLANAR:
-                {
-                    Plane_3 P1(ps, pd, p1);
-                    Plane_3 P2(ps, pd, p2);
-                    if (P1.orthogonal_direction() == P2.orthogonal_direction()){
-                        // Duplicated face, use index to break tie.
-                        order(0, 0) = adj_faces[0] < adj_faces[1] ? 0:1;
-                        order(1, 0) = adj_faces[0] < adj_faces[1] ? 1:0;
-                    } else {
-                        // Coplanar faces, one on each side of the edge.
-                        // It is equally valid to order them (0, 1) or (1, 0).
-                        // I cannot think of any reason to prefer one to the
-                        // other.  So just use (0, 1) ordering by default.
-                        order(0, 0) = 0;
-                        order(1, 0) = 1;
-                    }
-                }
-                break;
-            default:
-                assert(false);
+        order(1, 0) = 1;
+        break;
+      case CGAL::COPLANAR:
+        {
+          Plane_3 P1(ps, pd, p1);
+          Plane_3 P2(ps, pd, p2);
+          if (P1.orthogonal_direction() == P2.orthogonal_direction()){
+            // Duplicated face, use index to break tie.
+            order(0, 0) = adj_faces[0] < adj_faces[1] ? 0:1;
+            order(1, 0) = adj_faces[0] < adj_faces[1] ? 1:0;
+          } else {
+            // Coplanar faces, one on each side of the edge.
+            // It is equally valid to order them (0, 1) or (1, 0).
+            // I cannot think of any reason to prefer one to the
+            // other.  So just use (0, 1) ordering by default.
+            order(0, 0) = 0;
+            order(1, 0) = 1;
+          }
         }
-        return;
-    }
-
-    const size_t num_adj_faces = adj_faces.size();
-    const size_t o = get_opposite_vertex(
-            get_face_index(adj_faces[0]));
-    const Point_3 p_s(V(s, 0), V(s, 1), V(s, 2));
-    const Point_3 p_d(V(d, 0), V(d, 1), V(d, 2));
-    const Point_3 p_o(V(o, 0), V(o, 1), V(o, 2));
-    const Plane_3 separator(p_s, p_d, p_o);
-    assert(!separator.is_degenerate());
-
-    std::vector<Point_3> opposite_vertices;
-    for (size_t i=0; i<num_adj_faces; i++) {
-        const size_t o = get_opposite_vertex(
-                get_face_index(adj_faces[i]));
-        opposite_vertices.emplace_back(
-                V(o, 0), V(o, 1), V(o, 2));
-    }
-
-    std::vector<int> positive_side;
-    std::vector<int> negative_side;
-    std::vector<int> tie_positive_oriented;
-    std::vector<int> tie_negative_oriented;
-
-    std::vector<size_t> positive_side_index;
-    std::vector<size_t> negative_side_index;
-    std::vector<size_t> tie_positive_oriented_index;
-    std::vector<size_t> tie_negative_oriented_index;
-
-    for (size_t i=0; i<num_adj_faces; i++) {
-        const int f = adj_faces[i];
-        const Point_3& p_a = opposite_vertices[i];
-        auto orientation = separator.oriented_side(p_a);
-        switch (orientation) {
-            case CGAL::ON_POSITIVE_SIDE:
-                positive_side.push_back(f);
-                positive_side_index.push_back(i);
-                break;
-            case CGAL::ON_NEGATIVE_SIDE:
-                negative_side.push_back(f);
-                negative_side_index.push_back(i);
-                break;
-            case CGAL::ON_ORIENTED_BOUNDARY:
-                {
-                    const Plane_3 other(p_s, p_d, p_a);
-                    const auto target_dir = separator.orthogonal_direction();
-                    const auto query_dir = other.orthogonal_direction();
-                    if (target_dir == query_dir) {
-                        tie_positive_oriented.push_back(f);
-                        tie_positive_oriented_index.push_back(i);
-                    } else if (target_dir == -query_dir) {
-                        tie_negative_oriented.push_back(f);
-                        tie_negative_oriented_index.push_back(i);
-                    } else {
-                        assert(false);
-                    }
-                }
-                break;
-            default:
-                // Should not be here.
-                assert(false);
-        }
-    }
-
-    Eigen::PlainObjectBase<DerivedI> positive_order, negative_order;
-    order_facets_around_edge(V, F, s, d, positive_side, positive_order);
-    order_facets_around_edge(V, F, s, d, negative_side, negative_order);
-    std::vector<size_t> tie_positive_order =
-        index_sort(tie_positive_oriented);
-    std::vector<size_t> tie_negative_order =
-        index_sort(tie_negative_oriented);
-
-    // Copy results into order vector.
-    const size_t tie_positive_size = tie_positive_oriented.size();
-    const size_t tie_negative_size = tie_negative_oriented.size();
-    const size_t positive_size = positive_order.size();
-    const size_t negative_size = negative_order.size();
-
-    order.resize(tie_positive_size + positive_size +
-            tie_negative_size + negative_size, 1);
-
-    size_t count=0;
-    for (size_t i=0; i<tie_positive_size; i++) {
-        order(count+i, 0) =
-            tie_positive_oriented_index[tie_positive_order[i]];
-    }
-    count += tie_positive_size;
-
-    for (size_t i=0; i<negative_size; i++) {
-        order(count+i, 0) = negative_side_index[negative_order(i, 0)];
-    }
-    count += negative_size;
-
-    for (size_t i=0; i<tie_negative_size; i++) {
-        order(count+i, 0) =
-            tie_negative_oriented_index[tie_negative_order[i]];
-    }
-    count += tie_negative_size;
-
-    for (size_t i=0; i<positive_size; i++) {
-        order(count+i, 0) = positive_side_index[positive_order(i, 0)];
+        break;
+      default:
+        assert(false);
     }
-    count += positive_size;
-    assert(count == num_adj_faces);
-
-    // Find the correct start point.
-    size_t start_idx = 0;
-    for (size_t i=0; i<num_adj_faces; i++) {
-        const Point_3& p_a = opposite_vertices[order(i, 0)];
-        const Point_3& p_b =
-            opposite_vertices[order((i+1)%num_adj_faces, 0)];
-        auto orientation = CGAL::orientation(p_s, p_d, p_a, p_b);
-        if (orientation == CGAL::POSITIVE) {
-            // Angle between triangle (p_s, p_d, p_a) and (p_s, p_d, p_b) is
-            // more than 180 degrees.
-            start_idx = (i+1)%num_adj_faces;
-            break;
-        } else if (orientation == CGAL::COPLANAR &&
-                Plane_3(p_s, p_d, p_a).orthogonal_direction() !=
-                Plane_3(p_s, p_d, p_b).orthogonal_direction()) {
-            // All 4 points are coplanar, but p_a and p_b are on each side of
-            // the edge (p_s, p_d).  This means the angle between triangle
-            // (p_s, p_d, p_a) and (p_s, p_d, p_b) is exactly 180 degrees.
-            start_idx = (i+1)%num_adj_faces;
-            break;
+    return;
+  }
+
+  const size_t num_adj_faces = adj_faces.size();
+  const size_t o = get_opposite_vertex( get_face_index(adj_faces[0]));
+  const Point_3 p_s(V(s, 0), V(s, 1), V(s, 2));
+  const Point_3 p_d(V(d, 0), V(d, 1), V(d, 2));
+  const Point_3 p_o(V(o, 0), V(o, 1), V(o, 2));
+  const Plane_3 separator(p_s, p_d, p_o);
+  assert(!separator.is_degenerate());
+
+  std::vector<Point_3> opposite_vertices;
+  for (size_t i=0; i<num_adj_faces; i++) 
+  {
+    const size_t o = get_opposite_vertex( get_face_index(adj_faces[i]));
+    opposite_vertices.emplace_back(
+        V(o, 0), V(o, 1), V(o, 2));
+  }
+
+  std::vector<int> positive_side;
+  std::vector<int> negative_side;
+  std::vector<int> tie_positive_oriented;
+  std::vector<int> tie_negative_oriented;
+
+  std::vector<size_t> positive_side_index;
+  std::vector<size_t> negative_side_index;
+  std::vector<size_t> tie_positive_oriented_index;
+  std::vector<size_t> tie_negative_oriented_index;
+
+  for (size_t i=0; i<num_adj_faces; i++)
+  {
+    const int f = adj_faces[i];
+    const Point_3& p_a = opposite_vertices[i];
+    auto orientation = separator.oriented_side(p_a);
+    switch (orientation) {
+      case CGAL::ON_POSITIVE_SIDE:
+        positive_side.push_back(f);
+        positive_side_index.push_back(i);
+        break;
+      case CGAL::ON_NEGATIVE_SIDE:
+        negative_side.push_back(f);
+        negative_side_index.push_back(i);
+        break;
+      case CGAL::ON_ORIENTED_BOUNDARY:
+        {
+          const Plane_3 other(p_s, p_d, p_a);
+          const auto target_dir = separator.orthogonal_direction();
+          const auto query_dir = other.orthogonal_direction();
+          if (target_dir == query_dir) {
+            tie_positive_oriented.push_back(f);
+            tie_positive_oriented_index.push_back(i);
+          } else if (target_dir == -query_dir) {
+            tie_negative_oriented.push_back(f);
+            tie_negative_oriented_index.push_back(i);
+          } else {
+            assert(false);
+          }
         }
+        break;
+      default:
+        // Should not be here.
+        assert(false);
     }
-    DerivedI circular_order = order;
-    for (size_t i=0; i<num_adj_faces; i++) {
-        order(i, 0) = circular_order((start_idx + i)%num_adj_faces, 0);
+  }
+
+  Eigen::PlainObjectBase<DerivedI> positive_order, negative_order;
+  order_facets_around_edge(V, F, s, d, positive_side, positive_order);
+  order_facets_around_edge(V, F, s, d, negative_side, negative_order);
+  std::vector<size_t> tie_positive_order = index_sort(tie_positive_oriented);
+  std::vector<size_t> tie_negative_order = index_sort(tie_negative_oriented);
+
+  // Copy results into order vector.
+  const size_t tie_positive_size = tie_positive_oriented.size();
+  const size_t tie_negative_size = tie_negative_oriented.size();
+  const size_t positive_size = positive_order.size();
+  const size_t negative_size = negative_order.size();
+
+  order.resize(
+    tie_positive_size + positive_size + tie_negative_size + negative_size,1);
+
+  size_t count=0;
+  for (size_t i=0; i<tie_positive_size; i++)
+  {
+    order(count+i, 0) = tie_positive_oriented_index[tie_positive_order[i]];
+  }
+  count += tie_positive_size;
+
+  for (size_t i=0; i<negative_size; i++)
+  {
+    order(count+i, 0) = negative_side_index[negative_order(i, 0)];
+  }
+  count += negative_size;
+
+  for (size_t i=0; i<tie_negative_size; i++)
+  {
+    order(count+i, 0) = tie_negative_oriented_index[tie_negative_order[i]];
+  }
+  count += tie_negative_size;
+
+  for (size_t i=0; i<positive_size; i++)
+  {
+    order(count+i, 0) = positive_side_index[positive_order(i, 0)];
+  }
+  count += positive_size;
+  assert(count == num_adj_faces);
+
+  // Find the correct start point.
+  size_t start_idx = 0;
+  for (size_t i=0; i<num_adj_faces; i++)
+  {
+    const Point_3& p_a = opposite_vertices[order(i, 0)];
+    const Point_3& p_b =
+      opposite_vertices[order((i+1)%num_adj_faces, 0)];
+    auto orientation = CGAL::orientation(p_s, p_d, p_a, p_b);
+    if (orientation == CGAL::POSITIVE)
+    {
+      // Angle between triangle (p_s, p_d, p_a) and (p_s, p_d, p_b) is
+      // more than 180 degrees.
+      start_idx = (i+1)%num_adj_faces;
+      break;
+    } else if (orientation == CGAL::COPLANAR &&
+        Plane_3(p_s, p_d, p_a).orthogonal_direction() !=
+        Plane_3(p_s, p_d, p_b).orthogonal_direction())
+    {
+      // All 4 points are coplanar, but p_a and p_b are on each side of
+      // the edge (p_s, p_d).  This means the angle between triangle
+      // (p_s, p_d, p_a) and (p_s, p_d, p_b) is exactly 180 degrees.
+      start_idx = (i+1)%num_adj_faces;
+      break;
     }
+  }
+  DerivedI circular_order = order;
+  for (size_t i=0; i<num_adj_faces; i++)
+  {
+    order(i, 0) = circular_order((start_idx + i)%num_adj_faces, 0);
+  }
 }
 
 template<
-    typename DerivedV,
-    typename DerivedF,
-    typename DerivedI>
+  typename DerivedV,
+  typename DerivedF,
+  typename DerivedI>
 IGL_INLINE
 void igl::cgal::order_facets_around_edge(
-        const Eigen::PlainObjectBase<DerivedV>& V,
-        const Eigen::PlainObjectBase<DerivedF>& F,
-        size_t s, size_t d, 
-        const std::vector<int>& adj_faces,
-        const Eigen::PlainObjectBase<DerivedV>& pivot_point,
-        Eigen::PlainObjectBase<DerivedI>& order) {
-
-    assert(V.cols() == 3);
-    assert(F.cols() == 3);
-    auto signed_index_to_index = [&](int signed_idx) {
-        return abs(signed_idx) -1;
-    };
-    auto get_opposite_vertex_index = [&](size_t fid) {
-        if (F(fid, 0) != s && F(fid, 0) != d) return F(fid, 0);
-        if (F(fid, 1) != s && F(fid, 1) != d) return F(fid, 1);
-        if (F(fid, 2) != s && F(fid, 2) != d) return F(fid, 2);
-        assert(false);
-        // avoid warning
-        return -1;
-    };
-
-    const size_t N = adj_faces.size();
-    const size_t num_faces = N + 1; // N adj faces + 1 pivot face
-
-    DerivedV vertices(num_faces + 2, 3);
-    for (size_t i=0; i<N; i++) {
-        const size_t fid = signed_index_to_index(adj_faces[i]);
-        vertices.row(i) = V.row(get_opposite_vertex_index(fid));
+  const Eigen::PlainObjectBase<DerivedV>& V,
+  const Eigen::PlainObjectBase<DerivedF>& F,
+  size_t s, 
+  size_t d, 
+  const std::vector<int>& adj_faces,
+  const Eigen::PlainObjectBase<DerivedV>& pivot_point,
+  Eigen::PlainObjectBase<DerivedI>& order) 
+{
+
+  assert(V.cols() == 3);
+  assert(F.cols() == 3);
+  auto signed_index_to_index = [&](int signed_idx)
+  {
+    return abs(signed_idx) -1;
+  };
+  auto get_opposite_vertex_index = [&](size_t fid)
+  {
+    typedef typename DerivedF::Scalar Index;
+    if (F(fid, 0) != (Index)s && F(fid, 0) != (Index)d) return F(fid, 0);
+    if (F(fid, 1) != (Index)s && F(fid, 1) != (Index)d) return F(fid, 1);
+    if (F(fid, 2) != (Index)s && F(fid, 2) != (Index)d) return F(fid, 2);
+    assert(false);
+    // avoid warning
+    return -1;
+  };
+
+  const typename DerivedF::Scalar N = adj_faces.size();
+  const size_t num_faces = N + 1; // N adj faces + 1 pivot face
+
+  DerivedV vertices(num_faces + 2, 3);
+  for (size_t i=0; i<(size_t)N; i++)
+  {
+    const size_t fid = signed_index_to_index(adj_faces[i]);
+    vertices.row(i) = V.row(get_opposite_vertex_index(fid));
+  }
+  vertices.row(N  ) = pivot_point;
+  vertices.row(N+1) = V.row(s);
+  vertices.row(N+2) = V.row(d);
+
+  DerivedF faces(num_faces, 3);
+  for (size_t i=0; i<(size_t)N; i++) 
+  {
+    if (adj_faces[i] < 0)
+    {
+      faces(i,0) = N+1; // s
+      faces(i,1) = N+2; // d
+      faces(i,2) = i  ;
+    } else {
+      faces(i,0) = N+2; // d
+      faces(i,1) = N+1; // s
+      faces(i,2) = i  ;
     }
-    vertices.row(N  ) = pivot_point;
-    vertices.row(N+1) = V.row(s);
-    vertices.row(N+2) = V.row(d);
-
-    DerivedF faces(num_faces, 3);
-    for (size_t i=0; i<N; i++) {
-        if (adj_faces[i] < 0) {
-            faces(i,0) = N+1; // s
-            faces(i,1) = N+2; // d
-            faces(i,2) = i  ;
-        } else {
-            faces(i,0) = N+2; // d
-            faces(i,1) = N+1; // s
-            faces(i,2) = i  ;
-        }
-    }
-    // Last face is the pivot face.
-    faces(N, 0) = N+1;
-    faces(N, 1) = N+2;
-    faces(N, 2) = N;
-
-    std::vector<int> adj_faces_with_pivot(num_faces);
-    for (size_t i=0; i<num_faces; i++) {
-        if (faces(i,0) == N+1 && faces(i,1) == N+2) {
-            adj_faces_with_pivot[i] = int(i+1) * -1;
-        } else {
-            adj_faces_with_pivot[i] = int(i+1);
-        }
+  }
+  // Last face is the pivot face.
+  faces(N, 0) = N+1;
+  faces(N, 1) = N+2;
+  faces(N, 2) = N;
+
+  std::vector<int> adj_faces_with_pivot(num_faces);
+  for (size_t i=0; i<num_faces; i++)
+  {
+    if (faces(i,0) == N+1 && faces(i,1) == N+2)
+    {
+      adj_faces_with_pivot[i] = int(i+1) * -1;
+    } else
+    {
+      adj_faces_with_pivot[i] = int(i+1);
     }
-
-    DerivedI order_with_pivot;
-    igl::cgal::order_facets_around_edge(
-            vertices, faces, N+1, N+2,
-            adj_faces_with_pivot, order_with_pivot);
-
-    assert(order_with_pivot.size() == num_faces);
-    order.resize(N);
-    size_t pivot_index = num_faces + 1;
-    for (size_t i=0; i<num_faces; i++) {
-        if (order_with_pivot[i] == N) {
-            pivot_index = i;
-            break;
-        }
+  }
+
+  DerivedI order_with_pivot;
+  igl::cgal::order_facets_around_edge(
+      vertices, faces, N+1, N+2,
+      adj_faces_with_pivot, order_with_pivot);
+
+  assert(order_with_pivot.size() == num_faces);
+  order.resize(N);
+  size_t pivot_index = num_faces + 1;
+  for (size_t i=0; i<num_faces; i++)
+  {
+    if (order_with_pivot[i] == N)
+    {
+      pivot_index = i;
+      break;
     }
-    assert(pivot_index < num_faces);
+  }
+  assert(pivot_index < num_faces);
 
-    for (size_t i=0; i<N; i++) {
-        order[i] = order_with_pivot[(pivot_index+i+1)%num_faces];
-    }
+  for (size_t i=0; i<(size_t)N; i++)
+  {
+    order[i] = order_with_pivot[(pivot_index+i+1)%num_faces];
+  }
 }
 
 

include/igl/cgal/order_facets_around_edges.cpp

@@ -15,9 +15,7 @@ template<
     typename DerivedV,
     typename DerivedF,
     typename DerivedN,
-    typename DerivedE,
     typename DeriveduE,
-    typename DerivedEMAP,
     typename uE2EType,
     typename uE2oEType,
     typename uE2CType >
@@ -28,9 +26,7 @@ igl::cgal::order_facets_around_edges(
         const Eigen::PlainObjectBase<DerivedV>& V,
         const Eigen::PlainObjectBase<DerivedF>& F,
         const Eigen::PlainObjectBase<DerivedN>& N,
-        const Eigen::PlainObjectBase<DerivedE>& E,
         const Eigen::PlainObjectBase<DeriveduE>& uE,
-        const Eigen::PlainObjectBase<DerivedEMAP>& EMAP,
         const std::vector<std::vector<uE2EType> >& uE2E,
         std::vector<std::vector<uE2oEType> >& uE2oE,
         std::vector<std::vector<uE2CType > >& uE2C ) {
@@ -159,9 +155,7 @@ template<
     typename DerivedV,
     typename DerivedF,
     typename DerivedN,
-    typename DerivedE,
     typename DeriveduE,
-    typename DerivedEMAP,
     typename uE2EType,
     typename uE2oEType,
     typename uE2CType >
@@ -172,9 +166,7 @@ igl::cgal::order_facets_around_edges(
         const Eigen::PlainObjectBase<DerivedV>& V,
         const Eigen::PlainObjectBase<DerivedF>& F,
         const Eigen::PlainObjectBase<DerivedN>& N,
-        const Eigen::PlainObjectBase<DerivedE>& E,
         const Eigen::PlainObjectBase<DeriveduE>& uE,
-        const Eigen::PlainObjectBase<DerivedEMAP>& EMAP,
         const std::vector<std::vector<uE2EType> >& uE2E,
         std::vector<std::vector<uE2oEType> >& uE2oE,
         std::vector<std::vector<uE2CType > >& uE2C ) {
@@ -257,23 +249,19 @@ igl::cgal::order_facets_around_edges(
 template<
     typename DerivedV,
     typename DerivedF,
-    typename DerivedE,
     typename DeriveduE,
-    typename DerivedEMAP,
     typename uE2EType,
     typename uE2oEType,
     typename uE2CType >
 IGL_INLINE void igl::cgal::order_facets_around_edges(
         const Eigen::PlainObjectBase<DerivedV>& V,
         const Eigen::PlainObjectBase<DerivedF>& F,
-        const Eigen::PlainObjectBase<DerivedE>& E,
         const Eigen::PlainObjectBase<DeriveduE>& uE,
-        const Eigen::PlainObjectBase<DerivedEMAP>& EMAP,
         const std::vector<std::vector<uE2EType> >& uE2E,
         std::vector<std::vector<uE2oEType> >& uE2oE,
         std::vector<std::vector<uE2CType > >& uE2C ) {
 
-    typedef Eigen::Matrix<typename DerivedV::Scalar, 3, 1> Vector3E;
+    //typedef Eigen::Matrix<typename DerivedV::Scalar, 3, 1> Vector3E;
     const size_t num_faces = F.rows();
     const size_t num_undirected_edges = uE.rows();
 
@@ -332,7 +320,7 @@ IGL_INLINE void igl::cgal::order_facets_around_edges(
 
 #ifdef IGL_STATIC_LIBRARY
 // Explicit template specialization
-template void igl::cgal::order_facets_around_edges<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, long, long, bool>(Eigen::PlainObjectBase<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > >&, std::__1::vector<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::allocator<std::__1::vector<bool, std::__1::allocator<bool> > > >&);
-template void igl::cgal::order_facets_around_edges<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, long, long, bool>(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > >&, std::__1::vector<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::allocator<std::__1::vector<bool, std::__1::allocator<bool> > > >&);
-template void igl::cgal::order_facets_around_edges<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, long, long, bool>(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > >&, std::__1::vector<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::allocator<std::__1::vector<bool, std::__1::allocator<bool> > > >&);
+template void igl::cgal::order_facets_around_edges<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, long, long, bool>(Eigen::PlainObjectBase<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > >&, std::__1::vector<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::allocator<std::__1::vector<bool, std::__1::allocator<bool> > > >&);
+template void igl::cgal::order_facets_around_edges<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, long, long, bool>(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > >&, std::__1::vector<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::allocator<std::__1::vector<bool, std::__1::allocator<bool> > > >&);
+template void igl::cgal::order_facets_around_edges<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 2, 0, -1, 2>, long, long, bool>(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 2, 0, -1, 2> > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > > const&, std::__1::vector<std::__1::vector<long, std::__1::allocator<long> >, std::__1::allocator<std::__1::vector<long, std::__1::allocator<long> > > >&, std::__1::vector<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::allocator<std::__1::vector<bool, std::__1::allocator<bool> > > >&);
 #endif

include/igl/cgal/order_facets_around_edges.h

@@ -29,9 +29,7 @@ namespace igl
     //   V    #V by 3 list of vertices.
     //   F    #F by 3 list of faces
     //   N    #F by 3 list of face normals.
-    //   E    #F*3 by 2 list vertex indices, represents directed edges.
     //  uE    #uE by 2 list of vertex_indices, represents undirected edges.
-    //  EMAP  #F*3 list of indices that maps E to uE. (a many-to-one map)
     //  uE2E  #uE list of lists that maps uE to E. (a one-to-many map)
     //
     // Outputs:
@@ -44,9 +42,7 @@ namespace igl
         typename DerivedV,
         typename DerivedF,
         typename DerivedN,
-        typename DerivedE,
         typename DeriveduE,
-        typename DerivedEMAP,
         typename uE2EType,
         typename uE2oEType,
         typename uE2CType >
@@ -57,9 +53,7 @@ namespace igl
             const Eigen::PlainObjectBase<DerivedV>& V,
             const Eigen::PlainObjectBase<DerivedF>& F,
             const Eigen::PlainObjectBase<DerivedN>& N,
-            const Eigen::PlainObjectBase<DerivedE>& E,
             const Eigen::PlainObjectBase<DeriveduE>& uE,
-            const Eigen::PlainObjectBase<DerivedEMAP>& EMAP,
             const std::vector<std::vector<uE2EType> >& uE2E,
             std::vector<std::vector<uE2oEType> >& uE2oE,
             std::vector<std::vector<uE2CType > >& uE2C );
@@ -68,9 +62,7 @@ namespace igl
         typename DerivedV,
         typename DerivedF,
         typename DerivedN,
-        typename DerivedE,
         typename DeriveduE,
-        typename DerivedEMAP,
         typename uE2EType,
         typename uE2oEType,
         typename uE2CType >
@@ -81,9 +73,7 @@ namespace igl
             const Eigen::PlainObjectBase<DerivedV>& V,
             const Eigen::PlainObjectBase<DerivedF>& F,
             const Eigen::PlainObjectBase<DerivedN>& N,
-            const Eigen::PlainObjectBase<DerivedE>& E,
             const Eigen::PlainObjectBase<DeriveduE>& uE,
-            const Eigen::PlainObjectBase<DerivedEMAP>& EMAP,
             const std::vector<std::vector<uE2EType> >& uE2E,
             std::vector<std::vector<uE2oEType> >& uE2oE,
             std::vector<std::vector<uE2CType > >& uE2C );
@@ -93,18 +83,14 @@ namespace igl
     template<
         typename DerivedV,
         typename DerivedF,
-        typename DerivedE,
         typename DeriveduE,
-        typename DerivedEMAP,
         typename uE2EType,
         typename uE2oEType,
         typename uE2CType >
     IGL_INLINE void order_facets_around_edges(
             const Eigen::PlainObjectBase<DerivedV>& V,
             const Eigen::PlainObjectBase<DerivedF>& F,
-            const Eigen::PlainObjectBase<DerivedE>& E,
             const Eigen::PlainObjectBase<DeriveduE>& uE,
-            const Eigen::PlainObjectBase<DerivedEMAP>& EMAP,
             const std::vector<std::vector<uE2EType> >& uE2E,
             std::vector<std::vector<uE2oEType> >& uE2oE,
             std::vector<std::vector<uE2CType > >& uE2C );

include/igl/cgal/outer_facet.cpp

@@ -41,7 +41,7 @@ IGL_INLINE void igl::cgal::outer_facet(
     //    If it has zero normal component, it is facing outside if it contains
     //    directed edge (s, d).  
 
-    typedef typename DerivedV::Scalar Scalar;
+    //typedef typename DerivedV::Scalar Scalar;
     typedef typename DerivedV::Index Index;
 
     Index s,d;

include/igl/cgal/outer_hull.cpp

@@ -48,7 +48,7 @@ IGL_INLINE void igl::cgal::outer_hull(
   typedef typename DerivedF::Index Index;
   Matrix<Index,DerivedF::RowsAtCompileTime,1> C;
   typedef Matrix<typename DerivedV::Scalar,Dynamic,DerivedV::ColsAtCompileTime> MatrixXV;
-  typedef Matrix<typename DerivedF::Scalar,Dynamic,DerivedF::ColsAtCompileTime> MatrixXF;
+  //typedef Matrix<typename DerivedF::Scalar,Dynamic,DerivedF::ColsAtCompileTime> MatrixXF;
   typedef Matrix<typename DerivedG::Scalar,Dynamic,DerivedG::ColsAtCompileTime> MatrixXG;
   typedef Matrix<typename DerivedJ::Scalar,Dynamic,DerivedJ::ColsAtCompileTime> MatrixXJ;
   const Index m = F.rows();
@@ -74,7 +74,7 @@ IGL_INLINE void igl::cgal::outer_hull(
 #endif
   typedef Matrix<typename DerivedF::Scalar,Dynamic,2> MatrixX2I;
   typedef Matrix<typename DerivedF::Index,Dynamic,1> VectorXI;
-  typedef Matrix<typename DerivedV::Scalar, 3, 1> Vector3F;
+  //typedef Matrix<typename DerivedV::Scalar, 3, 1> Vector3F;
   MatrixX2I E,uE;
   VectorXI EMAP;
   vector<vector<typename DerivedF::Index> > uE2E;
@@ -91,7 +91,7 @@ IGL_INLINE void igl::cgal::outer_hull(
 
   std::vector<std::vector<typename DerivedF::Index> > uE2oE;
   std::vector<std::vector<bool> > uE2C;
-  order_facets_around_edges(V, F, E, uE, EMAP, uE2E, uE2oE, uE2C);
+  order_facets_around_edges(V, F, uE, uE2E, uE2oE, uE2C);
   uE2E = uE2oE;
   VectorXI diIM(3*m);
   for (auto ue : uE2E) {

include/igl/cgal/projected_delaunay.cpp

@@ -32,10 +32,10 @@ IGL_INLINE void igl::cgal::projected_delaunay(
   typedef CGAL::Segment_3<Kernel>  Segment_3; 
   typedef CGAL::Triangle_3<Kernel> Triangle_3; 
   typedef CGAL::Plane_3<Kernel>    Plane_3;
-  typedef CGAL::Tetrahedron_3<Kernel> Tetrahedron_3; 
+  //typedef CGAL::Tetrahedron_3<Kernel> Tetrahedron_3; 
   typedef CGAL::Point_2<Kernel>    Point_2;
-  typedef CGAL::Segment_2<Kernel>  Segment_2; 
-  typedef CGAL::Triangle_2<Kernel> Triangle_2; 
+  //typedef CGAL::Segment_2<Kernel>  Segment_2; 
+  //typedef CGAL::Triangle_2<Kernel> Triangle_2; 
   typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
   typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTFB_2;
   typedef CGAL::Triangulation_data_structure_2<TVB_2,CTFB_2> TDS_2;

include/igl/cgal/remesh_intersections.cpp

@@ -40,12 +40,12 @@ IGL_INLINE void igl::cgal::remesh_intersections(
   using namespace Eigen;
   typedef typename DerivedF::Index          Index;
   typedef CGAL::Point_3<Kernel>    Point_3;
-  typedef CGAL::Segment_3<Kernel>  Segment_3; 
-  typedef CGAL::Triangle_3<Kernel> Triangle_3; 
+  //typedef CGAL::Segment_3<Kernel>  Segment_3; 
+  //typedef CGAL::Triangle_3<Kernel> Triangle_3; 
   typedef CGAL::Plane_3<Kernel>    Plane_3;
-  typedef CGAL::Point_2<Kernel>    Point_2;
-  typedef CGAL::Segment_2<Kernel>  Segment_2; 
-  typedef CGAL::Triangle_2<Kernel> Triangle_2; 
+  //typedef CGAL::Point_2<Kernel>    Point_2;
+  //typedef CGAL::Segment_2<Kernel>  Segment_2; 
+  //typedef CGAL::Triangle_2<Kernel> Triangle_2; 
   typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
   typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTFB_2;
   typedef CGAL::Triangulation_data_structure_2<TVB_2,CTFB_2> TDS_2;
@@ -55,9 +55,9 @@ IGL_INLINE void igl::cgal::remesh_intersections(
   typedef CGAL::Constrained_triangulation_plus_2<CDT_2> CDT_plus_2;
   typedef std::pair<Index,Index> EMK;
   typedef std::vector<Index> EMV;
-  typedef std::map<EMK,EMV> EdgeMap;
+  //typedef std::map<EMK,EMV> EdgeMap;
   typedef std::pair<Index,Index> EMK;
-  typedef std::vector<CGAL::Object> ObjectList;
+  //typedef std::vector<CGAL::Object> ObjectList;
   typedef std::vector<Index> IndexList;
 
   int NF_count = 0;

include/igl/outer_element.cpp

@@ -30,17 +30,18 @@ IGL_INLINE void igl::outer_vertex(
   //    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();
+  typedef typename DerivedF::Scalar Index;
+  const Index INVALID = std::numeric_limits<Index>::max();
   const size_t num_selected_faces = I.rows();
   std::vector<size_t> candidate_faces;
-  size_t outer_vid = INVALID;
+  Index 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);
+      Index v = F(f, j);
       auto vx = V(v, 0);
       if (outer_vid == INVALID || vx > outer_val)
       {