1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
//
// loader.cpp
// Loop
//
// Created by Jingwei on 10/22/17.
// Copyright © 2017 Jingwei. All rights reserved.
//
#include "loader.hpp"
#include <fstream>
#include <unordered_map>
namespace qflow {
inline std::vector<std::string> &str_tokenize(const std::string &s, char delim, std::vector<std::string> &elems, bool include_empty = false) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim))
if (!item.empty() || include_empty)
elems.push_back(item);
return elems;
}
inline std::vector<std::string> str_tokenize(const std::string &s, char delim, bool include_empty) {
std::vector<std::string> elems;
str_tokenize(s, delim, elems, include_empty);
return elems;
}
inline uint32_t str_to_uint32_t(const std::string &str) {
char *end_ptr = nullptr;
uint32_t result = (uint32_t)strtoul(str.c_str(), &end_ptr, 10);
if (*end_ptr != '\0')
throw std::runtime_error("Could not parse unsigned integer \"" + str + "\"");
return result;
}
void load(const char* filename, MatrixXd& V, MatrixXi& F)
{
/// Vertex indices used by the OBJ format
struct obj_vertex {
uint32_t p = (uint32_t)-1;
uint32_t n = (uint32_t)-1;
uint32_t uv = (uint32_t)-1;
inline obj_vertex() { }
inline obj_vertex(const std::string &string) {
std::vector<std::string> tokens = str_tokenize(string, '/', true);
if (tokens.size() < 1 || tokens.size() > 3)
throw std::runtime_error("Invalid vertex data: \"" + string + "\"");
p = str_to_uint32_t(tokens[0]);
#if 0
if (tokens.size() >= 2 && !tokens[1].empty())
uv = str_to_uint32_t(tokens[1]);
if (tokens.size() >= 3 && !tokens[2].empty())
n = str_to_uint32_t(tokens[2]);
#endif
}
inline bool operator==(const obj_vertex &v) const {
return v.p == p && v.n == n && v.uv == uv;
}
};
/// Hash function for obj_vertex
struct obj_vertexHash : std::unary_function<obj_vertex, size_t> {
std::size_t operator()(const obj_vertex &v) const {
size_t hash = std::hash<uint32_t>()(v.p);
hash = hash * 37 + std::hash<uint32_t>()(v.uv);
hash = hash * 37 + std::hash<uint32_t>()(v.n);
return hash;
}
};
typedef std::unordered_map<obj_vertex, uint32_t, obj_vertexHash> VertexMap;
std::ifstream is(filename);
std::vector<Vector3d> positions;
//std::vector<Vector2d> texcoords;
//std::vector<Vector3d> normals;
std::vector<uint32_t> indices;
std::vector<obj_vertex> vertices;
VertexMap vertexMap;
std::string line_str;
while (std::getline(is, line_str)) {
std::istringstream line(line_str);
std::string prefix;
line >> prefix;
if (prefix == "v") {
Vector3d p;
line >> p.x() >> p.y() >> p.z();
positions.push_back(p);
}
else if (prefix == "vt") {
/*
Vector2d tc;
line >> tc.x() >> tc.y();
texcoords.push_back(tc);
*/
}
else if (prefix == "vn") {
/*
Vector3d n;
line >> n.x() >> n.y() >> n.z();
normals.push_back(n);
*/
}
else if (prefix == "f") {
std::string v1, v2, v3, v4;
line >> v1 >> v2 >> v3 >> v4;
obj_vertex tri[6];
int nVertices = 3;
tri[0] = obj_vertex(v1);
tri[1] = obj_vertex(v2);
tri[2] = obj_vertex(v3);
if (!v4.empty()) {
/* This is a quad, split into two triangles */
tri[3] = obj_vertex(v4);
tri[4] = tri[0];
tri[5] = tri[2];
nVertices = 6;
}
/* Convert to an indexed vertex list */
for (int i = 0; i<nVertices; ++i) {
const obj_vertex &v = tri[i];
VertexMap::const_iterator it = vertexMap.find(v);
if (it == vertexMap.end()) {
vertexMap[v] = (uint32_t)vertices.size();
indices.push_back((uint32_t)vertices.size());
vertices.push_back(v);
}
else {
indices.push_back(it->second);
}
}
}
}
F.resize(3, indices.size() / 3);
memcpy(F.data(), indices.data(), sizeof(uint32_t)*indices.size());
V.resize(3, vertices.size());
for (uint32_t i = 0; i<vertices.size(); ++i)
V.col(i) = positions.at(vertices[i].p - 1);
}
} // namespace qflow
|
