IGL_INLINE void igl::copyleft::cgal::outer_facet( const Eigen::PlainObjectBase<DerivedV> & V, const Eigen::PlainObjectBase<DerivedF> & F, const Eigen::PlainObjectBase<DerivedI> & I, IndexType & f, bool & flipped) { // Algorithm: // // 1. Find an outer edge (s, d). // // 2. Order adjacent facets around this edge. Because the edge is an // outer edge, there exists a plane passing through it such that all its // adjacent facets lie on the same side. The implementation of // order_facets_around_edge() will find a natural start facet such that // The first and last facets according to this order are on the outside. // // 3. Because the vertex s is an outer vertex by construction (see // implemnetation of outer_edge()). The first adjacent facet is facing // outside (i.e. flipped=false) if it has positive X normal component. // 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::Index Index; Index s,d; Eigen::Matrix<Index,Eigen::Dynamic,1> incident_faces; outer_edge(V, F, I, s, d, incident_faces); assert(incident_faces.size() > 0); auto convert_to_signed_index = [&](size_t fid) -> int{ if ((F(fid, 0) == s && F(fid, 1) == d) || (F(fid, 1) == s && F(fid, 2) == d) || (F(fid, 2) == s && F(fid, 0) == d) ) { return int(fid+1) * -1; } else { return int(fid+1); } }; auto signed_index_to_index = [&](int signed_id) -> size_t { return size_t(abs(signed_id) - 1); }; std::vector<int> adj_faces(incident_faces.size()); std::transform(incident_faces.data(), incident_faces.data() + incident_faces.size(), adj_faces.begin(), convert_to_signed_index); DerivedV pivot_point = V.row(s); pivot_point(0, 0) += 1.0; Eigen::VectorXi order; order_facets_around_edge(V, F, s, d, adj_faces, pivot_point, order); f = signed_index_to_index(adj_faces[order[0]]); flipped = adj_faces[order[0]] > 0; }
IGL_INLINE void igl::copyleft::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); assert(pivot_point.cols() == 3); auto signed_index_to_index = [&](int signed_idx) { return abs(signed_idx) -1; }; auto get_opposite_vertex_index = [&](size_t fid) -> typename DerivedF::Scalar { 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; }; { // Check if s, d and pivot are collinear. typedef CGAL::Exact_predicates_exact_constructions_kernel K; K::Point_3 ps(V(s,0), V(s,1), V(s,2)); K::Point_3 pd(V(d,0), V(d,1), V(d,2)); K::Point_3 pp(pivot_point(0,0), pivot_point(0,1), pivot_point(0,2)); if (CGAL::collinear(ps, pd, pp)) { throw std::runtime_error( "Pivot point is collinear with the outer edge!"); } } const size_t N = adj_faces.size(); const size_t num_faces = N + 1; // N adj faces + 1 pivot face // Because face indices are used for tie breaking, the original face indices // in the new faces array must be ascending. auto comp = [&](int i, int j) { return signed_index_to_index(adj_faces[i]) < signed_index_to_index(adj_faces[j]); }; std::vector<size_t> adj_order(N); for (size_t i=0; i<N; i++) adj_order[i] = i; std::sort(adj_order.begin(), adj_order.end(), comp); DerivedV vertices(num_faces + 2, 3); for (size_t i=0; i<N; i++) { const size_t fid = signed_index_to_index(adj_faces[adj_order[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<N; i++) { if (adj_faces[adj_order[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 ((size_t)faces(i,0) == N+1 && (size_t)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; order_facets_around_edge( vertices, faces, N+1, N+2, adj_faces_with_pivot, order_with_pivot); assert((size_t)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 ((size_t)order_with_pivot[i] == N) { pivot_index = i; break; } } assert(pivot_index < num_faces); for (size_t i=0; i<N; i++) { order[i] = adj_order[order_with_pivot[(pivot_index+i+1)%num_faces]]; } }
void igl::copyleft::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, bool debug) { // 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; order(1, 0) = 1; break; case CGAL::COPLANAR: { switch (CGAL::coplanar_orientation(ps, pd, p1, p2)) { case CGAL::POSITIVE: // 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; break; case CGAL::NEGATIVE: // 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; case CGAL::COLLINEAR: std::cerr << "Degenerated triangle detected." << std::endl; assert(false); break; default: assert(false); } } break; default: assert(false); } 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); if (separator.is_degenerate()) { throw std::runtime_error( "Cannot order facets around edge due to degenerated facets"); } 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: { auto inplane_orientation = CGAL::coplanar_orientation( p_s, p_d, p_o, p_a); switch (inplane_orientation) { case CGAL::POSITIVE: tie_positive_oriented.push_back(f); tie_positive_oriented_index.push_back(i); break; case CGAL::NEGATIVE: tie_negative_oriented.push_back(f); tie_negative_oriented_index.push_back(i); break; case CGAL::COLLINEAR: default: throw std::runtime_error( "Degenerated facet detected."); break; } } break; default: // Should not be here. throw std::runtime_error("Unknown CGAL state detected."); } } if (debug) { std::cout << "tie positive: " << std::endl; for (auto& f : tie_positive_oriented) { std::cout << get_face_index(f) << " "; } std::cout << std::endl; std::cout << "positive side: " << std::endl; for (auto& f : positive_side) { std::cout << get_face_index(f) << " "; } std::cout << std::endl; std::cout << "tie negative: " << std::endl; for (auto& f : tie_negative_oriented) { std::cout << get_face_index(f) << " "; } std::cout << std::endl; std::cout << "negative side: " << std::endl; for (auto& f : negative_side) { std::cout << get_face_index(f) << " "; } std::cout << std::endl; } auto index_sort = [](std::vector<int>& data) -> std::vector<size_t>{ 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; }; Eigen::PlainObjectBase<DerivedI> positive_order, negative_order; order_facets_around_edge(V, F, s, d, positive_side, positive_order, debug); order_facets_around_edge(V, F, s, d, negative_side, negative_order, debug); 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); } }