import numpy as np def save_obj_mesh(mesh_path, verts, faces): file = open(mesh_path, 'w') for v in verts: file.write('v %.4f %.4f %.4f\n' % (v[0], v[1], v[2])) for f in faces: f_plus = f + 1 file.write('f %d %d %d\n' % (f_plus[0], f_plus[1], f_plus[2])) file.close() # https://github.com/ratcave/wavefront_reader def read_mtlfile(fname): materials = {} with open(fname) as f: lines = f.read().splitlines() for line in lines: if line: split_line = line.strip().split(' ', 1) if len(split_line) < 2: continue prefix, data = split_line[0], split_line[1] if 'newmtl' in prefix: material = {} materials[data] = material elif materials: if data: split_data = data.strip().split(' ') # assume texture maps are in the same level # WARNING: do not include space in your filename!! if 'map' in prefix: material[prefix] = split_data[-1].split('\\')[-1] elif len(split_data) > 1: material[prefix] = tuple(float(d) for d in split_data) else: try: material[prefix] = int(data) except ValueError: material[prefix] = float(data) return materials def load_obj_mesh_mtl(mesh_file): vertex_data = [] norm_data = [] uv_data = [] face_data = [] face_norm_data = [] face_uv_data = [] # face per material face_data_mat = {} face_norm_data_mat = {} face_uv_data_mat = {} # current material name mtl_data = None cur_mat = None if isinstance(mesh_file, str): f = open(mesh_file, "r") else: f = mesh_file for line in f: if isinstance(line, bytes): line = line.decode("utf-8") if line.startswith('#'): continue values = line.split() if not values: continue if values[0] == 'v': v = list(map(float, values[1:4])) vertex_data.append(v) elif values[0] == 'vn': vn = list(map(float, values[1:4])) norm_data.append(vn) elif values[0] == 'vt': vt = list(map(float, values[1:3])) uv_data.append(vt) elif values[0] == 'mtllib': mtl_data = read_mtlfile(mesh_file.replace(mesh_file.split('/')[-1],values[1])) elif values[0] == 'usemtl': cur_mat = values[1] elif values[0] == 'f': # local triangle data l_face_data = [] l_face_uv_data = [] l_face_norm_data = [] # quad mesh if len(values) > 4: f = list(map(lambda x: int(x.split('/')[0]) if int(x.split('/')[0]) < 0 else int(x.split('/')[0])-1, values[1:4])) l_face_data.append(f) f = list(map(lambda x: int(x.split('/')[0]) if int(x.split('/')[0]) < 0 else int(x.split('/')[0])-1, [values[3], values[4], values[1]])) l_face_data.append(f) # tri mesh else: f = list(map(lambda x: int(x.split('/')[0]) if int(x.split('/')[0]) < 0 else int(x.split('/')[0])-1, values[1:4])) l_face_data.append(f) # deal with texture if len(values[1].split('/')) >= 2: # quad mesh if len(values) > 4: f = list(map(lambda x: int(x.split('/')[1]) if int(x.split('/')[1]) < 0 else int(x.split('/')[1])-1, values[1:4])) l_face_uv_data.append(f) f = list(map(lambda x: int(x.split('/')[1]) if int(x.split('/')[1]) < 0 else int(x.split('/')[1])-1, [values[3], values[4], values[1]])) l_face_uv_data.append(f) # tri mesh elif len(values[1].split('/')[1]) != 0: f = list(map(lambda x: int(x.split('/')[1]) if int(x.split('/')[1]) < 0 else int(x.split('/')[1])-1, values[1:4])) l_face_uv_data.append(f) # deal with normal if len(values[1].split('/')) == 3: # quad mesh if len(values) > 4: f = list(map(lambda x: int(x.split('/')[2]) if int(x.split('/')[2]) < 0 else int(x.split('/')[2])-1, values[1:4])) l_face_norm_data.append(f) f = list(map(lambda x: int(x.split('/')[2]) if int(x.split('/')[2]) < 0 else int(x.split('/')[2])-1, [values[3], values[4], values[1]])) l_face_norm_data.append(f) # tri mesh elif len(values[1].split('/')[2]) != 0: f = list(map(lambda x: int(x.split('/')[2]) if int(x.split('/')[2]) < 0 else int(x.split('/')[2])-1, values[1:4])) l_face_norm_data.append(f) face_data += l_face_data face_uv_data += l_face_uv_data face_norm_data += l_face_norm_data if cur_mat is not None: if cur_mat not in face_data_mat.keys(): face_data_mat[cur_mat] = [] if cur_mat not in face_uv_data_mat.keys(): face_uv_data_mat[cur_mat] = [] if cur_mat not in face_norm_data_mat.keys(): face_norm_data_mat[cur_mat] = [] face_data_mat[cur_mat] += l_face_data face_uv_data_mat[cur_mat] += l_face_uv_data face_norm_data_mat[cur_mat] += l_face_norm_data vertices = np.array(vertex_data) faces = np.array(face_data) norms = np.array(norm_data) norms = normalize_v3(norms) face_normals = np.array(face_norm_data) uvs = np.array(uv_data) face_uvs = np.array(face_uv_data) out_tuple = (vertices, faces, norms, face_normals, uvs, face_uvs) if cur_mat is not None and mtl_data is not None: for key in face_data_mat: face_data_mat[key] = np.array(face_data_mat[key]) face_uv_data_mat[key] = np.array(face_uv_data_mat[key]) face_norm_data_mat[key] = np.array(face_norm_data_mat[key]) out_tuple += (face_data_mat, face_norm_data_mat, face_uv_data_mat, mtl_data) return out_tuple def load_obj_mesh(mesh_file, with_normal=False, with_texture=False): vertex_data = [] norm_data = [] uv_data = [] face_data = [] face_norm_data = [] face_uv_data = [] if isinstance(mesh_file, str): f = open(mesh_file, "r") else: f = mesh_file for line in f: if isinstance(line, bytes): line = line.decode("utf-8") if line.startswith('#'): continue values = line.split() if not values: continue if values[0] == 'v': v = list(map(float, values[1:4])) vertex_data.append(v) elif values[0] == 'vn': vn = list(map(float, values[1:4])) norm_data.append(vn) elif values[0] == 'vt': vt = list(map(float, values[1:3])) uv_data.append(vt) elif values[0] == 'f': # quad mesh if len(values) > 4: f = list(map(lambda x: int(x.split('/')[0]), values[1:4])) face_data.append(f) f = list(map(lambda x: int(x.split('/')[0]), [values[3], values[4], values[1]])) face_data.append(f) # tri mesh else: f = list(map(lambda x: int(x.split('/')[0]), values[1:4])) face_data.append(f) # deal with texture if len(values[1].split('/')) >= 2: # quad mesh if len(values) > 4: f = list(map(lambda x: int(x.split('/')[1]), values[1:4])) face_uv_data.append(f) f = list(map(lambda x: int(x.split('/')[1]), [values[3], values[4], values[1]])) face_uv_data.append(f) # tri mesh elif len(values[1].split('/')[1]) != 0: f = list(map(lambda x: int(x.split('/')[1]), values[1:4])) face_uv_data.append(f) # deal with normal if len(values[1].split('/')) == 3: # quad mesh if len(values) > 4: f = list(map(lambda x: int(x.split('/')[2]), values[1:4])) face_norm_data.append(f) f = list(map(lambda x: int(x.split('/')[2]), [values[3], values[4], values[1]])) face_norm_data.append(f) # tri mesh elif len(values[1].split('/')[2]) != 0: f = list(map(lambda x: int(x.split('/')[2]), values[1:4])) face_norm_data.append(f) vertices = np.array(vertex_data) faces = np.array(face_data) - 1 if with_texture and with_normal: uvs = np.array(uv_data) face_uvs = np.array(face_uv_data) - 1 norms = np.array(norm_data) if norms.shape[0] == 0: norms = compute_normal(vertices, faces) face_normals = faces else: norms = normalize_v3(norms) face_normals = np.array(face_norm_data) - 1 return vertices, faces, norms, face_normals, uvs, face_uvs if with_texture: uvs = np.array(uv_data) face_uvs = np.array(face_uv_data) - 1 return vertices, faces, uvs, face_uvs if with_normal: norms = np.array(norm_data) norms = normalize_v3(norms) face_normals = np.array(face_norm_data) - 1 return vertices, faces, norms, face_normals return vertices, faces def normalize_v3(arr): ''' Normalize a numpy array of 3 component vectors shape=(n,3) ''' lens = np.sqrt(arr[:, 0] ** 2 + arr[:, 1] ** 2 + arr[:, 2] ** 2) eps = 0.00000001 lens[lens < eps] = eps arr[:, 0] /= lens arr[:, 1] /= lens arr[:, 2] /= lens return arr def compute_normal(vertices, faces): # Create a zeroed array with the same type and shape as our vertices i.e., per vertex normal norm = np.zeros(vertices.shape, dtype=vertices.dtype) # Create an indexed view into the vertex array using the array of three indices for triangles tris = vertices[faces] # Calculate the normal for all the triangles, by taking the cross product of the vectors v1-v0, and v2-v0 in each triangle n = np.cross(tris[::, 1] - tris[::, 0], tris[::, 2] - tris[::, 0]) # n is now an array of normals per triangle. The length of each normal is dependent the vertices, # we need to normalize these, so that our next step weights each normal equally. normalize_v3(n) # now we have a normalized array of normals, one per triangle, i.e., per triangle normals. # But instead of one per triangle (i.e., flat shading), we add to each vertex in that triangle, # the triangles' normal. Multiple triangles would then contribute to every vertex, so we need to normalize again afterwards. # The cool part, we can actually add the normals through an indexed view of our (zeroed) per vertex normal array norm[faces[:, 0]] += n norm[faces[:, 1]] += n norm[faces[:, 2]] += n normalize_v3(norm) return norm # compute tangent and bitangent def compute_tangent(vertices, faces, normals, uvs, faceuvs): # NOTE: this could be numerically unstable around [0,0,1] # but other current solutions are pretty freaky somehow c1 = np.cross(normals, np.array([0,1,0.0])) tan = c1 normalize_v3(tan) btan = np.cross(normals, tan) # NOTE: traditional version is below # pts_tris = vertices[faces] # uv_tris = uvs[faceuvs] # W = np.stack([pts_tris[::, 1] - pts_tris[::, 0], pts_tris[::, 2] - pts_tris[::, 0]],2) # UV = np.stack([uv_tris[::, 1] - uv_tris[::, 0], uv_tris[::, 2] - uv_tris[::, 0]], 1) # for i in range(W.shape[0]): # W[i,::] = W[i,::].dot(np.linalg.inv(UV[i,::])) # tan = np.zeros(vertices.shape, dtype=vertices.dtype) # tan[faces[:,0]] += W[:,:,0] # tan[faces[:,1]] += W[:,:,0] # tan[faces[:,2]] += W[:,:,0] # btan = np.zeros(vertices.shape, dtype=vertices.dtype) # btan[faces[:,0]] += W[:,:,1] # btan[faces[:,1]] += W[:,:,1] # btan[faces[:,2]] += W[:,:,1] # normalize_v3(tan) # ndott = np.sum(normals*tan, 1, keepdims=True) # tan = tan - ndott * normals # normalize_v3(btan) # normalize_v3(tan) # tan[np.sum(np.cross(normals, tan) * btan, 1) < 0,:] *= -1.0 return tan, btan if __name__ == '__main__': pts, tri, nml, trin, uvs, triuv = load_obj_mesh('/home/ICT2000/ssaito/Documents/Body/tmp/Baseball_Pitching/0012.obj', True, True) compute_tangent(pts, tri, uvs, triuv)