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()