import_matrix.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_ALGORITHMS_MESH_IMPORT_EXPORT_IMPORT_MATRIX_H
#define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_IMPORT_MATRIX_H
 
#include <vclib/mesh.h>
#include <vclib/space/core.h>
 
namespace vcl {
 
namespace detail {
 
template<MatrixConcept FMatrix>
std::vector<uint> faceVertIndices(const FMatrix& faces, uint f)
{
    std::vector<uint> fVerts;
 
    uint j = 0;
    while (j < faces.cols() && faces(f, j) != -1 && faces(f, j) != UINT_NULL)
        fVerts.push_back(faces(f, j));
 
    return fVerts;
}
 
template<uint ELEM_ID, MeshConcept MeshType, MatrixConcept NMatrix>
void importElementNormalsFromMatrix(MeshType& mesh, const NMatrix& normals)
{
    // The type of the normal of the element
    using NormalType = MeshType::template ElementType<ELEM_ID>::NormalType;
 
    if (normals.cols() != 3)
        throw WrongSizeException(
            "The input " + elementEnumString<ELEM_ID>() +
            " normal matrix must have 3 columns");
 
    // matrix rows must be equal to the number of elements of the given type
    if (normals.rows() != mesh.template number<ELEM_ID>())
        throw WrongSizeException(
            "The input normal matrix must have the same number of rows "
            "as the number of " +
            elementEnumString<ELEM_ID>() + " element in the mesh");
 
    enableIfPerElementComponentOptional<ELEM_ID, CompId::NORMAL>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::NORMAL>(mesh);
 
    uint i = 0;
    for (auto& e : mesh.template elements<ELEM_ID>()) {
        e.normal() = NormalType(normals(i, 0), normals(i, 1), normals(i, 2));
        i++;
    }
}
 
template<uint ELEM_ID, MeshConcept MeshType, MatrixConcept CMatrix>
void importElementColorsFromMatrix(MeshType& mesh, const CMatrix& colors)
{
    using MatrixScalar = CMatrix::Scalar;
 
    if (colors.cols() != 3 && colors.cols() != 4)
        throw WrongSizeException(
            "The input " + elementEnumString<ELEM_ID>() +
            " color matrix must have 3 or 4 columns");
 
    // matrix rows must be equal to the number of elements of the given type
    if (colors.rows() != mesh.template number<ELEM_ID>())
        throw WrongSizeException(
            "The input color matrix must have the same number of rows "
            "as the number of " +
            elementEnumString<ELEM_ID>() + " element in the mesh");
 
    enableIfPerElementComponentOptional<ELEM_ID, CompId::COLOR>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    uint i = 0;
    for (auto& e : mesh.template elements<ELEM_ID>()) {
        // Matrix has colors in range 0-255
        if constexpr (std::integral<MatrixScalar>) {
            if (colors.cols() == 3) {
                e.color() = Color(colors(i, 0), colors(i, 1), colors(i, 2));
            }
            else {
                e.color() = Color(
                    colors(i, 0), colors(i, 1), colors(i, 2), colors(i, 3));
            }
        }
        else { // Matrix has colors in range 0-1
            if (colors.cols() == 3) {
                e.color() = Color(
                    colors(i, 0) * 255, colors(i, 1) * 255, colors(i, 2) * 255);
            }
            else {
                e.color() = Color(
                    colors(i, 0) * 255,
                    colors(i, 1) * 255,
                    colors(i, 2) * 255,
                    colors(i, 3) * 255);
            }
        }
 
        i++;
    }
}
 
} // namespace detail
 
template<
    MeshConcept   MeshType,
    MatrixConcept VMatrix,
    MatrixConcept VNMatrix = Eigen::MatrixX3d>
MeshType pointCloudMeshFromMatrices(
    const VMatrix&  vertices,
    const VNMatrix& vertexNormals = VNMatrix())
{
    MeshType mesh;
 
    importMeshFromMatrices(
        mesh,
        vertices,
        Eigen::MatrixX3i(),
        Eigen::MatrixX2i(),
        vertexNormals,
        Eigen::MatrixX3d());
 
    return mesh;
}
 
template<
    MeshConcept   MeshType,
    MatrixConcept VMatrix,
    MatrixConcept FMatrix  = Eigen::MatrixX3i,
    MatrixConcept VNMatrix = Eigen::MatrixX3d,
    MatrixConcept FNMatrix = Eigen::MatrixX3d>
MeshType meshFromMatrices(
    const VMatrix&  vertices,
    const FMatrix&  faces         = FMatrix(),
    const VNMatrix& vertexNormals = VNMatrix(),
    const FNMatrix& faceNormals   = FNMatrix())
{
    MeshType mesh;
 
    importMeshFromMatrices(
        mesh, vertices, faces, Eigen::MatrixX2i(), vertexNormals, faceNormals);
 
    return mesh;
}
 
template<
    MeshConcept   MeshType,
    MatrixConcept VMatrix,
    MatrixConcept FMatrix  = Eigen::MatrixX3i,
    MatrixConcept EMatrix  = Eigen::MatrixX2i,
    MatrixConcept VNMatrix = Eigen::MatrixX3d,
    MatrixConcept FNMatrix = Eigen::MatrixX3d>
void importMeshFromMatrices(
    MeshType&       mesh,
    const VMatrix&  vertices,
    const FMatrix&  faces         = FMatrix(),
    const EMatrix&  edges         = EMatrix(),
    const VNMatrix& vertexNormals = VNMatrix(),
    const FNMatrix& faceNormals   = FNMatrix())
{
    mesh.clear();
    mesh.disableAllOptionalComponents();
 
    importVerticesFromMatrix(mesh, vertices);
 
    if constexpr (HasPerVertexNormal<MeshType>) {
        if (vertexNormals.rows() > 0) {
            importVertexNormalsFromMatrix(mesh, vertexNormals);
        }
    }
 
    if constexpr (HasFaces<MeshType>) {
        if (faces.rows() > 0)
            importFacesFromMatrix(mesh, faces);
 
        if constexpr (HasPerFaceNormal<MeshType>) {
            if (faceNormals.rows() > 0) {
                importFaceNormalsFromMatrix(mesh, faceNormals);
            }
        }
    }
 
    if constexpr (HasEdges<MeshType>) {
        if (edges.rows() > 0)
            importEdgesFromMatrix(mesh, edges);
    }
}
 
template<MeshConcept MeshType, MatrixConcept VMatrix>
void importVerticesFromMatrix(
    MeshType&      mesh,
    const VMatrix& vertices,
    bool           clearBeforeSet = true)
{
    using PositionType = MeshType::VertexType::PositionType;
 
    if (vertices.cols() != 3)
        throw WrongSizeException("The input vertex matrix must have 3 columns");
 
    if (clearBeforeSet) {
        mesh.clearVertices();
        mesh.resizeVertices(vertices.rows());
    }
    else {
        if (vertices.rows() != mesh.vertexNumber()) {
            throw WrongSizeException(
                "The input vertex matrix has a different number of rows than "
                "the number of vertices of the mesh");
        }
    }
 
    uint i = 0;
    for (auto& v : mesh.vertices()) {
        v.position() =
            PositionType(vertices(i, 0), vertices(i, 1), vertices(i, 2));
        i++;
    }
}
 
template<FaceMeshConcept MeshType, MatrixConcept FMatrix>
void importFacesFromMatrix(
    MeshType&      mesh,
    const FMatrix& faces,
    bool           clearBeforeSet = true)
{
    if (clearBeforeSet) {
        mesh.clearFaces();
        mesh.resizeFaces(faces.rows());
    }
    else {
        if (faces.rows() != mesh.faceNumber()) {
            throw WrongSizeException(
                "The input face matrix has a different number of rows "
                "than the number of faces of the mesh.");
        }
    }
 
    if constexpr (HasPolygons<MeshType>) {
        uint i = 0;
        for (auto& f : mesh.faces()) {
            uint vertexNumber = 0;
 
            // count the number of vertices of the face
            while (vertexNumber < faces.cols() &&
                   faces(i, vertexNumber) != -1 &&
                   faces(i, vertexNumber) != UINT_NULL)
                vertexNumber++;
 
            f.resizeVertices(vertexNumber);
 
            for (uint j = 0; j < vertexNumber; ++j)
                f.setVertex(j, faces(i, j));
            ++i;
        }
    }
    else { // the vertex number of mesh faces is fixed
        using FaceType = MeshType::FaceType;
 
        constexpr int VN = FaceType::VERTEX_NUMBER;
        if (faces.cols() == VN) { // faces of matrix and mesh have same size
            uint i = 0;
            for (auto& f : mesh.faces()) {
                for (uint j = 0; j < VN; ++j)
                    f.setVertex(j, faces(i, j));
                ++i;
            }
        }
        else { // faces of matrix and mesh have different sizes
            // matrix cols is higher than 3 (polygons), but we have a triangle
            // mesh and we can triangulate the faces
            if constexpr (VN == 3) {
                if (!clearBeforeSet) {
                    throw WrongSizeException(
                        "Cannot import the input face matrix into the mesh "
                        "without clearing the face container first "
                        "(need to perform a triangulation to import polygons "
                        "in a triangle mesh, and this operation that does not "
                        "guarantee a predefined number of faces is required).");
                }
                mesh.reserveFaces(faces.rows());
                for (uint i = 0; i < faces.rows(); ++i) {
                    std::vector<uint> fVertIndices =
                        detail::faceVertIndices(faces, i);
 
                    addTriangleFacesFromPolygon(mesh, fVertIndices);
                }
            }
            else {
                // no triangulation available because VN != 3, we don't
                // know how to import the faces and we throw an exception
                throw WrongSizeException(
                    "The input face matrix has a different number of columns "
                    "than the number of vertices of the mesh faces.");
            }
        }
    }
}
 
template<EdgeMeshConcept MeshType, MatrixConcept EMatrix>
void importEdgesFromMatrix(
    MeshType&      mesh,
    const EMatrix& edges,
    bool           clearBeforeSet = true)
{
    if (edges.cols() != 2)
        throw WrongSizeException("The input edge matrix must have 2 columns");
 
    if (clearBeforeSet) {
        mesh.clearEdges();
        mesh.resizeEdges(edges.rows());
    }
    else {
        if (edges.rows() != mesh.edgeNumber()) {
            throw WrongSizeException(
                "The input edge matrix has a different number of rows than "
                "the number of edges of the mesh");
        }
    }
 
    uint i = 0;
    for (auto& e : mesh.edges()) {
        e.setVertex(0, edges(i, 0));
        e.setVertex(1, edges(i, 1));
        i++;
    }
}
 
template<MeshConcept MeshType, MatrixConcept VNMatrix>
void importVertexNormalsFromMatrix(
    MeshType&       mesh,
    const VNMatrix& vertexNormals)
{
    detail::importElementNormalsFromMatrix<ElemId::VERTEX>(mesh, vertexNormals);
}
 
template<FaceMeshConcept MeshType, MatrixConcept FNMatrix>
void importFaceNormalsFromMatrix(MeshType& mesh, const FNMatrix& faceNormals)
{
    detail::importElementNormalsFromMatrix<ElemId::FACE>(mesh, faceNormals);
}
 
template<MeshConcept MeshType, MatrixConcept VCMatrix>
void importVertexColorsFromMatrix(MeshType& mesh, const VCMatrix& vertexColors)
{
    detail::importElementColorsFromMatrix<ElemId::VERTEX>(mesh, vertexColors);
}
 
template<FaceMeshConcept MeshType, MatrixConcept FCMatrix>
void importFaceColorsFromMatrix(MeshType& mesh, const FCMatrix& faceColors)
{
    detail::importElementColorsFromMatrix<ElemId::FACE>(mesh, faceColors);
}
 
template<EdgeMeshConcept MeshType, MatrixConcept ECMatrix>
void importEdgeColorsFromMatrix(MeshType& mesh, const ECMatrix& edgeColors)
{
    detail::importElementColorsFromMatrix<ElemId::EDGE>(mesh, edgeColors);
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_IMPORT_MATRIX_H