def compute_sequence(key):
placed = set(assembly.vertices_where({'is_placed': True}))
if key in placed:
return
sequence = assembly_block_building_sequence(assembly, key)
sequence[:] = [key for key in sequence if key not in placed]
assembly.set_vertices_attribute('is_placed', True, keys=sequence)
i_min = 0
i_max = len(sequence)
i_spn = i_max - i_min
facecolor = {key: '#eeeeee' for key in assembly.vertices()}
facecolor.update({key: '#cccccc' for key in placed})
facecolor.update({
key: i_to_red((index - i_min) / i_spn)
for index, key in enumerate(sequence)
})
facecolor[key] = '#ff0000'
plotter.clear_blocks()
plotter.draw_blocks(facecolor=facecolor)
def get_force_colors_uv(volmesh, network, gradient=False, tol=0.001):
"""Returns a dictionary of (u,v)-color pairs.
Blue means compression, and red means tension.
"""
c_dict = {}
f_dict = get_force_mags(volmesh, network)
f_range = sorted(f_dict.values())
c_forces = [x for x in f_range if x < 0]
t_forces = [x for x in f_range if x > 0]
for edge in f_dict:
force = f_dict[edge]
if force < 0: # if compression
color = (0, 0, 255)
if gradient:
min_c = abs(c_forces[-1])
max_c = abs(c_forces[0])
color = i_to_blue((abs(force) - min_c) / (max_c - min_c))
if force > 0: # if tension
color = (255, 0, 0)
if gradient:
min_t = t_forces[0]
max_t = t_forces[-1]
color = i_to_red((force - min_t) / (max_t - min_t))
if force == 0 or force < tol: # if close to zero
color = (255, 255, 255)
c_dict[edge] = color
return c_dict
import random
from compas.geometry import Pointcloud, Circle
from compas.utilities import i_to_red, i_to_green
from compas_plotters import GeometryPlotter
pcl = Pointcloud.from_bounds(10, 5, 0, 100)
plotter = GeometryPlotter()
for point in pcl.points:
circle = Circle([point, [0, 0, 1]], random.random())
plotter.add(circle,
facecolor=i_to_red(random.random(), normalize=True),
edgecolor=i_to_green(random.random(), normalize=True))
plotter.zoom_extents()
plotter.show()
cloads = Array2D(loads, 'double')
cq = Array1D(q, 'double')
cfixed = Array1D(fixed, 'int')
cfree = Array1D(free, 'int')
lib.fd.argtypes = [
ctypes.c_int, ctypes.c_int, ctypes.c_int, cvertices.ctype, cedges.ctype,
cloads.ctype, cq.ctype, cfixed.ctype, cfree.ctype
]
lib.fd(ctypes.c_int(len(vertices)), ctypes.c_int(len(edges)),
ctypes.c_int(len(fixed)), cvertices.cdata, cedges.cdata, cloads.cdata,
cq.cdata, cfixed.cdata, cfree.cdata)
xyz = cvertices.pydata
for key, attr in network.vertices(True):
attr['x'] = float(xyz[key][0])
attr['y'] = float(xyz[key][1])
attr['z'] = float(xyz[key][2])
zmax = max(network.get_vertices_attribute('z'))
plotter = NetworkPlotter(network, figsize=(10, 7))
plotter.draw_vertices(facecolor={
key: i_to_red(attr['z'] / zmax)
for key, attr in network.vertices(True)
})
plotter.draw_edges()
plotter.show()
faces = cablenet.get_face_strip(start)
cables = []
for edge in parallel:
edges = cablenet.get_continuous_edges(edge)
cables.append(edges)
chained = cablenet.get_continuous_edges(start, aligned=True)
chain = list(flatten(chained[::2] + chained[-1:]))
# ==============================================================================
# Visualize
# ==============================================================================
vertexcolor = {
key: i_to_red(index / len(chain))
for index, key in enumerate(chain)
}
arrows = [{
'start': cablenet.vertex_coordinates(start[0]),
'end': cablenet.vertex_coordinates(start[1]),
'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)
})
if __name__ == "__main__":
from compas.datastructures import Network
from compas.plotters import NetworkPlotter
from compas.utilities import i_to_red
network = Network.from_obj(compas.get('saddle.obj'))
vertices = network.get_vertices_attributes('xyz')
loads = network.get_vertices_attributes(('px', 'py', 'pz'), (0.0, 0.0, 0.0))
fixed = network.leaves()
edges = list(network.edges())
q = network.get_edges_attribute('q', 1.0)
xyz = fd_cpp(vertices, edges, fixed, q, loads)
for key, attr in network.vertices(True):
attr['x'] = xyz[key][0]
attr['y'] = xyz[key][1]
attr['z'] = xyz[key][2]
zmax = max(network.get_vertices_attribute('z'))
plotter = NetworkPlotter(network, figsize=(10, 7))
plotter.draw_vertices(
facecolor={key: i_to_red(attr['z'] / zmax) for key, attr in network.vertices(True)}
)
plotter.draw_edges()
plotter.show()
def color_interfaces(self, mode=0):
"""Color the interfaces with shades of blue and red according to the forces at the corners.
Parameters
----------
mode : int, optional
Mode to switch between normal forces(0) and frictions(1)
Default is 0.
Notes
-----
* Currently only normal forces are taken into account.
* Gradients should go from blue to red over white.
* White marks the neutral line (the axis of rotational equilibrium).
* ...
Examples
--------
.. code-block:: python
pass
"""
if mode == 0:
# redraw the faces with a discretisation that makes sense for the neutral axis
# color the drawn meshes
for u, v, attr in self.assembly.edges(True):
if not attr['interface_forces']:
continue
name = "{}.interface.{}-{}".format(self.assembly.name, u, v)
guids = compas_rhino.get_objects(name=name)
if not guids:
continue
guid = guids[0]
forces = [
f['c_np'] - f['c_nn'] for f in attr['interface_forces']
]
fmin = min(forces)
fmax = max(forces)
fmax = max(abs(fmin), fmax)
colors = []
p = len(attr['interface_points'])
for i in range(p):
f = forces[i]
if f > 0.0:
color = i_to_blue(f / fmax)
elif f < 0.0:
color = i_to_red(-f / fmax)
else:
color = (255, 255, 255)
colors.append(color)
# this is obviously not correct
# just a visual reminder
if p > 4:
colors.append((255, 255, 255))
compas_rhino.set_mesh_vertex_colors(guid, colors)
elif mode == 1:
for u, v, attr in self.assembly.edges(True):
if attr['interface_forces'] is None:
continue
name = "{}.interface.{}-{}".format(self.assembly.name, u, v)
guids = compas_rhino.get_objects(name=name)
if not guids:
continue
guid = guids[0]
iu, iv = attr['interface_uvw'][0], attr['interface_uvw'][1]
forces = [
length_vector(
add_vectors(scale_vector(iu, f['c_u']),
scale_vector(iv, f['c_v'])))
for f in attr['interface_forces']
]
fmin = min(forces)
fmax = max(forces)
fmax = max(abs(fmin), fmax)
fmax = max(fmax, self.defaults['range.friction'])
colors = []
p = len(attr['interface_points'])
for i in range(p):
f = forces[i]
if f > 0.0:
color = i_to_red(f / fmax)
else:
color = (255, 255, 255)
colors.append(color)
# this is obviously not correct
# just a visual reminder
if p > 4:
colors.append((255, 255, 255))
compas_rhino.set_mesh_vertex_colors(guid, colors)
else:
print("please choose mode 0 or 1")
from random import random
from compas.geometry import pointcloud_xy
from compas_plotters import Plotter
from compas.utilities import i_to_green
from compas.utilities import i_to_red
cloud = pointcloud_xy(20, (0, 10), (0, 5))
points = []
for xyz in cloud:
n = random()
points.append({
'pos': xyz,
'radius': n,
'edgecolor': i_to_green(n),
'facecolor': i_to_red(n)
})
plotter = Plotter(figsize=(8, 5))
plotter.draw_points(points)
plotter.show()
network = Network.from_obj(compas.get('grid_irregular.obj'))
adjacency = {key: network.vertex_neighbours(key) for key in network.vertices()}
weight = {(u, v): network.edge_length(u, v) for u, v in network.edges()}
weight.update({(v, u): weight[(u, v)] for u, v in network.edges()})
target = 22
distances = dijkstra_distances(adjacency, weight, target)
plotter = NetworkPlotter(network, figsize=(10, 8), fontsize=6)
dmax = max(distances.values())
facecolor = {key: i_to_red(distances[key] / dmax) for key in network.vertices()}
text = {key: '{:.1f}'.format(distances[key]) for key in network.vertices()}
plotter.draw_vertices(
text=text,
facecolor=facecolor,
radius=0.15
)
plotter.draw_edges()
plotter.show()
# ==========================================================================
# testrun 4
# ==========================================================================
from random import random
from compas.geometry import pointcloud_xy
from compas.utilities import i_to_green
from compas.utilities import i_to_red
import compas_rhino
pc = pointcloud_xy(10, (0, 10), (-3, 3))
print(pc)
points = []
for pt in pc:
n = random()
points.append({'pos': pt, 'color': i_to_red(n)})
compas_rhino.draw_points(points, layer="points", clear=True)
"""
cloud = pointcloud_xy(200, (0, 10), (0, 5))
points = []
circles = []
for xyz in cloud:
n = random()
points.append({'pos': xyz, 'color': i_to_red(n)})
circles.append({'plane': [xyz, [0,0,1]], 'color': i_to_red(n), 'radius':n})
layerp = "points"
layerc = "circles"
compas_rhino.draw_points(points, layer=layerp, clear=True)
compas_rhino.draw_circles(circles, layer=layerp, clear=False)
"""
}
weight = {(u, v): network.edge_length(u, v)
for u, v in network.edges()}
weight.update({(v, u): weight[(u, v)] for u, v in network.edges()})
target = 22
distances = dijkstra_distances(adjacency, weight, target)
plotter = NetworkPlotter(network, figsize=(10, 8), fontsize=6)
dmax = max(distances.values())
facecolor = {
key: i_to_red(distances[key] / dmax)
for key in network.vertices()
}
text = {
key: '{:.1f}'.format(distances[key])
for key in network.vertices()
}
plotter.draw_vertices(text=text, facecolor=facecolor, radius=0.15)
plotter.draw_edges()
plotter.show()
# ==========================================================================
# testrun 4
# ==========================================================================
import os
import compas
from compas.datastructures import Mesh
from compas.topology import breadth_first_ordering
from compas.utilities import i_to_red
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)
bfo = breadth_first_ordering(mesh.adjacency, 0)
print(bfo)
n = mesh.number_of_vertices()
plotter = MeshPlotter(mesh, figsize=(16, 10))
plotter.draw_vertices(
text={key: key for key in mesh.vertices()},
radius=0.2,
facecolor={key: i_to_red(1 - index / n) for index, key in enumerate(bfo)})
plotter.draw_edges()
plotter.show()
assembly = Assembly.from_json(compas_assembly.get('wall_courses.json'))
# visualise
R = Rotation.from_axis_and_angle([1.0, 0, 0], -pi / 2)
assembly_transform(assembly, R)
plotter = AssemblyPlotter(assembly, figsize=(16, 6), tight=True)
plotter.assembly_plotter.defaults['vertex.fontsize'] = 10
courses = assembly.get_vertices_attribute('course')
c_min = min(courses)
c_max = max(courses)
c_spn = c_max - c_min
facecolor = {
key: i_to_red((attr['course'] - c_min) / c_spn)
for key, attr in assembly.vertices(True)
}
edgecolor = {
key: '#000000'
for key in assembly.vertices_where({'is_support': True})
}
edgewidth = {key: 3 for key in assembly.vertices_where({'is_support': True})}
plotter.draw_blocks(facecolor=facecolor,
edgecolor=edgecolor,
edgewidth=edgewidth)
plotter.show()
viewer = App()
nodes = []
blocks = []
interfaces = []
sides = []
colors = []
for node in assembly.nodes():
nodes.append(Point(* assembly.node_coordinates(node)))
blocks.append(assembly.node_attribute(node, 'block'))
for node in assembly.nodes():
block = assembly.node_attribute(node, 'block')
faces = sorted(block.faces(), key=lambda face: block.face_area(face))[:-2]
for face in faces:
side = Polygon(block.face_coordinates(face))
mesh = Mesh.from_polygons([side])
sides.append(mesh)
for mesh in sides:
face = list(mesh.faces())[0]
dev = mesh.face_flatness(face)
colors.append(i_to_red(dev, normalize=True))
viewer.add(Collection(blocks), show_faces=False, show_edges=True)
viewer.add(Collection(sides), colors=colors, show_edges=False)
viewer.run()
print(sequence)
# rotate the assembly for visualisation
R = Rotation.from_axis_and_angle([1.0, 0, 0], -pi / 2)
assembly_transform(assembly, R)
# make a plotter
plotter = AssemblyPlotter(assembly, figsize=(16, 6), tight=True)
plotter.assembly_plotter.defaults['vertex.fontsize'] = 10
# color vertices according to their building order
i_min = 0
i_max = len(sequence)
i_spn = i_max - i_min
facecolor = {k: '#cccccc' for k in assembly.vertices()}
facecolor.update(
{k: i_to_red((index - i_min) / i_spn)
for index, k in enumerate(sequence)})
facecolor[key] = '#ff0000'
# plot the assembly vertices
# plot the block bounding boxes
plotter.draw_blocks(facecolor=facecolor)
plotter.show()
from compas.geometry import Pointcloud, Translation
from compas.utilities import i_to_red, pairwise
from compas_plotters import Plotter
plotter = Plotter(figsize=(8, 5))
pointcloud = Pointcloud.from_bounds(8, 5, 0, 10)
for index, (a, b) in enumerate(pairwise(pointcloud)):
artist = plotter.add(a,
edgecolor=i_to_red(max(index / 10, 0.1),
normalize=True))
plotter.add(b, size=10, edgecolor=(1, 0, 0))
plotter.zoom_extents()
plotter.pause(1.0)
@plotter.on(interval=0.1,
frames=50,
record=True,
recording='docs/_images/tutorial/plotters_dynamic.gif',
dpi=150)
def move(frame):
print(frame)
for a, b in pairwise(pointcloud):
vector = b - a
a.transform(Translation.from_vector(vector * 0.1))
from random import random
from compas.geometry import pointcloud_xy
from compas.utilities import i_to_green
from compas.utilities import i_to_red
import compas_rhino
cloud = pointcloud_xy(200, (0, 10), (0, 5))
points = []
circles = []
for xyz in cloud:
n = random()
points.append({'pos': xyz, 'color': i_to_red(n)})
circles.append({
'plane': [xyz, [0, 0, 1]],
'color': i_to_red(n),
'radius': n
})
layerp = "points"
layerc = "circles"
compas_rhino.draw_points(points, layer=layerp, clear=True)
compas_rhino.draw_circles(circles, layer=layerp, clear=False)
import os
import compas
from compas.datastructures import Mesh
from compas.topology import breadth_first_ordering
from compas.utilities import i_to_red
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)
bfo = breadth_first_ordering(mesh.adjacency, 0)
v = mesh.number_of_vertices()
plotter = MeshPlotter(mesh, figsize=(16, 10))
plotter.draw_vertices(
text={key: index
for index, key in enumerate(bfo)},
radius=0.2,
facecolor={key: i_to_red(1 - index / v)
for index, key in enumerate(bfo)})
plotter.draw_edges()
plotter.draw_faces()
plotter.show()
