Method handle_intersection_candidate

tools/CGAL/SelfIntersection.cpp:121–206

}

void SelfIntersection::handle_intersection_candidate(
        size_t f_idx_1, size_t f_idx_2) {
    auto duplicated_vertices = topological_overlap(f_idx_1, f_idx_2);
    const Vector3I f1 = m_faces.row(f_idx_1);
    const Vector3I f2 = m_faces.row(f_idx_2);
    const Triangle_3 t1(m_points[f1[0]], m_points[f1[1]], m_points[f1[2]]);
    const Triangle_3 t2(m_points[f2[0]], m_points[f2[1]], m_points[f2[2]]);

    bool is_intersecting = false;
    const size_t num_duplicated_vertices = duplicated_vertices.size();
    switch (num_duplicated_vertices) {
        case 0:
            // triangles do not touch.
            {
                bool t1_degenerate = t1.is_degenerate();
                bool t2_degenerate = t2.is_degenerate();
                if (t1_degenerate || t2_degenerate) {
                    // Degenerated triangles are considered as
                    // self-intersecting.
                    is_intersecting = true;
                } else {
                    is_intersecting = CGAL::do_intersect(t1, t2);
                }
            }
            break;
        case 3:
            // duplicated face
            is_intersecting = true;
            break;
        case 1:
            {
                // touch at a vertex.
                size_t shared_vertex = duplicated_vertices[0];
                Vector2I opp_edge_1 = get_opposite_edge(f1, shared_vertex);
                Vector2I opp_edge_2 = get_opposite_edge(f2, shared_vertex);
                Segment_3 seg_1(m_points[opp_edge_1[0]], m_points[opp_edge_1[1]]);
                Segment_3 seg_2(m_points[opp_edge_2[0]], m_points[opp_edge_2[1]]);
                is_intersecting =
                    CGAL::do_intersect(t1, seg_2) ||
                    CGAL::do_intersect(t2, seg_1);
            }
            break;
        case 2:
            {
                // touch at an edge.
                Vector2I shared_edge(duplicated_vertices[0],
                        duplicated_vertices[1]);
                size_t v1 = get_opposite_vertex(f1, shared_edge);
                size_t v2 = get_opposite_vertex(f2, shared_edge);
                const auto& p1 = m_points[v1];
                const auto& p2 = m_points[v2];
                const auto& p3 = m_points[shared_edge[0]];
                const auto& p4 = m_points[shared_edge[1]];
                if (CGAL::coplanar(p1, p2, p3, p4)) {
                    if (CGAL::collinear(p3, p4, p1)) {
                        is_intersecting = true;
                    } else if (CGAL::collinear(p3, p4, p2)) {
                        is_intersecting = true;