import_buffer.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2026                                                    *
 * 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              vertexCount,
    bool              clearBeforeSet = true,
    MatrixStorageType storage        = MatrixStorageType::ROW_MAJOR,
    uint              numRows        = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS = numRows == UINT_NULL ? vertexCount : numRows;
 
    if (clearBeforeSet) {
        mesh.clearVertices();
        mesh.resizeVertices(vertexCount);
    }
    else {
        if (vertexCount != mesh.vertexCount()) {
            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.vertexCount()) +
                "\nNumber of input vertex number: " +
                std::to_string(vertexCount));
        }
    }
 
    for (uint i = 0; auto& p : mesh.vertices() | views::positions) {
        p.x() = at(buffer, i, 0, NUM_ROWS, 3, storage);
        p.y() = at(buffer, i, 1, NUM_ROWS, 3, storage);
        p.z() = at(buffer, i, 2, NUM_ROWS, 3, storage);
 
        ++i;
    }
}
 
template<FaceMeshConcept MeshType>
void faceIndicesFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    uint              faceCount,
    uint              faceSize       = 3,
    bool              clearBeforeSet = true,
    MatrixStorageType storage        = MatrixStorageType::ROW_MAJOR,
    uint              numRows        = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS = numRows == UINT_NULL ? faceCount : numRows;
 
    if (clearBeforeSet) {
        mesh.clearFaces();
        mesh.resizeFaces(faceCount);
    }
    else {
        if (faceCount != mesh.faceCount()) {
            throw WrongSizeException(
                "The input face count does not match the number of faces of "
                "the mesh\n"
                "Number of faces in the mesh: " +
                std::to_string(mesh.faceCount()) +
                "\nNumber of input face count: " + std::to_string(faceCount));
        }
    }
 
    if constexpr (HasPolygons<MeshType>) {
        uint i = 0;
        for (auto& f : mesh.faces()) {
            uint vertexCount = 0;
 
            // count the number of vertices of the face
            while (vertexCount < faceSize &&
                   at(buffer, i, vertexCount, NUM_ROWS, faceSize, storage) !=
                       -1 &&
                   at(buffer, i, vertexCount, NUM_ROWS, faceSize, storage) !=
                       UINT_NULL)
                vertexCount++;
 
            f.resizeVertices(vertexCount);
 
            for (uint j = 0; j < vertexCount; ++j)
                f.setVertex(j, at(buffer, i, j, NUM_ROWS, faceSize, storage));
            ++i;
        }
    }
    else { // the vertex number of mesh faces is fixed
        using FaceType = MeshType::FaceType;
 
        constexpr int VC = FaceType::VERTEX_COUNT;
        if (faceSize == VC) { // faces of matrix and mesh have same size
            uint i = 0;
            for (auto& f : mesh.faces()) {
                for (uint j = 0; j < VC; ++j)
                    f.setVertex(
                        j, at(buffer, i, j, NUM_ROWS, 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 count of the faces of the mesh.\n"
                "Faces vertex count in the mesh: " +
                std::to_string(VC) +
                "\nNumber of columns in the input face buffer: " +
                std::to_string(faceSize));
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void edgeIndicesFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    uint              edgeCount,
    bool              clearBeforeSet = true,
    MatrixStorageType storage        = MatrixStorageType::ROW_MAJOR,
    uint              numRows        = UINT_NULL)
{
    using namespace detail;
 
    if (clearBeforeSet) {
        mesh.clearEdges();
        mesh.resizeEdges(edgeCount);
    }
    else {
        if (edgeCount != mesh.edgeCount()) {
            throw WrongSizeException(
                "The input edge count does not match the number of edges "
                "of the mesh\n"
                "Number of edges in the mesh: " +
                std::to_string(mesh.edgeCount()) +
                "\nNumber of input edge count: " + std::to_string(edgeCount));
        }
    }
 
    uint i = 0;
    for (auto& e : mesh.edges()) {
        e.setVertex(0, at(buffer, i, 0, numRows, 2, storage));
        e.setVertex(1, at(buffer, i, 1, numRows, 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              numRows = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? mesh.template count<ELEM_ID>() : numRows;
 
    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, NUM_ROWS, 3, storage);
        n.y() = at(buffer, i, 1, NUM_ROWS, 3, storage);
        n.z() = at(buffer, i, 2, NUM_ROWS, 3, storage);
 
        ++i;
    }
}
 
template<MeshConcept MeshType>
void vertexNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementNormalsFromBuffer<ElemId::VERTEX, MeshType>(
        mesh, buffer, storage, numRows);
}
 
template<FaceMeshConcept MeshType>
void faceNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementNormalsFromBuffer<ElemId::FACE, MeshType>(
        mesh, buffer, storage, numRows);
}
 
template<EdgeMeshConcept MeshType>
void edgeNormalsFromBuffer(
    MeshType&         mesh,
    const auto*       buffer,
    MatrixStorageType storage = MatrixStorageType::ROW_MAJOR,
    uint              numRows = UINT_NULL)
{
    elementNormalsFromBuffer<ElemId::EDGE, MeshType>(
        mesh, buffer, storage, numRows);
}
 
template<uint ELEM_ID, MeshConcept MeshType>
void elementColorsFromBuffer(
    MeshType&             mesh,
    const auto*           buffer,
    uint                  channelCount   = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  numRows        = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS =
        numRows == UINT_NULL ? mesh.template count<ELEM_ID>() : numRows;
 
    if (channelCount != 3 && channelCount != 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, NUM_ROWS, channelCount, storage);
            c.y() = at(buffer, i, 1, NUM_ROWS, channelCount, storage);
            c.z() = at(buffer, i, 2, NUM_ROWS, channelCount, storage);
 
            if (channelCount == 4)
                c.w() = at(buffer, i, 3, NUM_ROWS, channelCount, storage);
            else
                c.w() = 255;
        }
        else {
            c.x() = at(buffer, i, 0, NUM_ROWS, channelCount, storage) * 255;
            c.y() = at(buffer, i, 1, NUM_ROWS, channelCount, storage) * 255;
            c.z() = at(buffer, i, 2, NUM_ROWS, channelCount, storage) * 255;
 
            if (channelCount == 4)
                c.w() = at(buffer, i, 3, NUM_ROWS, channelCount, 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                  channelCount   = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  numRows        = UINT_NULL)
{
    elementColorsFromBuffer<ElemId::VERTEX, MeshType>(
        mesh, buffer, channelCount, storage, representation, numRows);
}
 
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                  channelCount   = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  numRows        = UINT_NULL)
{
    elementColorsFromBuffer<ElemId::FACE, MeshType>(
        mesh, buffer, channelCount, storage, representation, numRows);
}
 
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                  channelCount   = 4,
    MatrixStorageType     storage        = MatrixStorageType::ROW_MAJOR,
    Color::Representation representation = Color::Representation::INT_0_255,
    uint                  numRows        = UINT_NULL)
{
    elementColorsFromBuffer<ElemId::EDGE, MeshType>(
        mesh, buffer, channelCount, storage, representation, numRows);
}
 
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              numRows = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.vertexCount() : numRows;
 
    enableIfPerVertexTexCoordOptional(mesh);
    requirePerVertexTexCoord(mesh);
 
    for (uint i = 0; auto& t : mesh.vertices() | views::texCoords) {
        t.u() = at(buffer, i, 0, NUM_ROWS, 2, storage);
        t.v() = at(buffer, i, 1, NUM_ROWS, 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              numRows         = UINT_NULL)
{
    using namespace detail;
 
    const uint NUM_ROWS = numRows == UINT_NULL ? mesh.faceCount() : numRows;
    const uint NUM_COLS = 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, NUM_ROWS, NUM_COLS, storage);
                w.v() = at(buffer, i, 2 * j + 1, NUM_ROWS, NUM_COLS, 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