| import os
|
| import numpy as np
|
|
|
|
|
| class MeshData(object):
|
| def __init__(self, **kwargs):
|
| self.name = kwargs.get("name")
|
| self.vertex_format = [
|
| ('v_pos', 3, 'float'),
|
| ('v_normal', 3, 'float'),
|
| ('v_tc0', 2, 'float'),
|
| ('v_ambient', 3, 'float'),
|
| ('v_diffuse', 3, 'float'),
|
| ('v_specular', 3, 'float')
|
| ]
|
| self.vertices = []
|
| self.indices = []
|
|
|
| self.diffuse_color = np.array([1.0, 1.0, 1.0])
|
| self.ambient_color = np.array([1.0, 1.0, 1.0])
|
| self.specular_color = np.array([1.0, 1.0, 1.0])
|
| self.specular_coefficent = 16.0
|
| self.transparency = 1.0
|
|
|
| def set_materials(self, mtl_dict):
|
| self.diffuse_color = mtl_dict.get('Kd', self.diffuse_color)
|
| self.diffuse_color = np.array([float(v) for v in self.diffuse_color])
|
| self.ambient_color = mtl_dict.get('Ka', self.ambient_color)
|
| self.ambient_color = np.array([float(v) for v in self.ambient_color])
|
| self.specular_color = mtl_dict.get('Ks', self.specular_color)
|
| self.specular_color = np.array([float(v) for v in self.specular_color])
|
| self.specular_coefficent = float(
|
| mtl_dict.get('Ns', self.specular_coefficent))
|
| transparency = mtl_dict.get('d')
|
| if not transparency:
|
| transparency = 1.0 - float(mtl_dict.get('Tr', 0))
|
| self.transparency = float(transparency)
|
|
|
|
|
| class MTL(object):
|
| def __init__(self, filename):
|
| self.contents = {}
|
| self.filename = filename
|
| if not os.path.exists(filename):
|
| return
|
| for line in open(filename, "r"):
|
| if line.startswith('#'):
|
| continue
|
| values = line.split()
|
| if not values:
|
| continue
|
| if values[0] == 'newmtl':
|
| mtl = self.contents[values[1]] = {}
|
| elif mtl is None:
|
| raise ValueError("mtl file doesn't start with newmtl stmt")
|
| if len(values[1:]) > 1:
|
| mtl[values[0]] = values[1:]
|
| else:
|
| mtl[values[0]] = values[1]
|
|
|
| def __getitem__(self, key):
|
| return self.contents[key]
|
|
|
| def get(self, key, default=None):
|
| return self.contents.get(key, default)
|
|
|
|
|
| class ObjHandle(object):
|
| """ """
|
|
|
| def __init__(self, filename=None, swapyz=False, delimiter=None,
|
| vertices=None, normals=None, texcoords=None, faces=None, face_norms=None, face_texs=None,
|
| obj_material=None, mtl=None, triangulate=False):
|
| if filename is not None:
|
| self.load(filename, swapyz, delimiter, triangulate=triangulate)
|
| else:
|
| self.vertices = np.array(vertices) if vertices is not None else np.array([])
|
| self.normals = np.array(normals) if normals is not None else np.array([])
|
| self.texcoords = np.array(texcoords) if texcoords is not None else np.array([])
|
| self.faces = np.array(faces) if faces is not None else np.array([[]])
|
| self.face_norms = np.array(face_norms) if face_norms is not None else np.empty((self.faces.shape[0], 0))
|
| self.face_texs = np.array(face_texs) if face_texs is not None else np.empty((self.faces.shape[0], 0))
|
| if swapyz:
|
| self.vertices = self.vertices[: [0, 2, 1]]
|
| self.normals = self.normals[: [0, 2, 1]]
|
|
|
| self.objects = {}
|
| self._current_object = None
|
| self.obj_material = obj_material
|
| self.mtl = mtl
|
|
|
| def load(self, filename, swapyz=False, delimiter=None, triangulate=False):
|
| """Loads a Wavefront OBJ file. """
|
| self.objects = {}
|
| self.vertices = []
|
| self.normals = []
|
| self.texcoords = []
|
| self.faces = []
|
| self.face_norms = []
|
| self.face_texs = []
|
|
|
| self._current_object = None
|
| self.mtl = None
|
| self.obj_material = None
|
|
|
| for line in open(filename, "r", encoding="utf8"):
|
| if delimiter is not None and delimiter == "# object" and "# object" in line:
|
| if self._current_object:
|
| self.finish_object()
|
| self._current_object = line.split()[2]
|
| if line.startswith('#'):
|
| continue
|
| if line.startswith('s'):
|
| continue
|
| values = line.split()
|
| if not values:
|
| continue
|
| if values[0] == 'o' and len(self.vertices) != 0:
|
| self.finish_object()
|
| self._current_object = values[1]
|
| elif values[0] == 'mtllib':
|
|
|
| self.mtl = MTL(values[1])
|
| elif values[0] in ('usemtl', 'usemat'):
|
| self.obj_material = values[1]
|
| if values[0] == 'v':
|
| v = list(map(float, values[1:4]))
|
| if swapyz:
|
| v = [v[0], v[2], v[1]]
|
|
|
| self.vertices.append(v)
|
| elif values[0] == 'vn':
|
| v = list(map(float, values[1:4]))
|
| if swapyz:
|
| v = [v[0], v[2], v[1]]
|
|
|
| self.normals.append(v)
|
| elif values[0] == 'vt':
|
| self.texcoords.append(list(map(float, values[1:3])))
|
| elif values[0] == 'f':
|
| if not triangulate or len(values) == 4:
|
| face = []
|
| texcoords = []
|
| norms = []
|
| for v in values[1:]:
|
| w = v.split('/')
|
| face.append(int(w[0]) - 1)
|
| if len(w) >= 2 and len(w[1]) > 0:
|
| if '//' not in v:
|
| texcoords.append(int(w[1]) - 1)
|
| else:
|
| norms.append(int(w[1]) - 1)
|
| if len(w) >= 3 and len(w[2]) > 0:
|
| norms.append(int(w[2]) - 1)
|
| self.faces.append(face)
|
| self.face_norms.append(norms)
|
| self.face_texs.append(texcoords)
|
| else:
|
|
|
| face = []
|
| texcoords = []
|
| norms = []
|
| for v in values[1:4]:
|
| w = v.split('/')
|
| face.append(int(w[0]) - 1)
|
| if len(w) >= 2 and len(w[1]) > 0:
|
| if '//' not in v:
|
| texcoords.append(int(w[1]) - 1)
|
| else:
|
| norms.append(int(w[1]) - 1)
|
| if len(w) >= 3 and len(w[2]) > 0:
|
| norms.append(int(w[2]) - 1)
|
| self.faces.append(face)
|
| self.face_norms.append(norms)
|
| self.face_texs.append(texcoords)
|
|
|
| face = []
|
| texcoords = []
|
| norms = []
|
| for v in [values[1], values[3], values[4]]:
|
| w = v.split('/')
|
| face.append(int(w[0]) - 1)
|
| if len(w) >= 2 and len(w[1]) > 0:
|
| if '//' not in v:
|
| texcoords.append(int(w[1]) - 1)
|
| else:
|
| norms.append(int(w[1]) - 1)
|
| if len(w) >= 3 and len(w[2]) > 0:
|
| norms.append(int(w[2]) - 1)
|
| self.faces.append(face)
|
| self.face_norms.append(norms)
|
| self.face_texs.append(texcoords)
|
|
|
| self.finish_object()
|
|
|
| def finish_object(self):
|
| self.vertices = np.array(self.vertices)
|
| self.normals = np.array(self.normals)
|
| self.texcoords = np.array(self.texcoords)
|
| self.faces = np.array(self.faces)
|
| self.face_norms = np.array(self.face_norms)
|
| self.face_texs = np.array(self.face_texs)
|
| if self._current_object is None:
|
| return
|
|
|
| mesh = MeshData()
|
| idx = 0
|
| material = self.mtl.get(self.obj_material)
|
| if material:
|
| mesh.set_materials(material)
|
| for verts, norms, tcs in zip(self.faces, self.face_norms, self.face_texs):
|
|
|
|
|
|
|
| for i in range(3):
|
|
|
| n = np.array([0.0, 0.0, 0.0])
|
| if norms is not None:
|
| n = self.normals[norms[i] - 1]
|
|
|
|
|
| t = np.array([0.0, 0.0])
|
| if tcs is not None:
|
| t = self.texcoords[tcs[i] - 1]
|
|
|
|
|
| v = self.vertices[verts[i] - 1]
|
|
|
| data = [v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1]]
|
| mesh.vertices.extend(data)
|
|
|
|
|
| mesh.vertices.extend(
|
| mesh.ambient_color +
|
| mesh.diffuse_color +
|
| mesh.specular_color
|
| )
|
|
|
| tri = [idx, idx + 1, idx + 2]
|
| mesh.indices.extend(tri)
|
| idx += 3
|
|
|
| mesh.vertices = np.array(mesh.vertices)
|
| mesh.indices = np.array(mesh.indices)
|
|
|
| self.objects[self._current_object] = mesh
|
|
|
| self.faces = []
|
|
|
| def write(self, filename, swapyz=False):
|
|
|
| with open(filename, 'w') as f:
|
| if self.mtl is not None:
|
| f.write(f"mtllib {self.mtl.filename}\n")
|
| for v in self.vertices:
|
| if swapyz:
|
| v = v[0], v[2], v[1]
|
| f.write(f"v {v[0]:.6f} {v[1]:.6f} {v[2]:.6f}\n")
|
|
|
| if self.texcoords.size != 0:
|
| for vt in self.texcoords:
|
| f.write(f"vt {vt[0]:.6f} {vt[1]:.6f}\n")
|
| if self.normals.size != 0:
|
| for vn in self.normals:
|
| if swapyz:
|
| vn = vn[0], vn[2], vn[1]
|
| f.write(f"vn {vn[0]:.6f} {vn[1]:.6f} {vn[2]:.6f}\n")
|
| if self.obj_material is not None:
|
| f.write(f"usemtl {self.obj_material}\n")
|
| for verts, norms, tcs in zip(self.faces, self.face_norms, self.face_texs):
|
| f.write("f ")
|
| for i in range(verts.shape[0]):
|
| f.write(f"{verts[i] + 1}")
|
|
|
| if tcs.size != 0:
|
| f.write(f"/{tcs[i] + 1}")
|
| elif norms.size != 0:
|
| f.write("/")
|
| if norms.size != 0:
|
| f.write(f"/{norms[i] + 1}")
|
|
|
| if i != verts.shape[0] - 1:
|
| f.write(" ")
|
| f.write("\n")
|
|
|
