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 "import_buffer.h"
 
#include <vclib/mesh.h>
#include <vclib/space/core.h>
 
namespace vcl {
 
template<
    MeshConcept   MeshType,
    MatrixConcept VMatrix,
    MatrixConcept FMatrix = Eigen::MatrixX3i,
    MatrixConcept EMatrix = Eigen::MatrixX2i>
MeshType meshFromMatrices(
    const VMatrix& vertices,
    const FMatrix& faces = FMatrix(),
    const EMatrix& edges = EMatrix())
{
    MeshType mesh;
 
    meshFromMatrices(mesh, vertices, faces, edges);
 
    return mesh;
}
 
template<
    MeshConcept   MeshType,
    MatrixConcept VMatrix,
    MatrixConcept FMatrix = Eigen::MatrixX3i,
    MatrixConcept EMatrix = Eigen::MatrixX2i>
void meshFromMatrices(
    MeshType&      mesh,
    const VMatrix& vertices,
    const FMatrix& faces = FMatrix(),
    const EMatrix& edges = EMatrix())
{
    mesh.clear();
    mesh.disableAllOptionalComponents();
 
    vertexPositionsFromMatrix(mesh, vertices);
 
    if constexpr (HasFaces<MeshType>) {
        if (faces.rows() > 0)
            faceIndicesFromMatrix(mesh, faces);
    }
 
    if constexpr (HasEdges<MeshType>) {
        if (edges.rows() > 0)
            edgeIndicesFromMatrix(mesh, edges);
    }
}
 
template<MeshConcept MeshType, MatrixConcept VMatrix>
void vertexPositionsFromMatrix(
    MeshType&      mesh,
    const VMatrix& vertices,
    bool           clearBeforeSet = true)
{
    if (vertices.cols() != 3)
        throw WrongSizeException("The input vertex matrix must have 3 columns");
 
    MatrixStorageType stg = matrixStorageType<VMatrix>();
 
    vertexPositionsFromBuffer(
        mesh, vertices.data(), vertices.rows(), clearBeforeSet, stg);
}
 
template<FaceMeshConcept MeshType, MatrixConcept FMatrix>
void faceIndicesFromMatrix(
    MeshType&      mesh,
    const FMatrix& faces,
    bool           clearBeforeSet = true)
{
    MatrixStorageType stg = matrixStorageType<FMatrix>();
 
    faceIndicesFromBuffer(
        mesh, faces.data(), faces.rows(), faces.cols(), clearBeforeSet, stg);
}
 
template<EdgeMeshConcept MeshType, MatrixConcept EMatrix>
void edgeIndicesFromMatrix(
    MeshType&      mesh,
    const EMatrix& edges,
    bool           clearBeforeSet = true)
{
    if (edges.cols() != 2)
        throw WrongSizeException("The input edge matrix must have 2 columns");
 
    MatrixStorageType stg = matrixStorageType<EMatrix>();
 
    edgeIndicesFromBuffer(
        mesh, edges.data(), edges.rows(), clearBeforeSet, stg);
}
 
template<uint ELEM_ID, MeshConcept MeshType, Range R>
void elementSelectionFromRange(MeshType& mesh, R&& selection)
{
    if (std::ranges::size(selection) != mesh.template number<ELEM_ID>())
        throw WrongSizeException(
            "The input selection range must have the same number of elements "
            "as the number of " +
            elementEnumString<ELEM_ID>() + " element in the mesh");
 
    auto s = selection.begin();
    for (auto& e : mesh.template elements<ELEM_ID>()) {
        e.selected() = *s;
        ++s;
    }
}
 
template<MeshConcept MeshType, Range R>
void vertexSelectionFromRange(MeshType& mesh, R&& selection)
{
    elementSelectionFromRange<ElemId::VERTEX>(mesh, selection);
}
 
template<FaceMeshConcept MeshType, Range R>
void faceSelectionFromRange(MeshType& mesh, R&& selection)
{
    elementSelectionFromRange<ElemId::FACE>(mesh, selection);
}
 
template<EdgeMeshConcept MeshType, Range R>
void edgeSelectionFromRange(MeshType& mesh, R&& selection)
{
    elementSelectionFromRange<ElemId::EDGE>(mesh, selection);
}
 
template<uint ELEM_ID, MeshConcept MeshType, MatrixConcept NMatrix>
void elementNormalsFromMatrix(MeshType& mesh, const NMatrix& normals)
{
    MatrixStorageType stg = matrixStorageType<NMatrix>();
 
    if (normals.cols() != 3)
        throw WrongSizeException(
            "The input " + elementEnumString<ELEM_ID>() +
            " normal matrix must have 3 columns");
 
    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>() + " elements in the mesh");
 
    elementNormalsFromBuffer<ELEM_ID>(mesh, normals.data(), stg);
}
 
template<MeshConcept MeshType, MatrixConcept VNMatrix>
void vertexNormalsFromMatrix(MeshType& mesh, const VNMatrix& vertexNormals)
{
    elementNormalsFromMatrix<ElemId::VERTEX>(mesh, vertexNormals);
}
 
template<FaceMeshConcept MeshType, MatrixConcept FNMatrix>
void faceNormalsFromMatrix(MeshType& mesh, const FNMatrix& faceNormals)
{
    elementNormalsFromMatrix<ElemId::FACE>(mesh, faceNormals);
}
 
template<EdgeMeshConcept MeshType, MatrixConcept ENMatrix>
void edgeNormalsFromMatrix(MeshType& mesh, const ENMatrix& edgeNormals)
{
    elementNormalsFromMatrix<ElemId::EDGE>(mesh, edgeNormals);
}
 
template<uint ELEM_ID, MeshConcept MeshType, MatrixConcept CMatrix>
void elementColorsFromMatrix(MeshType& mesh, const CMatrix& colors)
{
    using MatrixScalar = CMatrix::Scalar;
 
    Color::Representation repr = std::integral<MatrixScalar> ?
                                     Color::Representation::INT_0_255 :
                                     Color::Representation::FLOAT_0_1;
 
    if (colors.rows() != mesh.template number<ELEM_ID>())
        throw WrongSizeException(
            "The input colors matrix must have the same number of rows as the "
            "number of " +
            elementEnumString<ELEM_ID>() + " elements in the mesh");
 
    elementColorsFromBuffer<ELEM_ID>(
        mesh, colors.data(), colors.cols(), matrixStorageType<CMatrix>(), repr);
}
 
template<uint ELEM_ID, MeshConcept MeshType, Range R>
void elementColorsFromRange(
    MeshType&     mesh,
    R&&           colors,
    Color::Format colorFormat)
{
    if (std::ranges::size(colors) != mesh.template number<ELEM_ID>())
        throw WrongSizeException(
            "The input color range must have the same number of elements "
            "as the number of " +
            elementEnumString<ELEM_ID>() + " element in the mesh");
 
    enableIfPerElementComponentOptional<ELEM_ID, CompId::COLOR>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    auto c = colors.begin();
    for (auto& e : mesh.template elements<ELEM_ID>()) {
        e.color() = Color(*c, colorFormat);
        ++c;
    }
}
 
template<MeshConcept MeshType, MatrixConcept VCMatrix>
void vertexColorsFromMatrix(MeshType& mesh, const VCMatrix& vertexColors)
{
    elementColorsFromMatrix<ElemId::VERTEX>(mesh, vertexColors);
}
 
template<MeshConcept MeshType, Range R>
void vertexColorsFromRange(
    MeshType&     mesh,
    R&&           colors,
    Color::Format colorFormat)
{
    elementColorsFromRange<ElemId::VERTEX>(mesh, colors, colorFormat);
}
 
template<FaceMeshConcept MeshType, MatrixConcept FCMatrix>
void faceColorsFromMatrix(MeshType& mesh, const FCMatrix& faceColors)
{
    elementColorsFromMatrix<ElemId::FACE>(mesh, faceColors);
}
 
template<FaceMeshConcept MeshType, Range R>
void faceColorsFromRange(MeshType& mesh, R&& colors, Color::Format colorFormat)
{
    elementColorsFromRange<ElemId::FACE>(mesh, colors, colorFormat);
}
 
template<EdgeMeshConcept MeshType, MatrixConcept ECMatrix>
void edgeColorsFromMatrix(MeshType& mesh, const ECMatrix& edgeColors)
{
    elementColorsFromMatrix<ElemId::EDGE>(mesh, edgeColors);
}
 
template<EdgeMeshConcept MeshType, Range R>
void edgeColorsFromRange(MeshType& mesh, R&& colors, Color::Format colorFormat)
{
    elementColorsFromRange<ElemId::EDGE>(mesh, colors, colorFormat);
}
 
template<uint ELEM_ID, MeshConcept MeshType, Range R>
void elementQualityFromRange(MeshType& mesh, R&& quality)
{
    if (std::ranges::size(quality) != mesh.template number<ELEM_ID>())
        throw WrongSizeException(
            "The input quality range must have the same number of elements "
            "as the number of " +
            elementEnumString<ELEM_ID>() + " element in the mesh");
 
    enableIfPerElementComponentOptional<ELEM_ID, CompId::QUALITY>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::QUALITY>(mesh);
 
    auto q = quality.begin();
    for (auto& e : mesh.template elements<ELEM_ID>()) {
        e.quality() = *q;
        ++q;
    }
}
 
template<MeshConcept MeshType, Range R>
void vertexQualityFromRange(MeshType& mesh, R&& quality)
{
    elementQualityFromRange<ElemId::VERTEX>(mesh, quality);
}
 
template<FaceMeshConcept MeshType, Range R>
void faceQualityFromRange(MeshType& mesh, R&& quality)
{
    elementQualityFromRange<ElemId::FACE>(mesh, quality);
}
 
template<EdgeMeshConcept MeshType, Range R>
void edgeQualityFromRange(MeshType& mesh, R&& quality)
{
    elementQualityFromRange<ElemId::EDGE>(mesh, quality);
}
 
template<MeshConcept MeshType, MatrixConcept VTMatrix>
void vertexTexCoordsFromMatrix(MeshType& mesh, const VTMatrix& vertexTexCoords)
{
    MatrixStorageType stg = matrixStorageType<VTMatrix>();
 
    if (vertexTexCoords.cols() != 2)
        throw WrongSizeException(
            "The input vertex texcoords matrix must have 2 columns");
 
    if (vertexTexCoords.rows() != mesh.vertexNumber())
        throw WrongSizeException(
            "The input vertex texcoords must have the same number of rows as "
            "the number of vertices in the mesh");
 
    vertexTexCoordsFromBuffer(mesh, vertexTexCoords.data(), stg);
}
 
template<MeshConcept MeshType, Range R>
void vertexMaterialIndicesFromRange(MeshType& mesh, R&& materialIndices)
{
    if (std::ranges::size(materialIndices) != mesh.vertexNumber())
        throw WrongSizeException(
            "The input quality range must have the same number of elements "
            "as the number of vertices in the mesh");
 
    enableIfPerVertexMaterialIndexOptional(mesh);
    requirePerVertexMaterialIndex(mesh);
 
    auto tt = materialIndices.begin();
    for (auto& v : mesh.vertices()) {
        v.materialIndex() = *tt;
        ++tt;
    }
}
 
template<FaceMeshConcept MeshType, MatrixConcept FTMatrix>
void faceWedgeTexCoordsFromMatrix(
    MeshType&       mesh,
    const FTMatrix& faceWedgeTexCoords)
{
    MatrixStorageType stg = matrixStorageType<FTMatrix>();
 
    if (faceWedgeTexCoords.rows() != mesh.faceNumber())
        throw WrongSizeException(
            "The input face wedge texcoords must have the same number of rows "
            "as the number of faces in the mesh");
 
    faceWedgeTexCoordsFromBuffer(
        mesh, faceWedgeTexCoords.data(), faceWedgeTexCoords.cols() / 2, stg);
}
 
template<FaceMeshConcept MeshType, Range R>
void faceMaterialIndicesFromRange(MeshType& mesh, R&& texCoordIndices)
{
    if (std::ranges::size(texCoordIndices) != mesh.faceNumber())
        throw WrongSizeException(
            "The input quality range must have the same number of elements "
            "as the number of faces in the mesh");
 
    enableIfPerFaceMaterialIndexOptional(mesh);
    requirePerFaceMaterialIndex(mesh);
 
    auto tt = texCoordIndices.begin();
    for (auto& f : mesh.faces()) {
        f.materialIndex() = *tt;
        ++tt;
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_IMPORT_MATRIX_H