Method compute_vertex_normals_from_edge

src/Attributes/VertexNormalAttribute.cpp:55–93

}

void VertexNormalAttribute::compute_vertex_normals_from_edge(Mesh& mesh) {
    const size_t dim = mesh.get_dim();
    assert(dim == 2);
    const size_t num_vertices = mesh.get_num_vertices();
    const size_t num_faces = mesh.get_num_faces();
    const size_t vertex_per_face = mesh.get_vertex_per_face();

    const VectorF& normals = get_attribute(mesh, "face_normal");

    VectorF& v_normals = m_values;
    v_normals = VectorF::Zero(dim * num_vertices);

    for (size_t i=0; i<num_faces; i++) {
        VectorI face = mesh.get_face(i);
        for (size_t j=0; j<vertex_per_face; j++) {
            size_t prev = (j-1+vertex_per_face) % vertex_per_face;
            size_t next = (j+1) % vertex_per_face;
            Vector2F prev_edge = mesh.get_vertex(face[j]) -
                mesh.get_vertex(face[prev]);
            Vector2F next_edge = mesh.get_vertex(face[next]) -
                mesh.get_vertex(face[j]);

            Vector3F n = normals.segment(i*3, 3);
            Vector3F e1(prev_edge[0], prev_edge[1], 0);
            Vector3F e2(next_edge[0], next_edge[1], 0);
            Vector3F n1 = e1.cross(n);
            Vector3F n2 = e2.cross(n);

            v_normals.segment(face[j]*dim, dim) += (n1 + n2).segment(0, dim);
        }
    }

    for (size_t i=0; i<num_vertices; i++) {
        Float norm = v_normals.segment(i*dim, dim).norm();
        if (norm > 1e-6) {
            v_normals.segment(i*dim, dim) /= norm;
        }
    }
}

const VectorF& VertexNormalAttribute::get_attribute(Mesh& mesh, const std::string& attr_name) {
    if (!mesh.has_attribute(attr_name)) {