export_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_EXPORT_MATRIX_H
#define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_MATRIX_H
 
#include "export_buffer.h"
 
#include <vclib/algorithms/mesh/stat/topology.h>
 
#include <vclib/mesh.h>
#include <vclib/space/core.h>
 
namespace vcl {
 
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexPositionsMatrix(const MeshType& mesh)
{
    Matrix vM(mesh.vertexNumber(), 3);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    vertexPositionsToBuffer(mesh, vM.data(), stg);
 
    return vM;
}
 
template<typename Vect, FaceMeshConcept MeshType>
Vect faceSizesVector(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    Vect fM(mesh.faceNumber());
 
    faceSizesToBuffer(mesh, fM.data());
 
    return fM;
}
 
template<typename Vect, FaceMeshConcept MeshType>
Vect faceVertexIndicesVector(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    uint nIndices = countPerFaceVertexReferences(mesh);
 
    Vect fV(nIndices);
 
    faceVertexIndicesToBuffer(mesh, fV.data());
 
    return fV;
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceVertexIndicesMatrix(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    uint fMaxSize = largestFaceSize(mesh);
 
    Matrix fM(mesh.faceNumber(), fMaxSize);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    faceVertexIndicesToBuffer(mesh, fM.data(), fMaxSize, stg);
 
    return fM;
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix triangulatedFaceVertexIndicesMatrix(
    const MeshType&    mesh,
    TriPolyIndexBiMap& indexMap = detail::indexMap)
{
    requireVertexContainerCompactness(mesh);
 
    uint tNumber = vcl::countTriangulatedTriangles(mesh);
 
    Matrix tM(tNumber, 3);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    triangulatedFaceVertexIndicesToBuffer(
        mesh, tM.data(), indexMap, stg, tNumber);
 
    return tM;
}
 
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix edgeVertexIndicesMatrix(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    Matrix eM(mesh.edgeNumber(), 2);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    edgeVertexIndicesToBuffer(mesh, eM.data(), stg);
 
    return eM;
}
 
template<uint ELEM_ID, typename Vect, MeshConcept MeshType>
Vect elementSelectionVector(const MeshType& mesh)
{
    Vect sV(mesh.template number<ELEM_ID>());
 
    vcl::elementSelectionToBuffer<ELEM_ID>(mesh, sV.data());
    return sV;
}
 
template<typename Vect, MeshConcept MeshType>
Vect vertexSelectionVector(const MeshType& mesh)
{
    return elementSelectionVector<ElemId::VERTEX, Vect>(mesh);
}
 
template<typename Vect, FaceMeshConcept MeshType>
Vect faceSelectionVector(const MeshType& mesh)
{
    return elementSelectionVector<ElemId::FACE, Vect>(mesh);
}
 
template<typename Vect, EdgeMeshConcept MeshType>
Vect edgeSelectionVector(const MeshType& mesh)
{
    return elementSelectionVector<ElemId::EDGE, Vect>(mesh);
}
 
template<uint ELEM_ID, MatrixConcept Matrix, MeshConcept MeshType>
Matrix elementNormalsMatrix(const MeshType& mesh)
{
    Matrix eNM(mesh.template number<ELEM_ID>(), 3);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    elementNormalsToBuffer<ELEM_ID>(mesh, eNM.data(), stg);
 
    return eNM;
}
 
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexNormalsMatrix(const MeshType& mesh)
{
    return elementNormalsMatrix<ElemId::VERTEX, Matrix>(mesh);
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceNormalsMatrix(const MeshType& mesh)
{
    return elementNormalsMatrix<ElemId::FACE, Matrix>(mesh);
}
 
template<uint ELEM_ID, MatrixConcept Matrix, MeshConcept MeshType>
Matrix elementColorsMatrix(const MeshType& mesh)
{
    Matrix eCM(mesh.template number<ELEM_ID>(), 4);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    elementColorsToBuffer<ELEM_ID>(mesh, eCM.data(), stg);
 
    return eCM;
}
 
template<uint ELEM_ID, typename Vect, MeshConcept MeshType>
Vect elementColorsVector(const MeshType& mesh, Color::Format colorFormat)
{
    Vect eCV(mesh.template number<ELEM_ID>());
 
    elementColorsToBuffer<ELEM_ID>(mesh, eCV.data(), colorFormat);
 
    return eCV;
}
 
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexColorsMatrix(const MeshType& mesh)
{
    return elementColorsMatrix<ElemId::VERTEX, Matrix>(mesh);
}
 
template<typename Vect, MeshConcept MeshType>
Vect vertexColorsVector(const MeshType& mesh, Color::Format colorFormat)
{
    return elementColorsVector<ElemId::VERTEX, Vect>(mesh, colorFormat);
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceColorsMatrix(const MeshType& mesh)
{
    return elementColorsMatrix<ElemId::FACE, Matrix>(mesh);
}
 
template<typename Vect, MeshConcept MeshType>
Vect faceColorsVector(const MeshType& mesh, Color::Format colorFormat)
{
    return elementColorsVector<ElemId::FACE, Vect>(mesh, colorFormat);
}
 
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix edgeColorsMatrix(const MeshType& mesh)
{
    return elementColorsMatrix<ElemId::EDGE, Matrix>(mesh);
}
 
template<typename Vect, MeshConcept MeshType>
Vect edgeColorsVector(const MeshType& mesh, Color::Format colorFormat)
{
    return elementColorsVector<ElemId::EDGE, Vect>(mesh, colorFormat);
}
 
template<uint ELEM_ID, typename Vect, MeshConcept MeshType>
Vect elementQualityVector(const MeshType& mesh)
{
    Vect eQV(mesh.template number<ELEM_ID>());
 
    elementQualityToBuffer<ELEM_ID>(mesh, eQV.data());
 
    return eQV;
}
 
template<typename Vect, MeshConcept MeshType>
Vect vertexQualityVector(const MeshType& mesh)
{
    return elementQualityVector<ElemId::VERTEX, Vect>(mesh);
}
 
template<typename Vect, FaceMeshConcept MeshType>
Vect faceQualityVector(const MeshType& mesh)
{
    return elementQualityVector<ElemId::FACE, Vect>(mesh);
}
 
template<typename Vect, EdgeMeshConcept MeshType>
Vect edgeQualityVector(const MeshType& mesh)
{
    return elementQualityVector<ElemId::EDGE, Vect>(mesh);
}
 
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexTexCoordsMatrix(const MeshType& mesh)
{
    Matrix vTCM(mesh.vertexNumber(), 2);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    vertexTexCoordsToBuffer(mesh, vTCM.data(), stg);
 
    return vTCM;
}
 
template<typename Vect, MeshConcept MeshType>
Vect vertexMaterialIndicesVector(const MeshType& mesh)
{
    Vect vTCI(mesh.vertexNumber());
 
    vertexMaterialIndicesToBuffer(mesh, vTCI.data());
 
    return vTCI;
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceWedgeTexCoordsMatrix(const MeshType& mesh)
{
    uint lfs = vcl::largestFaceSize(mesh);
 
    Matrix fTCM(mesh.faceNumber(), lfs * 2);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    faceWedgeTexCoordsToBuffer(mesh, fTCM.data(), lfs, stg);
 
    return fTCM;
}
 
template<typename Vect, FaceMeshConcept MeshType>
Vect faceMaterialIndicesVector(const MeshType& mesh)
{
    Vect fTCI(mesh.faceNumber());
 
    faceMaterialIndicesToBuffer(mesh, fTCI.data());
 
    return fTCI;
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    MeshConcept MeshType>
Container<Container<T>> vertexAdjacentVerticesVectors(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
    requirePerVertexAdjacentVertices(mesh);
 
    Container<Container<T>> vv(mesh.vertexNumber());
 
    auto vvIt = vv.begin();
    for (const auto& v : mesh.vertices()) {
        auto& vec = *vvIt;
 
        vec.resize(v.adjVerticesNumber());
        auto vecIt = vec.begin();
        for (const auto* ve : v.adjVertices()) {
            uint idx = ve ? ve->index() : UINT_NULL;
            *vecIt   = T(idx);
            ++vecIt;
        }
 
        ++vvIt;
    }
 
    return vv;
}
 
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexAdjacentVerticesMatrix(const MeshType& mesh)
{
    uint lva = vcl::largestPerVertexAdjacentVerticesNumber(mesh);
 
    Matrix vAVM(mesh.vertexNumber(), lva);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    vertexAdjacentVerticesToBuffer(mesh, vAVM.data(), lva, stg);
 
    return vAVM;
}
 
template<
    uint ELEM_ID,
    template<typename, typename...>
    typename Container,
    typename T,
    FaceMeshConcept MeshType>
Container<Container<T>> elementAdjacentFacesVectors(const MeshType& mesh)
{
    requireFaceContainerCompactness(mesh);
    requirePerElementComponent<ELEM_ID, CompId::ADJACENT_FACES>(mesh);
 
    Container<Container<T>> vv(mesh.template number<ELEM_ID>());
 
    auto vvIt = vv.begin();
    for (const auto& v : mesh.template elements<ELEM_ID>()) {
        auto& vec = *vvIt;
 
        vec.resize(v.adjFacesNumber());
        auto vecIt = vec.begin();
        for (const auto* fe : v.adjFaces()) {
            uint idx = fe ? fe->index() : UINT_NULL;
            *vecIt   = T(idx);
            ++vecIt;
        }
 
        ++vvIt;
    }
 
    return vv;
}
 
template<uint ELEM_ID, MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix elementAdjacentFacesMatrix(const MeshType& mesh)
{
    uint lfa = vcl::largestPerElementAdjacentFacesNumber<ELEM_ID>(mesh);
 
    Matrix eAFM(mesh.template number<ELEM_ID>(), lfa);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    elementAdjacentFacesToBuffer<ELEM_ID>(mesh, eAFM.data(), lfa, stg);
 
    return eAFM;
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    FaceMeshConcept MeshType>
Container<Container<T>> vertexAdjacentFacesVectors(const MeshType& mesh)
{
    return elementAdjacentFacesVectors<ElemId::VERTEX, Container, T>(mesh);
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix vertexAdjacentFacesMatrix(const MeshType& mesh)
{
    return elementAdjacentFacesMatrix<ElemId::VERTEX, Matrix>(mesh);
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    FaceMeshConcept MeshType>
Container<Container<T>> faceAdjacentFacesVectors(const MeshType& mesh)
{
    return elementAdjacentFacesVectors<ElemId::FACE, Container, T>(mesh);
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceAdjacentFacesMatrix(const MeshType& mesh)
{
    return elementAdjacentFacesMatrix<ElemId::FACE, Matrix>(mesh);
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    FaceMeshConcept MeshType>
Container<Container<T>> edgeAdjacentFacesVectors(const MeshType& mesh)
    requires EdgeMeshConcept<MeshType>
{
    return elementAdjacentFacesVectors<ElemId::EDGE, Container, T>(mesh);
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix edgeAdjacentFacesMatrix(const MeshType& mesh)
    requires EdgeMeshConcept<MeshType>
{
    return elementAdjacentFacesMatrix<ElemId::EDGE, Matrix>(mesh);
}
 
template<
    uint ELEM_ID,
    template<typename, typename...>
    typename Container,
    typename T,
    EdgeMeshConcept MeshType>
Container<Container<T>> elementAdjacentEdgesVectors(const MeshType& mesh)
{
    requireEdgeContainerCompactness(mesh);
    requirePerElementComponent<ELEM_ID, CompId::ADJACENT_EDGES>(mesh);
 
    Container<Container<T>> vv(mesh.template number<ELEM_ID>());
 
    auto vvIt = vv.begin();
    for (const auto& v : mesh.template elements<ELEM_ID>()) {
        auto& vec = *vvIt;
 
        vec.resize(v.adjEdgesNumber());
        auto vecIt = vec.begin();
        for (const auto* fe : v.adjEdges()) {
            uint idx = fe ? fe->index() : UINT_NULL;
            *vecIt   = T(idx);
            ++vecIt;
        }
 
        ++vvIt;
    }
 
    return vv;
}
 
template<uint ELEM_ID, MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix elementAdjacentEdgesMatrix(const MeshType& mesh)
{
    uint lea = vcl::largestPerElementAdjacentEdgesNumber<ELEM_ID>(mesh);
 
    Matrix eAEM(mesh.template number<ELEM_ID>(), lea);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    elementAdjacentEdgesToBuffer<ELEM_ID>(mesh, eAEM.data(), lea, stg);
 
    return eAEM;
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    EdgeMeshConcept MeshType>
Container<Container<T>> vertexAdjacentEdgesVectors(const MeshType& mesh)
{
    return elementAdjacentEdgesVectors<ElemId::VERTEX, Container, T>(mesh);
}
 
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix vertexAdjacentEdgesMatrix(const MeshType& mesh)
{
    return elementAdjacentEdgesMatrix<ElemId::VERTEX, Matrix>(mesh);
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    EdgeMeshConcept MeshType>
Container<Container<T>> faceAdjacentEdgesVectors(const MeshType& mesh)
    requires FaceMeshConcept<MeshType>
{
    return elementAdjacentEdgesVectors<ElemId::FACE, Container, T>(mesh);
}
 
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix faceAdjacentEdgesMatrix(const MeshType& mesh)
    requires FaceMeshConcept<MeshType>
{
    return elementAdjacentEdgesMatrix<ElemId::FACE, Matrix>(mesh);
}
 
template<
    template<typename, typename...>
    typename Container,
    typename T,
    EdgeMeshConcept MeshType>
Container<Container<T>> edgeAdjacentEdgesVectors(const MeshType& mesh)
{
    return elementAdjacentEdgesVectors<ElemId::EDGE, Container, T>(mesh);
}
 
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix edgeAdjacentEdgesMatrix(const MeshType& mesh)
{
    return elementAdjacentEdgesMatrix<ElemId::EDGE, Matrix>(mesh);
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_MATRIX_H