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(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(self):
"""Plot a force diagram with a plotter with all the default settings."""
from compas_plotters import MeshPlotter
plotter = MeshPlotter(self, figsize=(12, 8), tight=True)
plotter.draw_vertices(radius=0.05)
plotter.draw_edges()
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_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):
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()
def traverse_boundary_to_boundary(mesh):
"""
traverse the mesh from boundary to boundary in a "straight" line and visulize the results
mesh: mesh data structure
return a list of ordered vertex keys for the path and the mesh plotter with highlighted path (use plotter.show() to visualize))
"""
bound_keys=mesh.vertices_on_boundary()
# randomly pick a boundary key
ind=randrange(len(bound_keys))
key=bound_keys[ind]
pick_keys=[key]
prev_fkeys=set()
# non-corner vertices
if mesh.vertex_degree(key)>2:
f_keys=mesh.vertex_faces(key)
adj_keys=mesh.face_adjacency_vertices(f_keys[0], f_keys[1])
next_key=list(set(adj_keys)-set(pick_keys))[0]
pick_keys.append(next_key)
prev_fkeys.update(f_keys)
while next_key not in bound_keys:
f_keys=mesh.vertex_faces(next_key)
f_keys=list(set(f_keys)-prev_fkeys)
adj_keys=mesh.face_adjacency_vertices(f_keys[0], f_keys[1])
next_key=list(set(adj_keys)-set(pick_keys))[0]
pick_keys.append(next_key)
prev_fkeys.update(f_keys)
# corner vertices
elif mesh.vertex_degree(key)==2:
f_keys=mesh.vertex_faces(key)
next_key=mesh.face_vertex_ancestor(f_keys[0], key) # one way of moving on the boundary!
pick_keys.append(next_key)
prev_fkeys.update(f_keys)
while mesh.vertex_degree(next_key)!=2:
f_keys=mesh.vertex_faces(next_key)
f_keys=list(set(f_keys)-prev_fkeys)
next_key=mesh.face_vertex_ancestor(f_keys[0], next_key)
pick_keys.append(next_key)
prev_fkeys.update(f_keys)
# mesh plotter with highlighted path
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.draw_vertices(text='key', fontsize=10.0, radius=0.02)
plotter.draw_edges()
plotter.highlight_path(pick_keys, edgecolor=(255, 0, 0), edgewidth=2.0)
return pick_keys, plotter
if not mesh.is_vertex_on_boundary(n):
previous = index
index = n
break
while True:
path.append(index)
if mesh.is_vertex_on_boundary(index):
break
neighbors = mesh.vertex_neighbors(index, ordered=True)
i = neighbors.index(previous)
previous = index
index = neighbors[i + 2]
return path
# Test
start = 3
path = TraverseMesh(mesh, start)
print(path)
plotter = MeshPlotter(mesh, figsize=(4, 4))
plotter.draw_vertices(radius=0.4,
text='key',
keys=path,
facecolor=(100, 100, 0))
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
fpre = mesh.get_edges_attribute('fpre')
lpre = mesh.get_edges_attribute('lpre')
linit = mesh.get_edges_attribute('linit')
E = mesh.get_edges_attribute('E')
radius = mesh.get_edges_attribute('radius')
lines = []
for u, v in mesh.edges():
lines.append({
'start': mesh.vertex_coordinates(u, 'xy'),
'end': mesh.vertex_coordinates(v, 'xy'),
'color': '#cccccc',
'width': 0.5
})
plotter = MeshPlotter(mesh, figsize=(10, 7), fontsize=6)
plotter.draw_lines(lines)
plotter.draw_vertices(facecolor={key: '#000000' for key in mesh.vertices_where({'is_fixed': True})})
plotter.draw_edges()
plotter.update(pause=1.0)
def callback(k, xyz, crits, args):
print(k)
plotter.update_vertices()
plotter.update_edges()
plotter.update(pause=0.001)
for key, attr in mesh.vertices(True):
# ==============================================================================
# Main
# ==============================================================================
if __name__ == '__main__':
from compas.datastructures import Mesh
from compas_plotters import MeshPlotter
vertices = [(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (6.0, 10.0, 0.0),
(0.0, 10.0, 0.0)]
faces = [[0, 1, 2, 3]]
mesh = Mesh.from_vertices_and_faces(vertices, faces)
key = mesh.insert_vertex(0)
area = sum(mesh.face_area(fkey)
for fkey in mesh.faces()) / mesh.number_of_faces()
print(area)
for fkey in mesh.faces():
print(len(mesh.face_vertices(fkey)))
finer = trimesh_remesh_triangle(mesh, target=area / 10.0)
print(finer, key)
plotter = MeshPlotter(finer, figsize=(10, 7))
plotter.draw_edges()
plotter.show()
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(text={
vertex: str(mesh.vertex_degree(vertex))
for vertex in mesh.vertices()
},
radius=0.2)
plotter.draw_faces()
plotter.show()
# ==============================================================================
# Compute equilibrium
# ==============================================================================
update_xyz_numpy(cablenet)
# ==============================================================================
# Visualize
# ==============================================================================
heights = cablenet.vertices_attribute('z')
cmap = Colormap(heights, 'black')
vertexcolor = {key: cmap(z) for key, z in zip(cablenet.vertices(), heights)}
forces = cablenet.edges_attribute('f')
cmap = Colormap(forces, 'rgb')
edgecolor = {key: cmap(f) for key, f in zip(cablenet.edges(), forces)}
plotter = MeshPlotter(cablenet, figsize=(16, 9))
plotter.draw_vertices(facecolor=vertexcolor, radius=0.05)
plotter.draw_edges(width=2.0, color=edgecolor)
plotter.save(FILE_P, dpi=150)
# plotter.show()
# ==============================================================================
# Export
# ==============================================================================
cablenet.to_json(FILE_O)
import compas_libigl as igl
HERE = os.path.dirname(__file__)
FILE = os.path.join(HERE, '..', 'data', 'tubemesh.json')
mesh = Mesh.from_json(FILE)
mesh_quads_to_triangles(mesh)
key_index = mesh.key_index()
index_key = mesh.index_key()
V = mesh.vertices_attributes('xyz')
F = [[key_index[key] for key in mesh.face_vertices(fkey)]
for fkey in mesh.faces()]
root = mesh.get_any_vertex()
# D = igl.trimesh_geodistance_exact(V, F, 0)
D = igl.trimesh_geodistance_heat(V, F, key_index[root])
cmap = Colormap(D, 'red')
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.draw_faces()
plotter.draw_vertices(
text={root: 'root'},
radius=0.2,
facecolor={key: cmap(d)
for key, d in zip(mesh.vertices(), D)})
plotter.show()
import compas
from compas.datastructures import Mesh
from compas_plotters import MeshPlotter
from compas.utilities import i_to_rgb
mesh = Mesh.from_obj(compas.get('hypar.obj'))
for key, attr in mesh.vertices(True):
attr['is_fixed'] = mesh.vertex_degree(key) == 2
fixed = [key for key in mesh.vertices_where({'is_fixed': True})]
radius = {key: (0.05 if key in fixed else 0.01) for key in mesh.vertices()}
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(radius=radius)
plotter.draw_faces()
plotter.draw_edges()
def callback(k, args):
print(k)
if k % 100 == 0:
dev = mesh_flatness(mesh, maxdev=0.02)
plotter.update_vertices(radius=radius)
plotter.update_faces(
facecolor={fkey: i_to_rgb(dev[fkey])
for fkey in mesh.faces()})
HERE = os.path.dirname(__file__)
DATA = os.path.join(HERE, 'data')
FILE = os.path.join(DATA, 'faces.obj')
mesh = Mesh.from_obj(FILE)
# set random boundary vertex as start
deg3_vertices = []
for key in mesh.vertices():
if mesh.vertex_degree(key) == 3:
deg3_vertices.append(key)
start_vertex = random.choice(deg3_vertices)
# compute straight path
path = get_straight_path(mesh, start_vertex)
# visualize mesh, vertices and path
plotter = MeshPlotter(mesh, figsize=(16, 10))
plotter.draw_faces()
plotter.draw_edges()
plotter.draw_vertices(text='key', radius=0.15)
plotter.draw_vertices(facecolor=(0, 255, 255),
text='key',
keys=path[:1],
radius=0.2)
plotter.draw_vertices(facecolor=(255, 0, 255),
text='key',
keys=path[1:],
radius=0.2)
plotter.show()
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()
Returns
-------
mesh
The joined and welded mesh.
"""
return mesh_weld(meshes_join(meshes, cls=cls), precision=precision)
# ==============================================================================
# Main
# ==============================================================================
if __name__ == "__main__":
from compas.datastructures import Mesh
from compas.datastructures import mesh_weld
from compas_plotters import MeshPlotter
vertices = [[0, 0, 0], [0.04, 0, 0], [1.0, 0, 0], [1.0, 1.0, 0], [0, 1.0, 0]]
faces = [[0, 1, 2, 3, 4]]
mesh = Mesh.from_vertices_and_faces(vertices, faces)
mesh = mesh_weld(mesh, precision='1f')
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(text={key: "{:.3f}".format(mesh.vertex[key]['x']) for key in mesh.vertices()}, radius=0.03)
plotter.draw_edges()
plotter.show()
attr['y'] = y
attr['z'] = z
# mesh = Mesh.from_obj(compas.get('faces.obj'))
# mesh_quads_to_triangles(mesh)
# mesh = Mesh.from_polyhedron(12)
# mesh_quads_to_triangles(mesh)
index_key = mesh.index_key()
sources = [0]
d = mesh_geodesic_distances(mesh, sources, m=1.0).tolist()
dmin = min(d)
dmax = max(d)
drange = dmax - dmin
facecolor = {
key: i_to_blue(1 - (d[i] - dmin) / drange)
for i, key in enumerate(mesh.vertices())
}
for i in sources:
facecolor[index_key[i]] = '#ff0000'
plotter = MeshPlotter(mesh, figsize=(6, 4))
plotter.draw_vertices(facecolor=facecolor, radius=0.5)
plotter.draw_faces()
plotter.show()
# ==============================================================================
# Post-process
# ==============================================================================
postprocess(unrolled_SOUTH)
postprocess(unrolled_WEST)
postprocess(unrolled_NW)
postprocess(unrolled_NE)
postprocess(unrolled_EAST)
# ==============================================================================
# Visualize
# ==============================================================================
plotter = MeshPlotter(None, figsize=(10, 7))
mesh = unrolled_SOUTH[0]
bbox = oriented_bounding_box_xy_numpy(mesh.get_vertices_attributes('xyz'))
points = []
lines = []
for index, (x, y) in enumerate(bbox[0]):
point = Point(x, y, 0)
points.append({
'pos': point,
'radius': 0.01,
})
for u, v in pairwise(bbox[0] + bbox[0][:1]):
lines.append({'start': u, 'end': v, 'width': 0.1})
plotter.mesh = mesh
'color': (1.0, 0.0, 0.0)
}]
for u, v in parallel:
if u not in start and v not in start:
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
# boundary.append(boundary_edges[boundary[-1]])
# boundary_edges.pop(boundary[-2])
# boundaries.append(boundary[: -1])
# return boundaries
# ==============================================================================
# Main
# ==============================================================================
if __name__ == '__main__':
import compas
from compas.datastructures import Network
from compas_plotters import MeshPlotter
network = Network.from_obj(compas.get('lines.obj'))
lines = network.to_lines()
mesh = BaseMesh.from_lines(lines, delete_boundary_face=False)
mesh.summary()
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.draw_vertices()
plotter.draw_faces()
plotter.draw_edges()
plotter.show()
from compas_tna.diagrams import ForceDiagram
from compas_tna.equilibrium import horizontal_nodal
from compas_plotters import MeshPlotter
FILE = compas_tna.get('tutorial/boundaryconditions.json')
form = FormDiagram.from_json(FILE)
force = ForceDiagram.from_formdiagram(form)
horizontal_nodal(form, force, kmax=100)
# ==============================================================================
# Visualise
# ==============================================================================
plotter = MeshPlotter(force, figsize=(12, 8), tight=True)
vertexcolor = {
key: (1.0, 0.9, 0.9)
for key in force.vertices() if not form.face_attribute(key, '_is_loaded')
}
radius = {key: 0.05 for key in force.vertices()}
radius.update({
key: 0.1
for key in force.vertices() if not form.face_attribute(key, '_is_loaded')
})
plotter.draw_vertices(facecolor=vertexcolor, radius=radius)
plotter.draw_edges()
for fkey in cluster.faces_keys:
facedict[fkey] = color
facecolors = sorted(facedict.items(), key=lambda x: x[0])
facecolors = [x[1] for x in facecolors]
plotter.facecollection.set_facecolors(facecolors)
if export:
plotter.save(THERE + '{}_{}.png'.format(time(), k))
plotter.update(pause=0.50)
# ==========================================================================
# Set up Plotter
# ==========================================================================
plotter = MeshPlotter(mesh, figsize=(12, 9))
plotter.draw_lines(lines)
plotter.draw_faces()
callback = partial(callback,
plotter=plotter,
filepath=THERE,
export=EXPORT_PNG)
# ==========================================================================
# Set up K-Means algorithm
# ==========================================================================
faces = make_faces(str_mesh, vector_tag, weight=False)
clusters = furthest_init(NUM, faces, callback=None)
DRAW_FACES = False
DRAW_VF = False
# ==========================================================================
# Import mesh
# ==========================================================================
mesh = Mesh()
mesh = Mesh.from_json(HERE)
mesh_unify_cycles(mesh)
# ==========================================================================
# Visualization
# ==========================================================================
plotter = MeshPlotter(mesh, figsize=(12, 9))
if DRAW_EDGES:
plotter.draw_edges(color=(100, 100, 100), width=0.1)
if DRAW_FACES:
plotter.draw_faces()
# ==========================================================================
# Instantiate StructuralMesh()
# ==========================================================================
str_mesh = StructuralMesh(mesh)
# ==========================================================================
# Create closest-point seeds
def plot(self):
from compas_plotters import MeshPlotter
plotter = MeshPlotter(self, figsize=(12, 8), tight=True)
plotter.draw_vertices(radius=0.05)
plotter.draw_edges()
plotter.show()
q = mesh.get_edges_attribute('q')
fixed = mesh.vertices_where({'is_anchor': True})
fixed = [k_i[k] for k in fixed]
edges = [(k_i[u], k_i[v]) for u, v in mesh.edges()]
# compute equilibrium
# update the mesh geometry
xyz, q, f, l, r = fd_numpy(xyz, edges, fixed, q, loads)
for key, attr in mesh.vertices(True):
index = k_i[key]
attr['x'] = xyz[index, 0]
attr['y'] = xyz[index, 1]
attr['z'] = xyz[index, 2]
# visualisae the result
# color the vertices according to their elevation
plotter = MeshPlotter(mesh)
zmax = max(mesh.get_vertices_attribute('z'))
plotter.draw_vertices(facecolor={
key: i_to_black(attr['z'] / zmax)
for key, attr in mesh.vertices(True)
})
plotter.draw_faces()
plotter.draw_edges()
plotter.show()
# ==============================================================================
# Visualize
# ==============================================================================
edges = list(cablenet.edges_where({'is_edge': True}))
stress = [cablenet.stress(key) for key in edges]
cmap = Colormap(stress, 'rgb')
edgecolor = {key: cmap(s) for key, s in zip(edges, stress)}
utilization = [cablenet.stress(key) / cablenet.edge_attribute(key, 'yield') for key in edges]
cmap = Colormap(utilization, 'red')
edgecolor = {key: cmap(u) for key, u in zip(edges, utilization)}
print(min(utilization))
print(max(utilization))
plotter = MeshPlotter(cablenet, figsize=(16, 9))
plotter.draw_vertices(radius=0.05, facecolor={key: (0.0, 0.0, 0.0) for key in cablenet.vertices_where({'is_anchor': True})})
plotter.draw_edges(width=2.0, color=edgecolor, keys=edges)
plotter.save(FILE_P, dpi=150)
# plotter.show()
# ==============================================================================
# Export
# ==============================================================================
cablenet.to_json(FILE_O)
# 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.datastructures import Mesh
from compas.datastructures import mesh_quads_to_triangles
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])
from compas.datastructures import Mesh
from compas.utilities import geometric_key
from compas_plotters import MeshPlotter
from compas.geometry import delaunay_triangulation
points = [[2.994817685045075, 12.855606612493078, 0.0],
[4.185204599300653, 9.527867361977242, 0.0],
[4.414125159734419, 10.718254276232818, 0.0],
[5.925000858597267, 9.344730913630228, 0.0],
[8.900968144236211, 10.809822500406325, 0.0],
[9.496161601363999, 8.566401008155429, 0.0],
[7.710581229980631, 7.9254234389408875, 0.0],
[7.847933566240888, 6.414547740078039, 0.0],
[3.9104999267801377, 4.9036720412151915, 0.0],
[5.2909301507195865, 6.342692886748852, 0.0]]
vertices, faces = delaunay_triangulation(points, 'q30a1D')
mesh = Mesh.from_vertices_and_faces(vertices, faces)
plotter = MeshPlotter(mesh, figsize=(8, 5))
plotter.defaults['vertex.fontsize'] = 6
plotter.draw_faces()
plotter.draw_vertices(text='key')
plotter.show()