import_buffer.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_BUFFER_H
#define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_IMPORT_BUFFER_H
 
#include "detail.h"
 
#include <vclib/mesh.h>
#include <vclib/space/core.h>
 
namespace vcl {
 
template<MeshConcept MeshType>
void vertexPositionsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    uint              vertexNumber,
    bool              clearBeforeSet = true,
    MatrixStorageType storage        = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber      = UINT_NULL)
{
    using namespace detail;
 
    const uint ROW_NUM = rowNumber == UINT_NULL ? vertexNumber : rowNumber;
 
    if (clearBeforeSet) {
        mesh.clearVertices();
        mesh.resizeVertices(vertexNumber);
    }
    else {
        if (vertexNumber != mesh.vertexNumber()) {
            throw WrongSizeException(
                "The input vertex number does not match the number of vertices "
                "of the mesh\n"
                "Number of vertices in the mesh: " +
                std::to_string(mesh.vertexNumber()) +
                "\nNumber of input vertex number: " +
                std::to_string(vertexNumber));
        }
    }
 
    for (uint i = 0; auto& p : mesh.vertices() | views::positions) {
        p.x() = at(buffer, i, 0, ROW_NUM, 3, storage);
        p.y() = at(buffer, i, 1, ROW_NUM, 3, storage);
        p.z() = at(buffer, i, 2, ROW_NUM, 3, storage);
 
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void faceIndicesFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    uint              faceNumber,
    uint              faceSize       = 3,
    bool              clearBeforeSet = true,
    MatrixStorageType storage        = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber      = UINT_NULL)
{
    using namespace detail;
 
    const uint ROW_NUM = rowNumber == UINT_NULL ? faceNumber : rowNumber;
 
    if (clearBeforeSet) {
        mesh.clearFaces();
        mesh.resizeFaces(faceNumber);
    }
    else {
        if (faceNumber != mesh.faceNumber()) {
            throw WrongSizeException(
                "The input face number does not match the number of faces "
                "of the mesh\n"
                "Number of faces in the mesh: " +
                std::to_string(mesh.faceNumber()) +
                "\nNumber of input face number: " + std::to_string(faceNumber));
        }
    }
 
    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 < faceSize &&
                   at(buffer, i, vertexNumber, ROW_NUM, faceSize, storage) !=
                       -1 &&
                   at(buffer, i, vertexNumber, ROW_NUM, faceSize, storage) !=
                       UINT_NULL)
                vertexNumber++;
 
            f.resizeVertices(vertexNumber);
 
            for (uint j = 0; j < vertexNumber; ++j)
                f.setVertex(j, at(buffer, i, j, ROW_NUM, faceSize, storage));
            ++i;
        }
    }
    else { // the vertex number of mesh faces is fixed
        using FaceType = MeshType::FaceType;
 
        constexpr int VN = FaceType::VERTEX_NUMBER;
        if (faceSize == 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, at(buffer, i, j, ROW_NUM, faceSize, storage));
                ++i;
            }
        }
        else {
            // cannot import the faces if the number of face indices in the
            // buffer is different w.r.t. face size of the mesh
            throw WrongSizeException(
                "The input face buffer has a different face size "
                "than the vertex number of the faces of the mesh.\n"
                "Vertex number of faces in the mesh: " +
                std::to_string(VN) +
                "\nNumber of columns in the input face buffer: " +
                std::to_string(faceSize));
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeIndicesFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    uint              edgeNumber,
    bool              clearBeforeSet = true,
    MatrixStorageType storage        = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber      = UINT_NULL)
{
    using namespace detail;
 
    if (clearBeforeSet) {
        mesh.clearEdges();
        mesh.resizeEdges(edgeNumber);
    }
    else {
        if (edgeNumber != mesh.edgeNumber()) {
            throw WrongSizeException(
                "The input edge number does not match the number of edges "
                "of the mesh\n"
                "Number of edges in the mesh: " +
                std::to_string(mesh.edgeNumber()) +
                "\nNumber of input edge number: " + std::to_string(edgeNumber));
        }
    }
 
    uint i = 0;
    for (auto& e : mesh.edges()) {
        e.setVertex(0, at(buffer, i, 0, rowNumber, 2, storage));
        e.setVertex(1, at(buffer, i, 1, rowNumber, 2, storage));
        i++;
    }
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementSelectionFromBuffer(MeshType& mesh, const auto* buffer)
{
    for (uint i = 0; auto& e : mesh.template elements<ELEM_ID>()) {
        e.selected() = buffer[i];
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexSelectionFromBuffer(MeshType& mesh, const auto* buffer)
{
    elementSelectionFromBuffer<ElemId::VERTEX>(mesh, buffer);
}
 
template<FaceMeshConcept MeshType>
void faceSelectionFromBuffer(MeshType& mesh, const auto* buffer)
{
    elementSelectionFromBuffer<ElemId::FACE>(mesh, buffer);
}
 
template<EdgeMeshConcept MeshType>
void edgeSelectionFromBuffer(MeshType& mesh, const auto* buffer)
{
    elementSelectionFromBuffer<ElemId::EDGE>(mesh, buffer);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    using namespace detail;
 
    const uint ROW_NUM =
        rowNumber == UINT_NULL ? mesh.template number<ELEM_ID>() : rowNumber;
 
    enableIfPerElementComponentOptional<ELEM_ID, CompId::NORMAL>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::NORMAL>(mesh);
 
    for (uint  i = 0;
         auto& n : mesh.template elements<ELEM_ID>() | views::normals) {
        n.x() = at(buffer, i, 0, ROW_NUM, 3, storage);
        n.y() = at(buffer, i, 1, ROW_NUM, 3, storage);
        n.z() = at(buffer, i, 2, ROW_NUM, 3, storage);
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    elementNormalsFromBuffer<ElemId::VERTEX, MeshType>(
        mesh, buffer, storage, rowNumber);
}
 
template<FaceMeshConcept MeshType>
void faceNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    elementNormalsFromBuffer<ElemId::FACE, MeshType>(
        mesh, buffer, storage, rowNumber);
}
 
template<EdgeMeshConcept MeshType>
void edgeNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    elementNormalsFromBuffer<ElemId::EDGE, MeshType>(
        mesh, buffer, storage, rowNumber);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementColorsFromBuffer(
    MeshType&             mesh,
    const auto*           buffer,
    uint                  channelsNumber = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    using namespace detail;
 
    const uint ROW_NUM =
        rowNumber == UINT_NULL ? mesh.template number<ELEM_ID>() : rowNumber;
 
    if (channelsNumber != 3 && channelsNumber != 4)
        throw WrongSizeException(
            "The input " + elementEnumString<ELEM_ID>() +
            " colors must have 3 or 4 channels.");
 
    enableIfPerElementComponentOptional<ELEM_ID, CompId::COLOR>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    for (uint  i = 0;
         auto& c : mesh.template elements<ELEM_ID>() | views::colors) {
        if (representation == Color::Representation::INT_0_255) {
            c.x() = at(buffer, i, 0, ROW_NUM, channelsNumber, storage);
            c.y() = at(buffer, i, 1, ROW_NUM, channelsNumber, storage);
            c.z() = at(buffer, i, 2, ROW_NUM, channelsNumber, storage);
 
            if (channelsNumber == 4)
                c.w() = at(buffer, i, 3, ROW_NUM, channelsNumber, storage);
            else
                c.w() = 255;
        }
        else {
            c.x() = at(buffer, i, 0, ROW_NUM, channelsNumber, storage) * 255;
            c.y() = at(buffer, i, 1, ROW_NUM, channelsNumber, storage) * 255;
            c.z() = at(buffer, i, 2, ROW_NUM, channelsNumber, storage) * 255;
 
            if (channelsNumber == 4)
                c.w() =
                    at(buffer, i, 3, ROW_NUM, channelsNumber, storage) * 255;
            else
                c.w() = 255;
        }
        ++i;
    }
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementColorsFromBuffer(
    MeshType&     mesh,
    const auto*   buffer,
    Color::Format colorFormat)
{
    enableIfPerElementComponentOptional<ELEM_ID, CompId::COLOR>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::COLOR>(mesh);
 
    for (uint  i = 0;
         auto& c : mesh.template elements<ELEM_ID>() | views::colors) {
        c = Color(buffer[i++], colorFormat);
    }
}
 
template<MeshConcept MeshType>
void vertexColorsFromBuffer(
    MeshType&             mesh,
    const auto*           buffer,
    uint                  channelsNumber = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    elementColorsFromBuffer<ElemId::VERTEX, MeshType>(
        mesh, buffer, channelsNumber, storage, representation, rowNumber);
}
 
template<MeshConcept MeshType>
void vertexColorsFromBuffer(
    MeshType&     mesh,
    const auto*   buffer,
    Color::Format colorFormat)
{
    elementColorsFromBuffer<ElemId::VERTEX, MeshType>(
        mesh, buffer, colorFormat);
}
 
template<FaceMeshConcept MeshType>
void faceColorsFromBuffer(
    MeshType&             mesh,
    const auto*           buffer,
    uint                  channelsNumber = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    elementColorsFromBuffer<ElemId::FACE, MeshType>(
        mesh, buffer, channelsNumber, storage, representation, rowNumber);
}
 
template<FaceMeshConcept MeshType>
void faceColorsFromBuffer(
    MeshType&     mesh,
    const auto*   buffer,
    Color::Format colorFormat)
{
    elementColorsFromBuffer<ElemId::FACE, MeshType>(mesh, buffer, colorFormat);
}
 
template<EdgeMeshConcept MeshType>
void edgeColorsFromBuffer(
    MeshType&             mesh,
    const auto*           buffer,
    uint                  channelsNumber = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  rowNumber      = UINT_NULL)
{
    elementColorsFromBuffer<ElemId::EDGE, MeshType>(
        mesh, buffer, channelsNumber, storage, representation, rowNumber);
}
 
template<EdgeMeshConcept MeshType>
void edgeColorsFromBuffer(
    MeshType&     mesh,
    const auto*   buffer,
    Color::Format colorFormat)
{
    elementColorsFromBuffer<ElemId::EDGE, MeshType>(mesh, buffer, colorFormat);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementQualityFromBuffer(MeshType& mesh, const auto* buffer)
{
    enableIfPerElementComponentOptional<ELEM_ID, CompId::QUALITY>(mesh);
    requirePerElementComponent<ELEM_ID, CompId::QUALITY>(mesh);
 
    for (uint i = 0; auto& e : mesh.template elements<ELEM_ID>()) {
        e.quality() = buffer[i];
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexQualityFromBuffer(MeshType& mesh, const auto* buffer)
{
    elementQualityFromBuffer<ElemId::VERTEX, MeshType>(mesh, buffer);
}
 
template<FaceMeshConcept MeshType>
void faceQualityFromBuffer(MeshType& mesh, const auto* buffer)
{
    elementQualityFromBuffer<ElemId::FACE, MeshType>(mesh, buffer);
}
 
template<EdgeMeshConcept MeshType>
void edgeQualityFromBuffer(MeshType& mesh, const auto* buffer)
{
    elementQualityFromBuffer<ElemId::EDGE, MeshType>(mesh, buffer);
}
 
template<MeshConcept MeshType>
void vertexTexCoordsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage   = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber = UINT_NULL)
{
    using namespace detail;
 
    const uint ROW_NUM =
        rowNumber == UINT_NULL ? mesh.vertexNumber() : rowNumber;
 
    enableIfPerVertexTexCoordOptional(mesh);
    requirePerVertexTexCoord(mesh);
 
    for (uint i = 0; auto& t : mesh.vertices() | views::texCoords) {
        t.u() = at(buffer, i, 0, ROW_NUM, 2, storage);
        t.v() = at(buffer, i, 1, ROW_NUM, 2, storage);
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexMaterialIndicesFromBuffer(MeshType& mesh, const auto* buffer)
{
    enableIfPerVertexMaterialIndexOptional(mesh);
    requirePerVertexMaterialIndex(mesh);
 
    for (uint i = 0; auto& v : mesh.vertices()) {
        v.materialIndex() = buffer[i];
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void faceWedgeTexCoordsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    uint              largestFaceSize = 3,
    MatrixStorageType storage         = MatrixStorageType::ROW_MAJOR,
    uint              rowNumber       = UINT_NULL)
{
    using namespace detail;
 
    const uint ROW_NUM = rowNumber == UINT_NULL ? mesh.faceNumber() : rowNumber;
    const uint COL_NUM = largestFaceSize * 2;
 
    enableIfPerFaceWedgeTexCoordsOptional(mesh);
    requirePerFaceWedgeTexCoords(mesh);
 
    for (uint i = 0; auto& f : mesh.faces()) {
        for (uint j = 0; auto& w : f.wedgeTexCoords()) {
            if (j < largestFaceSize) {
                w.u() = at(buffer, i, 2 * j + 0, ROW_NUM, COL_NUM, storage);
                w.v() = at(buffer, i, 2 * j + 1, ROW_NUM, COL_NUM, storage);
            }
            ++j;
        }
        ++i;
    }
};
 
template<FaceMeshConcept MeshType>
void faceMaterialIndicesFromBuffer(MeshType& mesh, const auto* buffer)
{
    enableIfPerFaceMaterialIndexOptional(mesh);
    requirePerFaceMaterialIndex(mesh);
 
    for (uint i = 0; auto& f : mesh.faces()) {
        f.materialIndex() = buffer[i];
        ++i;
    }
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_MESH_IMPORT_EXPORT_IMPORT_BUFFER_H