def visualize_mesh_traversal() -> None:
''' Datastructures task
'''
mesh = Mesh.from_obj(get('faces.obj'))
x_values = {}
for vkey in mesh.vertices_on_boundary():
x_values[vkey] = mesh.vertex_coordinates(vkey)[0]
max_x = max(x_values.values())
print("Vertices on the right edge of the mesh:")
print([key for key in x_values if x_values[key] == max_x])
start_key = int(input("\nSelect start vertex: "))
path_verts = traverse_mesh(mesh, start_key)
print('\nPath calculated, starting MeshPlotter.')
plotter = MeshPlotter(mesh, figsize=(16, 10))
plotter.draw_vertices(text={key: key
for key in path_verts},
radius=0.2,
facecolor={key: '#ff0000'
for key in path_verts})
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
def plot_mesh(mesh):
"""
Compas Mesh Plotter
"""
all_keys=list(mesh.vertices())
plotter=MeshPlotter(mesh)
plotter.draw_vertices(text='key', keys=all_keys, radius=0.01)
plotter.draw_faces()
plotter.show()
def plot(self):
"""Plot a form diagram with a plotter with all the default settings."""
from compas_plotters import MeshPlotter
plotter = MeshPlotter(self, figsize=(12, 8), tight=True)
vertexcolor = {}
vertexcolor.update({key: '#00ff00' for key in self.vertices_where({'is_fixed': True})})
vertexcolor.update({key: '#ff0000' for key in self.vertices_where({'is_anchor': True})})
plotter.draw_vertices(facecolor=vertexcolor)
plotter.draw_edges(keys=list(self.edges_where({'_is_edge': True})))
plotter.draw_faces(keys=list(self.faces_where({'_is_loaded': True})))
plotter.show()
def plot_mesh(mesh_info_dict,
current_vertex_info_dict,
edges_flag=1,
faces_flag=1):
"""
This function plot the mesh and the path dynamically. But the problem is that
it seems that plotter.close() have not been defined in the current version
of the COMPAS (0.10.0)
"""
mesh = mesh_info_dict['mesh']
# define the facecolor dictionaries for vertices
facecolor = {}
# facecolor for all on-baoundary vertices
facecolor.update({
key: (200, 200, 200)
for key in mesh_info_dict['non_on_boundry_vertices']
})
# facecolor for all non-on-baoundary vertices
facecolor.update({
key: (150, 150, 150)
for key in mesh_info_dict['on_boundry_vertices']
})
# facecolor for all on-baoundary neighborhood vertices
facecolor.update({
key: (0, 255, 0)
for key in current_vertex_info_dict['non_on_boundry_neighbs_vertices']
})
# facecolor for all non-on-baoundary neighborhood vertices
facecolor.update({
key: (0, 0, 255)
for key in current_vertex_info_dict['on_boundry_neighbs_vertices']
})
# facecolor for the current vertes
facecolor.update({current_vertex_info_dict['current_vertex']: (255, 0, 0)})
# define important vertices
keys = mesh_info_dict['all_vertices']
# instantiate the MeshPlotter
plotter = MeshPlotter(mesh=mesh, figsie=(4, 4))
# draw vertices
plotter.draw_vertices(radius=0.3,
text='key',
keys=keys,
facecolor=facecolor)
# draw edges
if edges_flag == 1: plotter.draw_edges()
# draw faces
if faces_flag == 1: plotter.draw_faces()
# show mesh plot
plotter.show()
def plot(self):
from compas_plotters import MeshPlotter
plotter = MeshPlotter(self, figsize=(12, 8), tight=True)
vertexcolor = {}
vertexcolor.update({
key: '#00ff00'
for key in self.vertices_where({'is_fixed': True})
})
vertexcolor.update({
key: '#0000ff'
for key in self.vertices_where({'_is_external': True})
})
vertexcolor.update({
key: '#ff0000'
for key in self.vertices_where({'is_anchor': True})
})
plotter.draw_vertices(facecolor=vertexcolor)
plotter.draw_edges(keys=list(self.edges_where({'_is_edge': True})))
plotter.draw_faces(keys=list(self.faces_where({'_is_loaded': True})))
plotter.show()
arrows.append({
'start': cablenet.vertex_coordinates(u),
'end': cablenet.vertex_coordinates(v),
'color': (0.0, 0.0, 0.0)
})
facecolor = {
key: i_to_blue(index / len(faces))
for index, key in enumerate(faces)
}
plotter = MeshPlotter(cablenet, figsize=(10, 7))
plotter.defaults['vertex.radius'] = 0.04
plotter.defaults['edge.width'] = 0.5
plotter.draw_edges(width={key: 3.0 for edges in cables for key in edges})
plotter.draw_vertices(radius={key: 0.06
for key in chain},
facecolor=vertexcolor)
plotter.draw_arrows2(arrows)
plotter.draw_faces(facecolor=facecolor,
keys=faces,
text={key: str(index)
for index, key in enumerate(faces)})
plotter.show()
# ==============================================================================
# Export
# ==============================================================================
cablenet.to_json(FILE_O)
polylines = []
control_points = []
for streamline in streamsystem.streamlines:
polylines.append({
'points': streamline.polyline.points,
'color': (0, 0, 255)
})
for xyz in streamline.polyline.points:
control_points.append({
'pos': xyz,
'facecolor': (255, 255, 255),
'radius': 0.03
})
plotter = MeshPlotter(mesh, figsize=(12, 9))
plotter.draw_faces(keys=umbilic_keys, facecolor=(255, 0, 0))
# plotter.draw_edges(color=(10, 10, 10))
# plotter.draw_faces(keys=not_umbilic_keys)
plotter.draw_lines(lines)
# plotter.draw_points([{'pos': closest_pt, 'facecolor': (0, 255, 0), 'radius': 0.02},
# {'pos': test_pt, 'facecolor': (0, 0, 255), 'radius': 0.02}
# ]
# )
# plotter.draw_points(control_points)
plotter.draw_polylines(polylines)
plotter.show()
scale = vertical_from_zmax(form, 3.0)
# ==============================================================================
# visualise
# ==============================================================================
z = form.vertices_attribute('z')
zmin = min(z)
zmax = max(z)
plotter = MeshPlotter(form, figsize=(12, 8), tight=True)
plotter.draw_vertices(
keys=list(form.vertices_where({'is_external': False})),
facecolor={
key: i_to_black((attr['z'] - zmin) / (zmax - zmin))
for key, attr in form.vertices_where({'is_external': False}, True)
},
radius=0.1)
plotter.draw_edges(
keys=list(form.edges_where({'is_edge': True})),
color={key: '#00ff00'
for key in form.edges_where({'is_external': True})},
width={key: 2.0
for key in form.edges_where({'is_external': True})})
plotter.draw_faces(keys=list(form.faces_where({'is_loaded': True})))
plotter.show()
# ==============================================================================
# Input
# ==============================================================================
TOL = 0.02
MAXDEV = 0.005
KMAX = 500
mesh = Mesh.from_off(igl.get('tubemesh.off'))
# ==============================================================================
# Planarize
# ==============================================================================
V, F = mesh.to_vertices_and_faces()
V2 = igl.quadmesh_planarize((V, F), KMAX, MAXDEV)
# ==============================================================================
# Visualize
# ==============================================================================
mesh = Mesh.from_vertices_and_faces(V2, F)
dev = mesh_flatness(mesh, maxdev=TOL)
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.draw_faces(
facecolor={fkey: i_to_rgb(dev[fkey])
for fkey in mesh.faces()})
plotter.show()
# network.add_vertex(0)
# network.add_vertex(1)
# network.add_edge(0, 1)
# print(network)
# from compas.datastructures import mesh_connectivity_matrix
# from compas.datastructures import mesh_adjacency_matrix
# from compas.topology import face_adjacency
# mesh = Mesh.from_obj(compas.get('faces.obj'))
# print(mesh.number_of_faces())
# print(mesh.number_of_vertices())
# print(mesh.number_of_edges())
# mcm = mesh_connectivity_matrix(mesh)
# print(mcm.shape)
# mac = mesh_adjacency_matrix(mesh) # this one?
# print(mac.shape)
# xyz, faces = mesh.to_vertices_and_faces()
# fa = face_adjacency(xyz, faces) # ok!
# ==========================================================================
# Set up Plotter
# ==========================================================================
plotter = MeshPlotter(mesh, figsize=(12, 9))
plotter.draw_faces(facecolor=colors)
plotter.show()
edgegroups = []
for vertices in vertexgroups:
edgegroups.append(list(pairwise(vertices)))
return edgegroups
# ==============================================================================
# Main
# ==============================================================================
if __name__ == '__main__':
import compas
from compas.datastructures import Mesh
from compas_plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('quadmesh.obj'))
edges = mesh.edges_on_boundary()
print(len(edges))
faces = mesh.faces_on_boundary()
print(len(faces))
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.draw_vertices()
plotter.draw_faces(text='key')
plotter.draw_edges()
plotter.show()
mesh = RING_unrolled[3]
points = [
mesh.vertex_coordinates(key)
for key in mesh.vertices_on_boundary(ordered=True)
]
polygons = [{'points': offset_polygon(points, SEEM)}]
fkey = list(mesh.faces_where({'count': 0}))[0]
facecolor = {fkey: COLOR}
PLOTTER = MeshPlotter(mesh, figsize=(10, 7))
PLOTTER.draw_polygons(polygons)
PLOTTER.draw_faces(text={
fkey: "{}".format(str(attr['count']).zfill(2))
for fkey, attr in mesh.faces(True)
},
facecolor=facecolor)
PLOTTER.draw_edges()
PLOTTER.show()
# ==============================================================================
# Export
# ==============================================================================
# for mesh in RING_unrolled:
# path = os.path.join(DATA, 'FABRIC', 'unrolled', SIDE, "{}.json".format(mesh.attributes['name']))
# mesh.to_json(path)
# ==============================================================================
# Visualize
import compas
from compas.datastructures import Mesh
from compas_plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
plotter = MeshPlotter(mesh, figsize=(12, 7.5))
plotter.draw_vertices()
plotter.draw_faces(
text={face: str(mesh.face_degree(face))
for face in mesh.faces()})
plotter.show()
if __name__ == "__main__":
import compas
from compas.datastructures import Mesh
from compas_plotters import MeshPlotter
from compas.datastructures import mesh_quads_to_triangles
from compas.datastructures import trimesh_split_edge
mesh = Mesh.from_obj(compas.get('faces.obj'))
mesh_quads_to_triangles(mesh)
u, v = mesh.get_any_edge()
split = trimesh_split_edge(mesh, u, v, allow_boundary=True)
facecolor = {
key: '#cccccc' if key != split else '#ff0000'
for key in mesh.vertices()
}
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(text={key: key
for key in mesh.vertices()},
radius=0.2,
facecolor=facecolor)
plotter.draw_faces(text={fkey: fkey for fkey in mesh.faces()})
plotter.show()
mesh = Mesh.from_vertices_and_faces(points, cycles)
# e1 = network.edge_coordinates(0, 4)
# e2 = network.edge_coordinates(1, 3)
# xyz = intersection_line_line_xy(e1, e2)
# network.delete_edge(0, 4)
# network.delete_edge(1, 3)
# x = network.add_node(x=xyz[0], y=xyz[1], z=xyz[2])
# network.add_edge(x, 0)
# network.add_edge(x, 1)
# network.add_edge(x, 3)
# network.add_edge(x, 4)
# plotter = NetworkPlotter(network, figsize=(8, 5))
# plotter.draw_nodes(text='key', radius=0.25)
# plotter.draw_edges()
# plotter.show()
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.draw_vertices(text='key', radius=0.25)
plotter.draw_edges(
keys=list(set(mesh.edges()) - set(mesh.edges_on_boundary())))
plotter.draw_faces(
text='key',
keys=list(set(mesh.faces()) - set(mesh.faces_on_boundary())))
plotter.save('find_cycles.png')
for u, v in mesh.edges():
lines.append({
'start': mesh.vertex_coordinates(u, 'xy'),
'end': mesh.vertex_coordinates(v, 'xy'),
'color': '#cccccc',
'width': 1.0,
})
smooth_centerofmass(vertices, adjacency, fixed=fixed, kmax=100)
for key, attr in mesh.vertices(True):
attr['x'] = vertices[key][0]
attr['y'] = vertices[key][1]
attr['z'] = vertices[key][2]
plotter = MeshPlotter(mesh)
plotter.draw_lines(lines)
plotter.draw_vertices(
text={key: mesh.vertex_degree(key)
for key in mesh.vertices()},
facecolor={key: '#ff0000'
for key in fixed})
plotter.draw_edges()
plotter.draw_faces(text={
key: "{:.1f}".format(mesh.face_area(key))
for key in mesh.faces()
})
plotter.show()
vertexcolor.update(
{key: '#00ff00'
for key in form.vertices_where({'is_fixed': True})})
vertexcolor.update(
{key: '#0000ff'
for key in form.vertices_where({'is_external': True})})
vertexcolor.update(
{key: '#ff0000'
for key in form.vertices_where({'is_anchor': True})})
radius = {key: 0.05 for key in form.vertices()}
radius.update({key: 0.1 for key in form.vertices_where({'is_anchor': True})})
plotter.draw_vertices(facecolor=vertexcolor, radius=radius)
edges = list(form.edges_where({'is_edge': True}))
plotter.draw_edges(
keys=edges,
color={key: '#00ff00'
for key in form.edges_where({'is_external': True})},
width={key: 2.0
for key in form.edges_where({'is_external': True})})
faces = list(form.faces_where({'is_loaded': True}))
plotter.draw_faces(
keys=faces,
facecolor=(1.0, 0.9, 0.9),
)
plotter.show()
# return voronoi
# ==============================================================================
# Main
# ==============================================================================
if __name__ == "__main__":
from compas.datastructures import Mesh
from compas.geometry import pointcloud_xy
from compas_plotters import MeshPlotter
points = pointcloud_xy(200, (0, 50))
faces = delaunay_from_points(points)
delaunay = Mesh.from_vertices_and_faces(points, faces)
plotter = MeshPlotter(delaunay, figsize=(8, 5))
facecolor = {
fkey: (255, 0, 0) if delaunay.face_normal(fkey)[2] > 0 else (0, 0, 255)
for fkey in delaunay.faces()
}
plotter.draw_vertices(keys=list(delaunay.vertices_on_boundary()),
radius=0.5)
plotter.draw_faces(facecolor=facecolor)
plotter.draw_edges(keys=list(delaunay.edges_on_boundary()))
plotter.show()
from compas_plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('hypar.obj'))
target = mesh.copy()
points = mesh.vertices_attributes('xyz')
points[:] = [[x, y, 0] for x, y, z in points]
mesh_quads_to_triangles(target)
pulled = trimesh_pull_points_numpy(target, points)
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.defaults['vertex.fontsize'] = 6
plotter.draw_vertices(text={
key: "{:.1f}".format(attr['z'])
for key, attr in mesh.vertices(True)
},
radius=0.08)
plotter.draw_faces()
plotter.draw_points([{
'pos': [x, y, z],
'text': "{:.1f}".format(z),
'radius': 0.08,
'facecolor': '#00ff00',
'fontsize': 6
} for x, y, z in pulled])
plotter.show()
import os
import compas
from compas.datastructures import Mesh
from compas_plotters import MeshPlotter
HERE = os.path.dirname(__file__)
DATA = os.path.join(HERE, 'data')
FILE = os.path.join(DATA, 'faces.obj')
mesh = Mesh.from_obj(FILE)
plotter = MeshPlotter(mesh, figsize=(16, 10))
plotter.draw_vertices(
facecolor={key: (255, 0, 0)
for key in mesh.vertices_on_boundary()},
text={key: str(mesh.vertex_degree(key))
for key in mesh.vertices()},
radius=0.2)
plotter.draw_edges(keys=list(mesh.edges_on_boundary()), color=(255, 0, 0))
plotter.draw_faces(
facecolor={
key: (150, 255, 150)
for key in mesh.faces() if not mesh.is_face_on_boundary(key)
})
plotter.show()