def plot(self):
from compas.plotters import MeshPlotter
plotter = MeshPlotter(self)
plotter.draw_vertices()
plotter.draw_edges()
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()
u, v = v, u
edgecolor[(u, v)] = '#ff0000'
edgewidth[(u, v)] = 5.0
for path in paths[1:]:
parent = predecessors[path[0]]
for u, v in pairwise([parent] + path):
if not mesh.has_edge(u, v):
u, v = v, u
edgecolor[(u, v)] = '#00ff00'
edgewidth[(u, v)] = 5.0
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(text='key',
facecolor={key: '#ff0000'
for key in (root, )},
radius=0.2)
plotter.draw_edges(color=edgecolor, width=edgewidth)
plotter.show()
# dynamic traversal to visualize the difference
# between DFS and BFS
# ==========================================================================
# testrun 2
# ==========================================================================
if testrun == 2:
import compas
# Main
# ==============================================================================
if __name__ == "__main__":
import compas
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
from compas.topology import mesh_quads_to_triangles
mesh = Mesh.from_obj(compas.get('faces.obj'))
mesh_quads_to_triangles(mesh)
split = mesh.split_edge_tri(15, 20)
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()
trimesh_remesh(delaunay, 1.0, allow_boundary_split=True)
points = [delaunay.vertex_coordinates(key) for key in delaunay.vertices()]
faces = delaunay_from_points(points)
delaunay = Mesh.from_vertices_and_faces(points, faces)
voronoi = voronoi_from_delaunay(delaunay)
lines = []
for u, v in voronoi.edges():
lines.append({
'start': voronoi.vertex_coordinates(u, 'xy'),
'end': voronoi.vertex_coordinates(v, 'xy'),
'width': 1.0
})
plotter = MeshPlotter(delaunay, figsize=(10, 6))
plotter.draw_lines(lines)
plotter.draw_vertices(radius=0.075,
facecolor={
key: '#0092d2'
for key in delaunay.vertices()
if key not in delaunay.vertices_on_boundary()
})
plotter.draw_edges(color='#cccccc')
plotter.show()
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()})
plotter.update_edges()
plotter.update()
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.draw_lines(lines)
# draw the vertices and edges in the starting configuration
# and pause for a second before starting the dynamic visualization
plotter.draw_vertices(facecolor={
key: '#000000'
for key in mesh.vertices() if mesh.vertex_degree(key) == 2
})
plotter.draw_edges()
plotter.update(pause=0.5)
# run the smoother
xyz = smooth_centroid_cpp(vertices,
adjacency,
fixed,
kmax=kmax,
callback=callback)
# keep the plot alive
import compas
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
plotter = MeshPlotter(mesh)
plotter.draw_vertices(text='key', radius=0.15)
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
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()
import compas
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
k_a = {key: mesh.vertex_area(key) for key in mesh.vertices()}
plotter = MeshPlotter(mesh)
plotter.draw_vertices(
radius=0.2,
text={key: '{:.1f}'.format(k_a[key]) for key in mesh.vertices()}
)
plotter.draw_faces()
plotter.draw_edges()
plotter.show()
force = ForceDiagram.from_formdiagram(form)
horizontal(form, force, alpha=100)
scale = vertical_from_zmax(form, 3.0)
# ==============================================================================
# visualise
# ==============================================================================
z = form.get_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()
mesh = Mesh.from_obj(compas.get('faces.obj'))
edges = list(mesh.edges())
root = mesh.get_any_vertex()
ordering, predecessors, paths = depth_first_tree(mesh.adjacency, root)
edgecolor = {}
edgewidth = {}
for u, v in pairwise(paths[0]):
if not mesh.has_edge(u, v):
u, v = v, u
edgecolor[(u, v)] = '#ff0000'
edgewidth[(u, v)] = 3.0
for path in paths[1:]:
parent = predecessors[path[0]]
for u, v in pairwise([parent] + path):
if not mesh.has_edge(u, v):
u, v = v, u
edgecolor[(u, v)] = '#00ff00'
edgewidth[(u, v)] = 3.0
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(text='key', facecolor={root: '#ff0000'}, radius=0.2)
plotter.draw_edges(color=edgecolor, width=edgewidth)
plotter.show()
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
# ==============================================================================
# construct a mesh from OBJ
mesh = Mesh.from_obj(compas.get('faces.obj'))
# ==============================================================================
# visualise the result with a plotter
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(
text={key: key
for key in mesh.vertices_where({
'x': (2, 8),
'y': (2, 8)
})},
radius={
key: 0.2
for key in mesh.vertices_where({
'x': (2, 8),
'y': (2, 8)
})
})
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
[18.929227828979492, 16.271940231323242, 0.0],
[7.34525203704834, 12.111981391906738, 0.0],
[13.31309986114502, 14.699410438537598, 0.0],
[18.699434280395508, 19.613750457763672, 0.0],
[11.913931846618652, 10.593378067016602, 0.0],
[17.163223266601563, 26.870658874511719, 0.0],
[26.110898971557617, 26.634754180908203, 0.0],
[22.851469039916992, 9.81414794921875, 0.0],
[21.051292419433594, 7.556171894073486, 0.0],
[22.1370792388916, 19.089054107666016, 0.0]]
faces = [[15, 5, 0, 4], [0, 9, 12, 4], [9, 11, 14, 12], [14, 1, 8, 12],
[1, 18, 17, 8], [17, 2, 7, 8], [2, 6, 16, 7], [16, 15, 4, 7],
[13, 19, 7, 4], [19, 10, 8, 7], [10, 3, 12, 8], [3, 13, 4, 12]]
mesh = CoarseQuadMesh.from_vertices_and_faces(vertices, faces)
mesh.collect_strip_edge_attribute()
mesh.density_target_length(2)
dense_mesh = densify_quad_mesh(mesh)
plotter = MeshPlotter(dense_mesh, figsize=(10, 6))
plotter.draw_vertices(text='key', radius=0.2, picker=10)
for text in plotter.axes.texts:
text.set_visible(False)
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
from compas.datastructures import Mesh
from compas.topology import mesh_subdivide_catmullclark
from compas.plotters import MeshPlotter
vertices = [[0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 1.0, 0.]]
faces = [
[0, 1, 2, 3],
]
mesh = Mesh.from_vertices_and_faces(vertices, faces)
subd = mesh_subdivide_catmullclark(mesh, k=3, fixed=None)
plotter = MeshPlotter(subd)
plotter.draw_vertices(facecolor={key: '#ff0000'
for key in mesh.vertices()},
radius=0.01)
plotter.draw_faces()
plotter.show()
points = [mesh.vertex_coordinates(key) for key in mesh.vertices()]
faces = delaunay_from_points(points)
mesh = Mesh.from_vertices_and_faces(points, faces)
dual = mesh_dual(mesh)
# network = FaceNetwork.from_vertices_and_faces(points, faces)
# network_find_faces(network)
# dual = network_dual(network)
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(dual, figsize=(10, 7))
plotter.draw_lines(lines)
plotter.draw_vertices(facecolor='#eeeeee',
edgecolor='#000000',
radius=0.05)
plotter.draw_faces(facecolor='#eeeeee', edgecolor='#eeeeee', text='key')
plotter.draw_edges()
plotter.show()
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()
import compas
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
key = 17
nbrs = mesh.vertex_neighbors(key, ordered=True)
plotter = MeshPlotter(mesh)
color = {nbr: '#cccccc' for nbr in nbrs}
color[key] = '#ff0000'
text = {nbr: str(index) for index, nbr in enumerate(nbrs)}
text[key] = str(key)
plotter.draw_vertices(text=text, facecolor=color)
plotter.draw_faces()
plotter.draw_edges()
plotter.show()
# 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
plotter = MeshPlotter(mesh, figsize=(10, 7))
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.draw_vertices(
facecolor=facecolor,
radius=0.05
)
# plotter.draw_edges()
plotter.draw_faces()
plotter.show()
import compas
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
key = 17
nbrs = mesh.vertex_faces(key, ordered=True)
plotter = MeshPlotter(mesh)
plotter.draw_vertices(
text={17: '17'},
facecolor={17: '#ff0000'},
radius=0.2
)
plotter.draw_faces(
text={nbr: str(index) for index, nbr in enumerate(nbrs)},
facecolor={nbr: '#cccccc' for nbr in nbrs}
)
plotter.draw_edges()
plotter.show()
def update_plot(k, args):
plotter.update_vertices()
plotter.update_edges()
plotter.update_faces()
plotter.update(pause=0.001)
# path to the sample file
DATA = os.path.join(os.path.dirname(__file__), '..', 'data')
FILE = os.path.join(DATA, 'faces.obj')
# make a mesh
mesh = Mesh.from_obj(FILE)
# identify fixed points
fixed = list(mesh.vertices_where({'vertex_degree': 2}))
# make a plotter
plotter = MeshPlotter(mesh, figsize=(10, 7))
# draw the original configuration
plotter.draw_vertices(facecolor={key: '#ff0000' for key in fixed})
plotter.draw_edges()
plotter.draw_faces()
# smooth with dynamic viz
mesh_smooth_centroid(mesh, fixed=fixed, kmax=100, callback=update_plot)
# keep plot alive
plotter.show()
def plot_form(form, radius=0.1, fix_width=False, max_width=10, simple=False):
""" Extended load-path plotting of a FormDiagram
Parameters
----------
form : obj
FormDiagram to plot.
radius : float
Radius of vertex markers.
fix_width : bool
Fix edge widths as constant.
max_width : float
Maximum edge width.
simple : bool
Simple red and blue colour plotting.
Returns
-------
obj
Plotter object.
"""
q = [attr['q'] for u, v, attr in form.edges(True)]
qmax = max(abs(array(q)))
lines = []
for u, v in form.edges():
qi = form.get_edge_attribute((u, v), 'q')
if simple:
if qi > 0:
colour = ['ff', '00', '00']
elif qi < 0:
colour = ['00', '00', 'ff']
else:
colour = ['aa', 'aa', 'aa']
else:
colour = ['00', '00', '00']
if qi > 0:
colour[0] = 'ff'
if form.get_edge_attribute((u, v), 'is_symmetry'):
colour[1] = 'cc'
if form.get_edge_attribute((u, v), 'is_ind'):
colour[2] = 'ff'
width = max_width if fix_width else (qi / qmax) * max_width
lines.append({
'start': form.vertex_coordinates(u),
'end': form.vertex_coordinates(v),
'color': ''.join(colour),
'width': width,
})
plotter = MeshPlotter(form, figsize=(10, 10))
if radius:
plotter.draw_vertices(facecolor={
i: '#aaaaaa'
for i in form.vertices_where({'is_fixed': True})
},
radius=radius)
plotter.draw_lines(lines)
return plotter
loads = mesh.get_vertices_attributes(('px', 'py', 'pz'))
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()
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
})
# ==============================================================================
# make a plotter for visualisation
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)
# ==============================================================================
# define a callback for visualising the iterative process
def callback(k, xyz, crits, args):
print(k)
plotter.update_vertices()
plotter.update_edges()
plotter.update(pause=0.001)
import compas
from compas.datastructures import Mesh
from compas.plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
plotter = MeshPlotter(mesh)
plotter.draw_vertices()
plotter.draw_faces(
text={fkey: '%.1f' % mesh.face_area(fkey)
for fkey in mesh.faces()})
plotter.draw_edges()
plotter.show()
return True
# ==============================================================================
# Main
# ==============================================================================
if __name__ == "__main__":
import compas
from compas.datastructures import Mesh
from compas.datastructures import mesh_quads_to_triangles
from compas.datastructures import trimesh_collapse_edge
from compas.plotters import MeshPlotter
mesh = Mesh.from_obj(compas.get('faces.obj'))
mesh_quads_to_triangles(mesh)
trimesh_collapse_edge(mesh, 21, 27)
trimesh_collapse_edge(mesh, 0, 6, allow_boundary=True)
trimesh_collapse_edge(mesh, 1, 7, allow_boundary=True)
plotter = MeshPlotter(mesh, figsize=(10, 7))
plotter.draw_vertices(text={key: key for key in mesh.vertices()}, radius=0.2)
plotter.draw_faces(text={fkey: fkey for fkey in mesh.faces()})
plotter.show()
# ==============================================================================
# Main
# ==============================================================================
if __name__ == '__main__':
from compas.datastructures import Mesh
from compas.geometry import conforming_delaunay_triangle
from compas.plotters import MeshPlotter
points = [[2.994817685045075, 10.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]]
segments = list(pairwise(list(range(len(points))) + [0]))
vertices, faces = conforming_delaunay_triangle(points, segments)
mesh = Mesh.from_vertices_and_faces(vertices, faces)
plotter = MeshPlotter(mesh)
plotter.draw_faces()
plotter.draw_vertices(text='key')
plotter.show()
[2, 3, 4],
[3, 0, 4],
]
lines = [
([0., 0., 0.], [1., 0., -1.]),
([0., 0., 0.], [-1., 0., -1.]),
([0., 0., 0.], [0., 1., -1.]),
([0., 0., 0.], [0., -1., -1.]),
([0., 0., 0.], [0., 0., 1.]),
]
#kagome = Kagome.from_skeleton(lines)
kagome = Kagome.from_vertices_and_faces(vertices, faces)
kagome.densification(3)
kagome.patterning()
kagome.store_kagome_polyedge_data()
plotter = MeshPlotter(kagome.kagome)
plotter.draw_vertices(radius=.005)
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
#print kagome.kagome_negative_singularities()
#print kagome.kagome_singularities()
#print kagome.kagome_polyline_frames()
#kagome.kagome_polyedges()
#kagome.kagome_polyline_colouring()
kagome.kagome_polyedge_weaving()
vertexcolor = {}
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)
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(facecolor={
key: (1.0, 0.9, 0.9)
for key in form.faces_where({'is_loaded': False})
}, )
plotter.show()
from compas.geometry import pointcloud_xy from compas.datastructures import Mesh from compas.topology import delaunay_from_points from compas.plotters import MeshPlotter points = pointcloud_xy(10, (0, 10)) faces = delaunay_from_points(points) delaunay = Mesh.from_vertices_and_faces(points, faces) plotter = MeshPlotter(delaunay) plotter.draw_vertices(radius=0.1) plotter.draw_faces() plotter.show()
