read_obj.hpp

/*
 * eos - A 3D Morphable Model fitting library written in modern C++11/14.
 *
 * File: include/eos/core/read_obj.hpp
 *
 * Copyright 2017, 2018 Patrik Huber
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#ifndef EOS_READ_OBJ_HPP
#define EOS_READ_OBJ_HPP
 
#include "eos/core/Mesh.hpp"
#include "eos/cpp17/optional.hpp"
 
#include "Eigen/Core"
 
#include <cassert>
#include <fstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
namespace eos {
namespace core {
 
namespace detail {
 
template <class ContainerType>
void tokenize(const std::string& str, ContainerType& tokens, const std::string& delimiters = " ",
              bool trim_empty = false)
{
    std::string::size_type pos, last_pos = 0;
    const auto length = str.length();
 
    using value_type = typename ContainerType::value_type;
    using size_type = typename ContainerType::size_type;
 
    while (last_pos < length + 1)
    {
        pos = str.find_first_of(delimiters, last_pos);
        if (pos == std::string::npos)
        {
            pos = length;
        }
 
        if (pos != last_pos || !trim_empty)
            tokens.push_back(value_type(str.data() + last_pos, (size_type)pos - last_pos));
 
        last_pos = pos + 1;
    }
};
 
inline std::pair<Eigen::Vector3f, cpp17::optional<Eigen::Vector3f>> parse_vertex(const std::string& line)
{
    std::vector<std::string> tokens;
    tokenize(line, tokens, " ", true); // compress multiple (and leading/trailing) whitespaces
    if (tokens.size() != 3 && tokens.size() != 6)
    {
        throw std::runtime_error(
            "Encountered a vertex ('v') line that does not consist of either 3 ('x y z') "
            "or 6 ('x y z r g b') numbers.");
    }
    const Eigen::Vector3f vertex(std::stof(tokens[0]), std::stof(tokens[1]), std::stof(tokens[2]));
    cpp17::optional<Eigen::Vector3f> vertex_color;
    if (tokens.size() == 6)
    {
        vertex_color = Eigen::Vector3f(std::stof(tokens[3]), std::stof(tokens[4]), std::stof(tokens[5]));
    }
    return {vertex, vertex_color};
};
 
inline Eigen::Vector2f parse_texcoords(const std::string& line)
{
    std::vector<std::string> tokens;
    tokenize(line, tokens, " ");
 
    if (tokens.size() != 2)
    {
        if (tokens.size() == 3 && std::stof(tokens[2]) == 0.f)
        {
            // we support this case too - 'u v 0'
        } else
        {
            throw std::runtime_error(
                "Encountered a texture coordinates ('vt') line that does not consist of two "
                "('u v') numbers. 'u v w' is only supported in the special case if w is 0.");
        }
    }
    const Eigen::Vector2f texcoords(std::stof(tokens[0]), std::stof(tokens[1]));
    return texcoords;
};
 
inline void parse_vertex_normal(const std::string& line)
{
    throw std::runtime_error("Parsing \"vn\" is not yet implemented.");
};
 
inline auto parse_face(const std::string& line)
{
    using std::string;
    using std::vector;
 
    // Obj indices are 1-based.
    vector<int> vertex_indices;  // size() = 3 or 4
    vector<int> texture_indices; // size() = 3 or 4
    vector<int> normal_indices;  // size() = 3 or 4
 
    vector<string> tokens;
    tokenize(line, tokens, " ", true); // compress multiple (and leading/trailing) whitespaces
    if (tokens.size() != 3 && tokens.size() != 4)
    {
        // For now we need this to be 3 (triangles) or 4 (quads)
        throw std::runtime_error("Encountered a faces ('f') line that does not consist of three or four "
                                 "blocks of numbers. We currently only support 3 blocks (triangle meshes) "
                                 "and 4 blocks (quad meshes).");
    }
    // Now for each of these tokens, we want to split on "/":
    for (const auto& token : tokens)
    {
        vector<string> subtokens;
        tokenize(token, subtokens, "/", false); // don't trim empty -if we do, we lose positional information.
        assert(subtokens.size() > 0 && subtokens.size() <= 3);
 
        // There should always be a vertex index:
        vertex_indices.push_back(std::stoi(subtokens[0]) - 1); // obj indices are 1-based, so we subtract one.
 
        if (subtokens.size() == 2)
        {
            // We've got texture coordinate indices as well:
            texture_indices.push_back(std::stoi(subtokens[1]) - 1);
        }
 
        if (subtokens.size() == 3)
        {
            // We've got either texcoord indices *and* normal indices, or just normal indices:
            if (!subtokens[1].empty())
            {
                // We do have texcoord indices
                texture_indices.push_back(std::stoi(subtokens[1]) - 1);
            }
            // And push_back the normal indices:
            normal_indices.push_back(std::stoi(subtokens[2]) - 1);
            // Note if we use normal indices in the future: It looked like they can be zero in some cases?
        }
    }
 
    return std::make_tuple(vertex_indices, texture_indices, normal_indices);
};
 
} /* namespace detail */
 
inline Mesh read_obj(std::string filename)
{
    std::ifstream file(filename);
    if (!file)
    {
        throw std::runtime_error(std::string("Could not open obj file: " + filename));
    }
 
    // We'll need these helper functions for the parsing:
    const auto starts_with = [](const std::string& input, const std::string& match) {
        return input.size() >= match.size() && std::equal(match.begin(), match.end(), input.begin());
    };
 
    /*    auto trim_left = [](const std::string& input, std::string pattern = " \t") {
            auto first = input.find_first_not_of(pattern);
            if (first == std::string::npos)
            {
                return input;
            }
            return input.substr(first, input.size());
        }; */
 
    Mesh mesh;
 
    std::string line;
    while (getline(file, line))
    {
        if (starts_with(line, "#"))
        {
            continue;
        }
 
        if (starts_with(line, "v "))
        { // matching with a space so that it doesn't match 'vt'
            const auto vertex_data =
                detail::parse_vertex(line.substr(2)); // pass the string without the first two characters
            mesh.vertices.push_back(vertex_data.first);
            if (vertex_data.second)
            { // there are vertex colours:
                mesh.colors.push_back(vertex_data.second.value());
            }
        }
        if (starts_with(line, "vt "))
        {
            const auto texcoords = detail::parse_texcoords(line.substr(3));
            mesh.texcoords.push_back(texcoords);
        }
        if (starts_with(line, "vn "))
        {
            // detail::parse_vertex_normal(line.substr(3));
            // Not handled yet, our Mesh class doesn't contain normals right now anyway.
        }
        // There's other things like "vp ", which we don't handle
        if (starts_with(line, "f "))
        {
            const auto face_data = detail::parse_face(line.substr(2));
            if (std::get<0>(face_data).size() == 3) // 3 triangle indices, nothing to do:
            {
                mesh.tvi.push_back(
                    {std::get<0>(face_data)[0], std::get<0>(face_data)[1], std::get<0>(face_data)[2]});
            }
            // If their sizes are 4, we convert the quad to two triangles:
            // Note: I think MeshLab does the same, it shows the number of "Faces" as twice the "f" entries
            // in the obj.
            else if (std::get<0>(face_data).size() == 4)
            {
                // Just create two faces with (quad[0], quad[1], quad[2]) and (quad[0], quad[2], quad[3]).
                mesh.tvi.push_back(
                    {std::get<0>(face_data)[0], std::get<0>(face_data)[1], std::get<0>(face_data)[2]});
                mesh.tvi.push_back(
                    {std::get<0>(face_data)[0], std::get<0>(face_data)[2], std::get<0>(face_data)[3]});
            }
            // We don't handle normal_indices for now.
        }
        // There can be other stuff in obj's like materials, named objects, etc., which are not handled here.
    }
    return mesh;
}
 
} /* namespace core */
} /* namespace eos */
 
#endif /* EOS_READ_OBJ_HPP */