Method split_edge

tools/MeshUtils/EdgeSplitter.cpp:113–155

template<typename AdjacencyVector>
void EdgeSplitter::split_edge(const VectorI& edge,
        const AdjacencyVector& adj_faces, Float max_length) {
    const auto v0 = m_vertices.row(edge[0]);
    const auto v1 = m_vertices.row(edge[1]);
    Float length = (v0 - v1).norm();
    if (length < max_length) return;

    bool adj_faces_are_valid = true;
    for (auto fi : adj_faces) {
        adj_faces_are_valid = adj_faces_are_valid && m_face_is_valid[fi];
    }
    if (!adj_faces_are_valid) return;

    const size_t base_v_idx = m_vertices.rows() + m_new_vertices.size();

    std::list<VectorF> edge_vertices = {v0, v1};
    split(edge_vertices, edge_vertices.begin(), length, max_length);
    assert(edge_vertices.size() > 2);

    const auto v_begin = std::next(edge_vertices.begin());
    const auto v_end = std::prev(edge_vertices.end());
    for (auto v_itr = v_begin; v_itr != v_end; v_itr++) {
        m_new_vertices.push_back(*v_itr);
    }

    const size_t num_edge_vertices = edge_vertices.size();
    for (auto fi : adj_faces) {
        const auto& f = m_faces.row(fi);
        size_t opposite_v_id = get_opposite_vertex_index(f, edge[0], edge[1]);
        bool is_correctly_orientated = has_same_orientation(
                f, opposite_v_id, edge[0], edge[1]);
        for (size_t i=0; i<num_edge_vertices-1; i++) {
            size_t curr_idx = i==0 ? edge[0] : i-1 + base_v_idx;
            size_t next_idx = i==num_edge_vertices-2 ? edge[1] : i + base_v_idx;
            if (is_correctly_orientated)
                m_new_faces.emplace_back(opposite_v_id, curr_idx, next_idx);
            else
                m_new_faces.emplace_back(opposite_v_id, next_idx, curr_idx);
        }

        m_face_is_valid[fi] = false;
    }
}

void EdgeSplitter::finalize_geometry() {
    if (m_new_vertices.empty()) {