load.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_IO_MESH_OBJ_LOAD_H
#define VCL_IO_MESH_OBJ_LOAD_H
 
#include "material.h"
 
#include <vclib/io/file_info.h>
#include <vclib/io/image/load.h>
#include <vclib/io/mesh/settings.h>
#include <vclib/io/read.h>
 
#include <vclib/algorithms/mesh.h>
#include <vclib/space/complex.h>
#include <vclib/space/core.h>
 
#include <algorithm>
#include <map>
 
namespace vcl {
 
namespace detail {
 
inline void loadObjMaterials(
    std::map<std::string, ObjMaterial>& materialMap,
    std::istream&                       stream)
{
    std::string matName;
    ObjMaterial mat;
 
    auto manageMaterialArgsFn = [&](auto& token) {
        while ((*token)[0] == '-') {
            if (*token == "-o" || *token == "-s" || *token == "-t") {
                // ignore the argument and the three values
                ++token;
                ++token;
                ++token;
                ++token;
            }
            if (*token == "-mm") {
                // ignore the argument and the two values
                ++token;
                ++token;
                ++token;
            }
            if (*token == "-blendu" || *token == "-blendv" || *token == "-cc" ||
                *token == "-clamp" || *token == "-texres") {
                // ignore the argument and the value
                ++token;
                ++token;
            }
        }
    };
 
    do {
        Tokenizer tokens = readAndTokenizeNextNonEmptyLineNoThrow(stream);
        if (stream) {
            // counter for texture images, used when mesh has no texture files
            uint                nt     = 0;
            Tokenizer::iterator token  = tokens.begin();
            std::string         header = *token++;
            if (header == "newmtl") {
                if (!matName.empty())
                    materialMap[matName] = mat;
                mat         = ObjMaterial();
                matName     = *token;
                mat.matName = matName;
            }
            if (header == "Ka") {
                if (tokens.size() >= 4) {
                    if (*token != "spectral" && *token != "xyz") {
                        mat.Ka.x() = io::readFloat<float>(token);
                        mat.Ka.y() = io::readFloat<float>(token);
                        mat.Ka.z() = io::readFloat<float>(token);
                    }
                }
            }
            if (header == "Kd") {
                if (tokens.size() >= 4) {
                    if (*token != "spectral" && *token != "xyz") {
                        mat.Kd.x() = io::readFloat<float>(token);
                        mat.Kd.y() = io::readFloat<float>(token);
                        mat.Kd.z() = io::readFloat<float>(token);
                    }
                }
            }
            if (header == "Ks") {
                if (tokens.size() >= 4) {
                    if (*token != "spectral" && *token != "xyz") {
                        mat.Ks.x() = io::readFloat<float>(token);
                        mat.Ks.y() = io::readFloat<float>(token);
                        mat.Ks.z() = io::readFloat<float>(token);
                    }
                }
            }
            if (header == "Ke") {
                if (tokens.size() >= 4) {
                    if (*token != "spectral" && *token != "xyz") {
                        mat.Ke.x() = io::readFloat<float>(token);
                        mat.Ke.y() = io::readFloat<float>(token);
                        mat.Ke.z() = io::readFloat<float>(token);
                    }
                }
            }
            if (header == "d") {
                if ((*token)[0] == '-')
                    token++;
                mat.d = io::readFloat<float>(token);
            }
            if (header == "Tr") {
                if ((*token)[0] == '-')
                    token++;
                mat.d = 1 - io::readFloat<float>(token);
            }
            if (header == "Ns") {
                mat.Ns = io::readFloat<float>(token);
            }
            if (header == "illum") {
                mat.illum = io::readFloat<int>(token);
            }
            if (header == "map_Kd") {
                // need to manage args
                manageMaterialArgsFn(token);
                mat.map_Kd = *token;
                // replace backslashes with slashes - windows compatibility
                std::ranges::replace(mat.map_Kd, '\\', '/');
            }
            if (header == "map_Ke") {
                // need to manage args
                manageMaterialArgsFn(token);
                mat.map_Ke = *token;
                // replace backslashes with slashes - windows compatibility
                std::ranges::replace(mat.map_Ke, '\\', '/');
            }
            if (header == "map_bump" || header == "bump") {
                // need to manage args
                manageMaterialArgsFn(token);
                mat.map_bump = *token;
                // replace backslashes with slashes - windows compatibility
                std::ranges::replace(mat.map_bump, '\\', '/');
            }
        }
    } while (stream);
    if (!matName.empty())
        materialMap[matName] = mat;
}
 
template<MeshConcept MeshType>
void loadObjMaterials(
    std::map<std::string, ObjMaterial>& materialMap,
    MeshType&                           mesh,
    std::istream&                       stream,
    MeshInfo&                           loadedInfo,
    const LoadSettings&                 settings)
{
    loadObjMaterials(materialMap, stream);
 
    for (auto& [matName, mat] : materialMap) {
        if constexpr (HasMaterials<MeshType>) {
            loadedInfo.setMaterials();
            Material m = mat.toMaterial();
            mat.matId  = mesh.materialCount();
            mesh.pushMaterial(m);
        }
    }
}
 
template<MeshConcept MeshType>
void loadObjMaterials(
    std::map<std::string, ObjMaterial>& materialMap,
    MeshType&                           mesh,
    const std::string&                  mtllib,
    MeshInfo&                           loadedInfo,
    const LoadSettings&                 settings)
{
    std::ifstream file = openInputFileStream(mtllib);
    loadObjMaterials(materialMap, mesh, file, loadedInfo, settings);
}
 
template<MeshConcept MeshType>
void readObjVertex(
    MeshType&            m,
    Tokenizer::iterator& token,
    MeshInfo&            loadedInfo,
    const Tokenizer&     tokens,
    const LoadSettings&  settings)
{
    uint vid = m.addVertex();
    for (uint i = 0; i < 3; ++i) {
        m.vertex(vid).position()[i] = io::readDouble<double>(token);
    }
    if constexpr (HasPerVertexColor<MeshType>) {
        if (vid == 0) {
            // if the file stores the vertex color in the non-standard way
            // (color values after the positions)
            if (tokens.size() > 6) {
                if (settings.enableOptionalComponents) {
                    enableIfPerVertexColorOptional(m);
                    loadedInfo.setPerVertexColor();
                }
                else {
                    if (isPerVertexColorAvailable(m))
                        loadedInfo.setPerVertexColor();
                }
            }
        }
        if (loadedInfo.hasPerVertexColor()) {
            // the file has the nonstandard way to store vertex colors, after
            // the positions...
            if (tokens.size() > 6) {
                m.vertex(vid).color().setRedF(io::readFloat<float>(token));
                m.vertex(vid).color().setGreenF(io::readFloat<float>(token));
                m.vertex(vid).color().setBlueF(io::readFloat<float>(token));
            }
        }
    }
}
 
template<FaceMeshConcept MeshType>
void readObjFace(
    MeshType&                     m,
    MeshInfo&                     loadedInfo,
    const Tokenizer&              tokens,
    const std::vector<Point3d>&   normals,
    const std::vector<TexCoordd>& wedgeTexCoords,
    const ObjMaterial&            currentMaterial,
    const LoadSettings&           settings)
{
    using FaceType = MeshType::FaceType;
 
    std::vector<uint> vids;
    std::vector<uint> wids;
    std::vector<uint> nids;
 
    loadedInfo.updateMeshType(tokens.size() - 1);
 
    // actual read - load vertex indices and texcoords indices, if present
    Tokenizer::iterator token = tokens.begin();
    ++token;
    vids.resize(tokens.size() - 1);
    wids.reserve(tokens.size() - 1);
    nids.reserve(tokens.size() - 1);
    for (uint i = 0; i < tokens.size() - 1; ++i) {
        Tokenizer subt(*token, '/', false);
        auto      t = subt.begin();
        vids[i]     = io::readUInt<uint>(t) - 1;
        if (subt.size() > 1) {
            if (!t->empty()) {
                wids.push_back(io::readUInt<uint>(t) - 1);
            }
            if (subt.size() > 2) {
                if (!t->empty()) {
                    nids.push_back(io::readUInt<uint>(t) - 1);
                }
            }
        }
        ++token;
    }
 
    // add the face
    uint      fid = m.addFace();
    FaceType& f   = m.face(fid);
 
    // check if we need to split the face we read into triangles
    bool splitFace = false;
    // we have a polygonal mesh, no need to split
    if constexpr (FaceType::VERTEX_COUNT < 0) {
        // need to resize to the right number of verts
        f.resizeVertices(tokens.size() - 1);
    }
    else if (FaceType::VERTEX_COUNT != tokens.size() - 1) {
        // we have faces with static sizes (triangles), but we are loading faces
        // with number of verts > 3. Need to split the face we are loading in n
        // faces!
        splitFace = true;
    }
 
    // create the face in the mesh, for now we manage only vertex indices
    if (!splitFace) { // no need to split face case
        for (uint i = 0; i < vids.size(); ++i) {
            if (vids[i] >= m.vertexCount()) {
                throw MalformedFileException(
                    "Bad vertex index for face " + std::to_string(fid));
            }
            f.setVertex(i, vids[i]);
        }
    }
    else { // split needed
        addTriangleFacesFromPolygon(m, f, vids);
    }
 
    // material
    if constexpr (HasPerFaceMaterialIndex<MeshType>) {
        if (fid == 0 && currentMaterial.matId != UINT_NULL) {
            if (settings.enableOptionalComponents) {
                enableIfPerFaceMaterialIndexOptional(m);
                loadedInfo.setPerFaceMaterialIndex();
            }
            else {
                if (isPerFaceMaterialIndexAvailable(m)) {
                    loadedInfo.setPerFaceMaterialIndex();
                }
            }
        }
        if (loadedInfo.hasPerFaceMaterialIndex()) {
            if (!splitFace) {
                f.materialIndex() = currentMaterial.matId;
            }
            else {
                for (uint ff = fid; ff < m.faceCount(); ++ff) {
                    FaceType& f       = m.face(ff);
                    f.materialIndex() = currentMaterial.matId;
                }
            }
        }
    }
 
    // vertex normals
    if constexpr (HasPerVertexNormal<MeshType>) {
        using NormalType = typename MeshType::VertexType::NormalType;
        using NST        = typename NormalType::ScalarType;
        // first, need to check if I can store per-vertex normals in the mesh
        if (fid == 0) {
            // if the current face has the right number of normals, we assume
            // that we can load per-vertex normals
            if (nids.size() == vids.size()) {
                if (settings.enableOptionalComponents) {
                    enableIfPerVertexNormalOptional(m);
                    loadedInfo.setPerVertexNormal();
                }
                else {
                    if (isPerVertexNormalAvailable(m)) {
                        loadedInfo.setPerVertexNormal();
                    }
                }
            }
        }
        if (loadedInfo.hasPerVertexNormal()) {
            if (nids.size() == vids.size()) {
                for (uint i = 0; i < nids.size(); ++i) {
                    if (nids[i] >= normals.size()) {
                        throw MalformedFileException(
                            "Bad normal index for face " + std::to_string(fid));
                    }
                    m.vertex(vids[i]).normal() = normals[nids[i]].cast<NST>();
                }
            }
        }
    }
 
    // wedge texcoords
    if constexpr (HasPerFaceWedgeTexCoords<MeshType>) {
        using WedgeTCType = MeshType::FaceType::WedgeTexCoordType;
        using WTCST       = typename WedgeTCType::ScalarType;
        // first, need to check if I can store wedge texcoords in the mesh
        if (fid == 0) {
            // if the current face has the right number of wedge texcoords, we
            // assume that we can load wedge texcoords
            if (wids.size() == vids.size()) {
                if (settings.enableOptionalComponents) {
                    enableIfPerFaceWedgeTexCoordsOptional(m);
                    loadedInfo.setPerFaceWedgeTexCoords();
                }
                else {
                    if (isPerFaceWedgeTexCoordsAvailable(m)) {
                        loadedInfo.setPerFaceWedgeTexCoords();
                    }
                }
            }
        }
        if (loadedInfo.hasPerFaceWedgeTexCoords()) {
            if (wids.size() == vids.size()) {
                if (!splitFace) { // there wasn't a triangulation of the face
                    // it is safe to assign each wedge texcoord to its position
                    // in the face
                    for (uint i = 0; i < wids.size(); ++i) {
                        if (wids[i] >= wedgeTexCoords.size()) {
                            throw MalformedFileException(
                                "Bad texcoord index for face " +
                                std::to_string(fid));
                        }
                        f.wedgeTexCoord(i) =
                            wedgeTexCoords[wids[i]].cast<WTCST>();
                    }
                }
                else {
                    // take read texcoords and map them in the triangulated
                    // faces for each face of the triangulation of the polygon
                    for (uint ff = fid; ff < m.faceCount(); ++ff) {
                        FaceType& f = m.face(ff);
                        // for each vertex of the face
                        for (uint i = 0; i < f.vertexCount(); ++i) {
                            uint vid = m.index(f.vertex(i));
                            // find the position of the vertex in the vids array
                            auto it = std::find(vids.begin(), vids.end(), vid);
                            assert(it != vids.end());
                            uint pos = it - vids.begin();
                            // check that the texcoord id is valid
                            if (wids[pos] >= wedgeTexCoords.size()) {
                                throw MalformedFileException(
                                    "Bad texcoord index for face " +
                                    std::to_string(fid));
                            }
                            // set the wedge texcoord in the same position of
                            // the vertex
                            f.wedgeTexCoord(i) =
                                wedgeTexCoords[wids[pos]]
                                    .cast<typename FaceType::WedgeTexCoordType::
                                              ScalarType>();
                        }
                    }
                }
            }
        }
    }
}
 
template<EdgeMeshConcept MeshType>
void readObjEdge(
    MeshType&           m,
    MeshInfo&           loadedInfo,
    const Tokenizer&    tokens,
    const ObjMaterial&  currentMaterial,
    const LoadSettings& settings)
{
    using EdgeType = MeshType::EdgeType;
 
    // add the edge
    uint      eid = m.addEdge();
    EdgeType& e   = m.edge(eid);
 
    // actual read - load vertex indices
    Tokenizer::iterator token = tokens.begin();
    ++token;
    uint vid1 = io::readUInt<uint>(token) - 1;
    uint vid2 = io::readUInt<uint>(token) - 1;
    e.setVertices(vid1, vid2);
}
 
template<MeshConcept MeshType, LoggerConcept LogType = NullLogger>
void loadObj(
    MeshType&                         m,
    std::istream&                     inputObjStream,
    const std::vector<std::istream*>& inputMtlStreams,
    MeshInfo&                         loadedInfo,
    const std::string&                filename     = "",
    bool                              ignoreMtlLib = false,
    const LoadSettings&               settings     = LoadSettings(),
    LogType&                          log          = nullLogger)
{
    loadedInfo.clear();
 
    // save array of normals, that are stored later
    std::vector<Point3d> normals;
 
    // save array of texcoords, that are stored later (into wedges when loading
    // faces or into vertices as a fallback)
    std::vector<TexCoordd> texCoords;
 
    // map of materials loaded
    std::map<std::string, detail::ObjMaterial> materialMap;
 
    // load materials from the material files, if any
    for (auto* stream : inputMtlStreams) {
        detail::loadObjMaterials(materialMap, m, *stream, loadedInfo, settings);
    }
 
    // the current material, set by 'usemtl'
    detail::ObjMaterial currentMaterial;
 
    if constexpr (HasMaterials<MeshType>) {
        m.meshBasePath() = FileInfo::pathWithoutFileName(filename);
    }
 
    if constexpr (HasName<MeshType>) {
        m.name() = FileInfo::fileNameWithoutExtension(filename);
    }
 
    inputObjStream.seekg(0, inputObjStream.end);
    std::size_t fsize = inputObjStream.tellg();
    inputObjStream.seekg(0, inputObjStream.beg);
    log.startProgress("Loading OBJ file", fsize);
 
    // cycle that reads line by line
    do {
        Tokenizer tokens =
            readAndTokenizeNextNonEmptyLineNoThrow(inputObjStream);
        if (inputObjStream) {
            Tokenizer::iterator token  = tokens.begin();
            std::string         header = *token++;
            if (header == "mtllib" && !ignoreMtlLib) { // material file
                // we load the material file if they are not ignored
                std::string mtlfile =
                    FileInfo::pathWithoutFileName(filename) + *token;
                try {
                    detail::loadObjMaterials(
                        materialMap, m, mtlfile, loadedInfo, settings);
                }
                catch (CannotOpenFileException) {
                    log.log(
                        "Cannot open material file " + mtlfile,
                        LogType::WARNING_LOG);
                }
            }
            // use a new material - change currentMaterial
            if (header == "usemtl") {
                std::string matname = *token;
                auto        it      = materialMap.find(matname);
                if (it != materialMap.end()) {
                    currentMaterial = it->second;
                }
                else { // material not found - warning
                    log.log(
                        "Material " + matname + " not found.",
                        LogType::WARNING_LOG);
                }
            }
            // read vertex (and for some non-standard obj files, also vertex
            // color)
            if (header == "v") {
                loadedInfo.setVertices();
                loadedInfo.setPerVertexPosition();
                detail::readObjVertex(m, token, loadedInfo, tokens, settings);
            }
            // read normals and save them in the vector of normasl, we will
            // store them in the mesh later
            if (header == "vn") {
                if constexpr (HasPerVertexNormal<MeshType>) {
                    Point3d n;
                    for (uint i = 0; i < 3; ++i) {
                        n[i] = io::readDouble<double>(token);
                    }
                    normals.push_back(n);
                }
            }
            // read texcoords and save them in the vector of texcoords, we will
            // store them in the mesh later
            if (header == "vt") {
                if constexpr (
                    HasPerVertexTexCoord<MeshType> ||
                    HasPerFaceWedgeTexCoords<MeshType>) {
                    // save the texcoord for later
                    TexCoordd tf;
                    for (uint i = 0; i < 2; ++i) {
                        tf[i] = io::readDouble<double>(token);
                    }
                    texCoords.push_back(tf);
                }
            }
            // read faces and manage:
            // - color
            // - eventual texcoords
            // - possibility to split polygonal face into several triangles
            if (header == "f") {
                loadedInfo.setFaces();
                loadedInfo.setPerFaceVertexReferences();
                if constexpr (HasFaces<MeshType>) {
                    detail::readObjFace(
                        m,
                        loadedInfo,
                        tokens,
                        normals,
                        texCoords,
                        currentMaterial,
                        settings);
                }
            }
            // read edges and manage their color
            if (header == "l") {
                loadedInfo.setEdges();
                loadedInfo.setPerEdgeVertexReferences();
                if constexpr (HasEdges<MeshType>) {
                    detail::readObjEdge(
                        m, loadedInfo, tokens, currentMaterial, settings);
                }
            }
            log.progress(inputObjStream.tellg());
        }
    } while (inputObjStream);
 
    if constexpr (HasPerVertexNormal<MeshType>) {
        using NormalType = typename MeshType::VertexType::NormalType;
        using NST        = typename NormalType::ScalarType;
        // if we have not yet set per-vertex normals, try to set them now
        if (!loadedInfo.hasPerVertexNormal()) {
            if (normals.size() == m.vertexCount()) {
                if (settings.enableOptionalComponents) {
                    enableIfPerVertexNormalOptional(m);
                    loadedInfo.setPerVertexNormal();
                }
                else {
                    if (isPerVertexNormalAvailable(m))
                        loadedInfo.setPerVertexNormal();
                }
 
                if (loadedInfo.hasPerVertexNormal()) {
                    for (uint i = 0; const auto& n : normals) {
                        m.vertex(i).normal() = n.template cast<NST>();
                        ++i;
                    }
                }
            }
        }
    }
 
    if constexpr (HasPerVertexTexCoord<MeshType>) {
        if (!loadedInfo.hasPerFaceWedgeTexCoords()) {
            if (texCoords.size() == m.vertexCount()) {
                // load texcoords into vertices only if there are no wedge
                if (settings.enableOptionalComponents) {
                    enableIfPerVertexTexCoordOptional(m);
                    loadedInfo.setPerVertexTexCoord();
                }
                else {
                    if (isPerVertexTexCoordAvailable(m))
                        loadedInfo.setPerVertexTexCoord();
                }
                if (loadedInfo.hasPerVertexTexCoord()) {
                    using TexCoordType =
                        typename MeshType::VertexType::TexCoordType;
                    using TCT = typename TexCoordType::ScalarType;
                    for (uint i = 0; i < m.vertexCount(); ++i) {
                        m.vertex(i).texCoord() =
                            texCoords[i].template cast<TCT>();
                    }
                }
 
                // material index
                if constexpr (HasMaterials<MeshType>) {
                    if (m.materialCount() > 0) {
                        if (settings.enableOptionalComponents) {
                            enableIfPerVertexMaterialIndexOptional(m);
                            loadedInfo.setPerVertexMaterialIndex();
                        }
                        else {
                            if (isPerVertexMaterialIndexAvailable(m))
                                loadedInfo.setPerVertexMaterialIndex();
                        }
                        if (loadedInfo.hasPerVertexMaterialIndex()) {
                            for (uint i = 0; i < m.vertexCount(); ++i) {
                                // assign the first material to all vertices
                                m.vertex(i).materialIndex() = 0;
                            }
                        }
                    }
                }
            }
        }
    }
 
    if constexpr (HasMaterials<MeshType>) {
        if (settings.loadTextureImages) {
            using enum Material::TextureType;
            loadTextureImages(m, m.meshBasePath(), {BASE_COLOR, EMISSIVE}, log);
        }
    }
 
    log.endProgress();
}
 
} // namespace detail
 
template<MeshConcept MeshType, LoggerConcept LogType = NullLogger>
void loadObj(
    MeshType&                         m,
    std::istream&                     inputObjStream,
    const std::vector<std::istream*>& inputMtlStreams,
    MeshInfo&                         loadedInfo,
    const LoadSettings&               settings = LoadSettings(),
    LogType&                          log      = nullLogger)
{
    detail::loadObj(
        m,
        inputObjStream,
        inputMtlStreams,
        loadedInfo,
        "",
        true,
        settings,
        log);
}
 
template<MeshConcept MeshType, LoggerConcept LogType = NullLogger>
void loadObj(
    MeshType&           m,
    const std::string&  filename,
    MeshInfo&           loadedInfo,
    const LoadSettings& settings = LoadSettings(),
    LogType&            log      = nullLogger)
{
    std::ifstream file = openInputFileStream(filename);
 
    // some obj files do not declare the material file name with mtllib, but
    // they assume that material file has the same name of the obj file.
    // Therefore, we first load this file if it exists.
    std::string stdmtlfile = FileInfo::pathWithoutFileName(filename) +
                             FileInfo::fileNameWithoutExtension(filename) +
                             ".mtl";
 
    std::ifstream              f;
    std::vector<std::istream*> mtlStreams;
    try {
        f = openInputFileStream(stdmtlfile);
        mtlStreams.push_back(&f);
    }
    catch (CannotOpenFileException) {
        // nothing to do, this file was missing, but this was a fallback for
        // some type of files...
    }
 
    detail::loadObj(
        m, file, mtlStreams, loadedInfo, filename, false, settings, log);
}
 
} // namespace vcl
 
#endif // VCL_IO_MESH_OBJ_LOAD_H