def show_polyscope(self): # Shows a polyscope window (https://polyscope.run/py/) of the current MeshSet, rendering all the meshes contained # in it. Requires the polyscope package (pip install polyscope). import polyscope import numpy polyscope.init() for m in self: is_enabled = m.is_visible() if m.is_point_cloud(): psm = polyscope.register_point_cloud(m.label(), m.transformed_vertex_matrix(), enabled=is_enabled) else: psm = polyscope.register_surface_mesh( m.label(), m.transformed_vertex_matrix(), m.face_matrix(), enabled=is_enabled) if m.has_vertex_color(): vc = m.vertex_color_matrix() vc = numpy.delete(vc, 3, 1) psm.add_color_quantity('vertex_color', vc) if m.has_vertex_scalar(): psm.add_scalar_quantity('vertex_scalar', m.vertex_scalar_array()) if not m.is_point_cloud() and m.has_face_color(): fc = m.face_color_matrix() fc = numpy.delete(fc, 3, 1) psm.add_color_quantity('face_color', fc, defined_on='faces') if not m.is_point_cloud() and m.has_face_scalar(): psm.add_scalar_quantity('face_scalar', m.face_scalar_array(), defined_on='faces') polyscope.show()
def show(self): "use polyscope : https://polyscope.run/py/ " assert 0, "TODO" import polyscope as ps ps.init() ### Register a point cloud # `my_points` is a Nx3 numpy array #ps.register_point_cloud("my points", my_points) ### Register a mesh # `verts` is a Nx3 numpy array of vertex positions # `faces` is a Fx3 array of indices, or a nested list # ... ps.register_surface_mesh("my mesh", verts, faces, smooth_shade=True) ps.show()
def show_mesh_in_ply_file(obj_file): ps.init() vertex_pos = [] face_indices = [] flag = False with open(obj_file) as f_in: for line in f_in: temp = line.split(' ') if line == 'end_header\n': print('loading data') flag = True continue if flag == True: if temp[0] == '3': face_indices.append(np.array([int(temp[1]), int(temp[2]), int(temp[3])])) else: vertex_pos.append(np.array([float(temp[0]), float(temp[1]), float(temp[2])])) points = np.array(vertex_pos) faces = np.array(face_indices) ps_mesh = ps.register_surface_mesh("result mesh", points, faces) ps.set_autoscale_structures(True) ps.show()
numpy.random.seed(777) return numpy.random.rand(n_pts, 3) def generate_faces(n_pts=10): numpy.random.seed(777) return numpy.random.randint(0, n_pts, size=(2 * n_pts, 3)) verts, faces = generate_verts(), generate_faces() ### Register a point cloud # `my_points` is a Nx3 numpy array # ps.register_point_cloud("my points", my_points) ### Register a mesh # `verts` is a Nx3 numpy array of vertex positions # `faces` is a Fx3 array of indices, or a nested list polyscope.register_surface_mesh("my mesh", verts, faces, smooth_shade=True) # Add a scalar function and a vector function defined on the mesh # vertex_scalar is a length V numpy array of values # face_vectors is an Fx3 array of vectors per face # ps.get_surface_mesh("my mesh").add_scalar_quantity("my_scalar", # vertex_scalar, defined_on='vertices', cmap='blues') # ps.get_surface_mesh("my mesh").add_vector_quantity("my_vector", # face_vectors, defined_on='faces', color=(0.2, 0.5, 0.5)) # View the point cloud and mesh we just registered in the 3D UI polyscope.show()
verts, faces = util.triangulate_surface(surface, n) uv = surface.coordinates(n) normals = surface.unit_normals(uv) jacobians = surface.df(uv) k1d, k2d = np.array(surface.principal_direction(uv)) push_forward_k1d = np.einsum('ij,ikj->ik', k1d, jacobians) push_forward_k2d = np.einsum('ij,ikj->ik', k2d, jacobians) k1, k2 = np.array(surface.principal_curvature(uv)) #=================================== # Register Surface ps_mesh = ps.register_surface_mesh(name, verts, faces) S = surface.shape_index(uv) S_colors = np.array([np.array(shape_scale_to_color(s)) for s in S]) ps.get_surface_mesh(name).add_color_quantity("S_colormap", S_colors, defined_on='vertices') ps.get_surface_mesh(name).add_scalar_quantity("S", S, defined_on='vertices', cmap='viridis') # Register Surface Normals ps.get_surface_mesh(name).add_vector_quantity( "normals", np.array(normals),
def main(): parser = argparse.ArgumentParser() parser.add_argument('model_weights_path', type=str, help='path to the model checkpoint') parser.add_argument('input_path', type=str, help='path to the input') parser.add_argument('--disable_cuda', action='store_true', help='disable cuda') parser.add_argument('--sample_cloud', type=int, help='run on sampled points') parser.add_argument('--n_rounds', type=int, default=5, help='number of rounds') parser.add_argument('--prob_thresh', type=float, default=.9, help='threshold for final surface') parser.add_argument( '--output', type=str, help='path to save the resulting high prob mesh to. also disables viz') parser.add_argument('--output_trim_unused', action='store_true', help='trim unused vertices when outputting') # Parse arguments args = parser.parse_args() set_args_defaults(args) viz = not args.output args.polyscope = False # Initialize polyscope if viz: polyscope.init() # === Load the input if args.input_path.endswith(".npz"): record = np.load(args.input_path) verts = torch.tensor(record['vert_pos'], dtype=args.dtype, device=args.device) surf_samples = torch.tensor(record['surf_pos'], dtype=args.dtype, device=args.device) samples = verts.clone() faces = torch.zeros((0, 3), dtype=torch.int64, device=args.device) polyscope.register_point_cloud("surf samples", toNP(surf_samples)) if args.input_path.endswith(".xyz"): raw_pts = np.loadtxt(args.input_path) verts = torch.tensor(raw_pts, dtype=args.dtype, device=args.device) samples = verts.clone() faces = torch.zeros((0, 3), dtype=torch.int64, device=args.device) polyscope.register_point_cloud("surf samples", toNP(verts)) else: print("reading mesh") verts, faces = utils.read_mesh(args.input_path) print(" {} verts {} faces".format(verts.shape[0], faces.shape[0])) verts = torch.tensor(verts, dtype=args.dtype, device=args.device) faces = torch.tensor(faces, dtype=torch.long, device=args.device) # verts = verts[::10,:] if args.sample_cloud: samples = mesh_utils.sample_points_on_surface( verts, faces, args.sample_cloud) else: samples = verts.clone() # === Load the model print("loading model weights") model = PointTriNet_Mesher() model.load_state_dict(torch.load(args.model_weights_path)) model.eval() with torch.no_grad(): # Sample lots of faces from the vertices print("predicting") candidate_triangles, candidate_probs = model.predict_mesh( samples.unsqueeze(0), n_rounds=args.n_rounds) candidate_triangles = candidate_triangles.squeeze(0) candidate_probs = candidate_probs.squeeze(0) print("done predicting") # Visualize high_prob = args.prob_thresh high_faces = candidate_triangles[candidate_probs > high_prob] closed_faces = mesh_utils.fill_holes_greedy(high_faces) if viz: polyscope.register_point_cloud("input points", toNP(samples)) spmesh = polyscope.register_surface_mesh("all faces", toNP(samples), toNP(candidate_triangles), enabled=False) spmesh.add_scalar_quantity("probs", toNP(candidate_probs), defined_on='faces') spmesh = polyscope.register_surface_mesh( "high prob mesh " + str(high_prob), toNP(samples), toNP(high_faces)) spmesh.add_scalar_quantity( "probs", toNP(candidate_probs[candidate_probs > high_prob]), defined_on='faces') spmesh = polyscope.register_surface_mesh("hole-closed mesh " + str(high_prob), toNP(samples), toNP(closed_faces), enabled=False) polyscope.show() # Save output if args.output: high_prob = args.prob_thresh out_verts = toNP(samples) out_faces = toNP(high_faces) out_faces_closed = toNP(closed_faces) if args.output_trim_unused: out_verts, out_faces, _, _ = igl.remove_unreferenced( out_verts, out_faces) igl.write_triangle_mesh(args.output + "_mesh.ply", out_verts, out_faces) write_ply_points(args.output + "_samples.ply", toNP(samples)) igl.write_triangle_mesh(args.output + "_pred_mesh.ply", out_verts, out_faces) igl.write_triangle_mesh(args.output + "_pred_mesh_closed.ply", out_verts, out_faces_closed) write_ply_points(args.output + "_samples.ply", toNP(samples))
tree = Union('u2', [ Cylinder(1.0, 2.0, 's1'), Pose([1.0, 0.0, 0.0], [45.0, 45.0, 45.0], [Box([1.0, 1.0, 1.0], 'b1')], 'p1') ]) with open('data/bobbin.json') as json_file: tree = node_from_old_json_format(json.load(json_file), False) print('loaded tree: {}'.format(tree.to_dict())) print(tree.to_dict()) tree2 = CSGNode.from_dict(tree.to_dict()) print(tree2.to_dict()) print(json.dumps(tree2.to_dict())) # uncomment the following line for stack test # tree = node_from_stack_format('data/stack.txt') pc = point_cloud_from_node(tree, [-20, -20, -20], [20, 20, 20], 0.2, 0.2) v, f, n = node_to_mesh(tree, [-20, -20, -20], [20, 20, 20], 0.8) ps.init() ps.register_surface_mesh("mesh 1", v, f) ps.register_point_cloud("points 1", pc) ps.show()
# Load SMPL model smpl = SMPL(config.SMPL_MODEL_DIR, batch_size=1, create_transl=False).to(device) model.eval() ret, first_frame = cap.read() cv2.imshow('frame', first_frame) # Preprocess input image and generate predictions first_joints, first_vertices = get_prediction(first_frame) edges = np.array([[2, 3], [3, 4], [5, 6], [6, 7], [9, 10], [10, 11], [12, 13], [13, 14], [14, 19], [14, 20], [14, 21], [11, 22], [11, 23], [11, 24], [12, 8], [8, 9], [8, 41], [41, 40], [37, 43], [40, 5], [40, 2], [40, 37]]) ps.init() ps_net = ps.register_curve_network("my network", first_joints, edges) ps_mesh = ps.register_surface_mesh("my mesh", first_vertices, smpl.faces) ps.show() # Setup renderer for visualization # renderer = Renderer(focal_length=constants.FOCAL_LENGTH, img_res=constants.IMG_RES, faces=smpl.faces) # outfile = args.img.split('.')[0] if args.outfile is None else args.outfile while True: _, current_frame = cap.read() cv2.imshow('frame', current_frame) current_joints, current_vertices = get_prediction(current_frame) next_frame(current_joints, current_vertices) if cv2.waitKey(1) & 0xFF == ord('q'): break
# import scipy.sparse.linalg as sla # Path to where the bindings live sys.path.append(os.path.join(os.path.dirname(__file__), "../build/")) sys.path.append(os.path.join(os.path.dirname(__file__), "../src/")) import potpourri3d as pp3d ps.init() # Read input ## = Mesh test # V, F = pp3d.read_mesh("/Users/nick/mesh/spot.obj") V, F = pp3d.read_mesh("bunny_small.ply") ps_mesh = ps.register_surface_mesh("mesh", V, F) # Distance dists = pp3d.compute_distance(V, F, 4) ps_mesh.add_scalar_quantity("dist", dists) # Vector heat solver = pp3d.MeshVectorHeatSolver(V, F) # Vector heat (extend scalar) ext = solver.extend_scalar([1, 22], [0., 6.]) ps_mesh.add_scalar_quantity("ext", ext) # Vector heat (tangent frames) basisX, basisY, basisN = solver.get_tangent_frames() ps_mesh.add_vector_quantity("basisX", basisX)
def add_surface_mesh(self, name, obj_path, **kwargs): verts, faces = load_obj_robust(obj_path) ps.register_surface_mesh(name, verts.numpy(), faces.numpy(), **kwargs)
#!/usr/bin/env python3 # Visualization example with polyscope (pip install polyscope) # https://polyscope.run/py/ import vedo import polyscope m = vedo.load(vedo.dataurl+'embryo.tif').isosurface().extractLargestRegion() # m = vedo.load(vedo.dataurl+'man.vtk') polyscope.set_program_name("vedo using polyscope") polyscope.set_verbosity(0) polyscope.set_up_dir("z_up") polyscope.init() ps_mesh = polyscope.register_surface_mesh('My vedo mesh', m.points(), m.faces(), color=[0.5,0,0], smooth_shade=True, ) ps_mesh.add_scalar_quantity("heights", m.points()[:,2], defined_on='vertices') ps_mesh.set_material("wax") # wax, mud, jade, candy polyscope.show() vedo.show(m, axes=11)
import open3d import polyscope as ps import numpy as np path = "/Users/chandler/Downloads/shared_training_cloud_omg_dataset_234_geometry_triangle_mesh.ply" mesh = open3d.io.read_triangle_mesh(path) mesh.compute_triangle_normals() ps.init() ps.register_surface_mesh("my mesh", np.array(mesh.vertices), np.array(mesh.triangles), smooth_shade=True) ps.get_surface_mesh("my mesh").add_vector_quantity("normals", np.array( mesh.triangle_normals), defined_on='faces', color=(0.2, 0.5, 0.5)) ps.show()
import sys sys.path.append("src") from geometry.smooth import curves import numpy as np import polyscope as ps from thirdparty.octasphere import octasphere ps.init() verts, faces = octasphere(0, 1) ps_mesh = ps.register_surface_mesh("name", verts, faces) ps.show()
path = "/Users/cbabraham/data/mesh/spot/spot_triangulated.obj" # verts and faces V,F = igl.read_triangle_mesh(path) # cotan laplacian and mass matrix L = igl.cotmatrix(V,F) M = igl.massmatrix(V,F) # eigenvectors of the laplacian _, E = scipy.sparse.linalg.eigsh(L, 1000, M, which='BE') C = V.T.dot(E) # inner product of each eigenvector and the mesh R = np.einsum('km,nm->nk',C,E) # V: n x k verts (k = 3) # E: n x m eigenvectors, to use as bases # C: k x m basis weights # R: n x k synthesized vertices from weighted bases ps.init() original = ps.register_surface_mesh("mesh", V,F) for i, eigenvector in enumerate(E.T): original.add_scalar_quantity( "eigenvector-{}".format(i), eigenvector.astype(np.float32), # defined_on='vertices' ) test = ps.register_surface_mesh("m2", R.astype(np.float32), F) ps.show()
import numpy as np from pygel3d import hmesh m = hmesh.load("../cube.obj") print(m.positions()) faces = m.faces() ## Old school allfaces=[] for f in faces: face=[] for v in m.circulate_face(f): face.append(v) allfaces = allfaces + [face] ## Fancy version allfaces2 = [[v for v in m.circulate_face(f)] for f in faces] polyscope.init() #Display the vertices as point cloud polyscope.register_point_cloud("data", m.positions()) #Display the vertices as mesh polyscope.register_surface_mesh("data mesh", m.positions(), allfaces) #Display the vertices as mesh polyscope.register_surface_mesh("data mesh2", m.positions(), allfaces2) polyscope.show()
surface = smooth_surfaces["plane"] # uv = surface.coordinates(100) # smooth_points = surface.f(uv) # smooth_laplacian = surface.vector_laplacian(uv) mesh = TriangleMesh.read('/Users/cbabraham/Downloads/Damaliscus Korrigum PLY/damaliscus_korrigum.ply') # mesh = TriangleMesh.from_surface(surface, 100) compute_distance = GeodesicDistanceComputation(mesh.vs, np.array(mesh.faces)) distance_of_each_vertex_to_vertex_0 = compute_distance(62132) ps.init() ps.register_surface_mesh("mesh1", mesh.vs, mesh.faces) ps.get_surface_mesh("mesh1").add_scalar_quantity("distance", distance_of_each_vertex_to_vertex_0, defined_on='vertices', cmap='reds') ps.show() # # descrete # mesh = TriangleMesh.from_surface(surface, 100) # discrete_laplacian = \ # get_topological_laplacian(mesh.faces, mesh.vs).dot(mesh.vs) # A = np.linalg.norm(smooth_laplacian, axis=1) # B = np.linalg.norm(smooth_laplacian + smooth_points, axis=1) # C = np.linalg.norm(discrete_laplacian, axis=1) # D = np.linalg.norm(mesh.vs - discrete_laplacian, axis=1) # ps.init()