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/concepts/space/matrix.h>
#include <vclib/mesh/requirements.h>
#include <vclib/space/core/matrix.h>
 
namespace vcl {
 
template<MatrixConcept Matrix, MeshConcept MeshType>
Matrix vertexCoordsMatrix(const MeshType& mesh)
{
    Matrix vM(mesh.vertexNumber(), 3);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    vertexCoordsToBuffer(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 faceIndicesVector(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    uint nIndices = countPerFaceVertexReferences(mesh);
 
    Vect fV(nIndices);
 
    faceIndicesToBuffer(mesh, fV.data());
 
    return fV;
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix faceIndicesMatrix(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    uint fMaxSize = largestFaceSize(mesh);
 
    Matrix fM(mesh.faceNumber(), fMaxSize);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    faceIndicesToBuffer(mesh, fM.data(), fMaxSize, stg);
 
    return fM;
}
 
template<MatrixConcept Matrix, FaceMeshConcept MeshType>
Matrix triangulatedFaceIndicesMatrix(
    const MeshType&    mesh,
    TriPolyIndexBiMap& indexMap = detail::indexMap)
{
    requireVertexContainerCompactness(mesh);
 
    uint tNumber = vcl::countTriangulatedTriangles(mesh);
 
    Matrix tM(tNumber, 3);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    triangulatedFaceIndicesToBuffer(mesh, tM.data(), indexMap, stg, tNumber);
 
    return tM;
}
 
template<MatrixConcept Matrix, EdgeMeshConcept MeshType>
Matrix edgeIndicesMatrix(const MeshType& mesh)
{
    requireVertexContainerCompactness(mesh);
 
    Matrix eM(mesh.edgeNumber(), 2);
 
    MatrixStorageType stg = matrixStorageType<Matrix>();
 
    edgeIndicesToBuffer(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<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)
{
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(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)
{
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    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<uint ELEM_ID, typename Vect, MeshConcept MeshType>
Vect elementQualityVector(const MeshType& mesh)
{
    requirePerElementComponent<ELEM_ID, CompId::QUALITY>(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);
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_MATRIX_H