def draw(self): """Draw the box associated with the artist. Returns ------- list The GUIDs of the objects created in Rhino. """ vertices = [list(vertex) for vertex in self.shape.vertices] faces = self.shape.faces edges = self.shape.edges points = [{'pos': point, 'color': self.color} for point in vertices] lines = [{ 'start': vertices[i], 'end': vertices[j], 'color': self.color } for i, j in edges] polygons = [{ 'points': [vertices[index] for index in face], 'color': self.color } for face in faces] guids = compas_rhino.draw_points(points, layer=self.layer, clear=False, redraw=False) guids += compas_rhino.draw_lines(lines, layer=self.layer, clear=False, redraw=False) guids += compas_rhino.draw_faces(polygons, layer=self.layer, clear=False, redraw=False) self._guids = guids return guids
def draw(self, u=10): """Draw the cone associated with the artist. Parameters ---------- u : int, optional Number of faces in the "u" direction. Default is ``10``. Returns ------- list The GUIDs of the objects created in Rhino. """ vertices, faces = self.shape.to_vertices_and_faces(u=u) vertices = [list(vertex) for vertex in vertices] points = [{'pos': point, 'color': self.color} for point in vertices] polygons = [{ 'points': [vertices[index] for index in face], 'color': self.color } for face in faces] guids = compas_rhino.draw_points(points, layer=self.layer, clear=False, redraw=False) guids += compas_rhino.draw_faces(polygons, layer=self.layer, clear=False, redraw=False) self._guids = guids return guids
def draw_faces(self, keys=None, color=None, join_faces=False): """Draw a selection of faces. Parameters ---------- fkeys : list A list of face keys identifying which faces to draw. The default is ``None``, in which case all faces are drawn. color : str, tuple, dict The color specififcation for the faces. Colors should be specified in the form of a string (hex colors) or as a tuple of RGB components. To apply the same color to all faces, provide a single color specification. Individual colors can be assigned using a dictionary of key-color pairs. Missing keys will be assigned the default face color (``self.defaults['face.color']``). The default is ``None``, in which case all faces are assigned the default face color. Notes ----- The faces are named using the following template: ``"{}.face.{}".format(self.datastructure.name, key)``. This name is used afterwards to identify faces in the Rhino model. """ keys = keys or list(self.datastructure.faces()) colordict = color_to_colordict(color, keys, default=self.defaults.get('color.face'), colorformat='rgb', normalize=False) faces = [] for fkey in keys: faces.append({ 'points': self.datastructure.face_coordinates(fkey), 'name': self.datastructure.face_name(fkey), 'color': colordict[fkey], 'layer': self.datastructure.face_attribute(fkey, 'layer', None) }) guids = compas_rhino.draw_faces(faces, layer=self.layer, clear=False, redraw=False) if not join_faces: return guids guid = rs.JoinMeshes(guids, delete_input=True) rs.ObjectLayer(guid, self.layer) rs.ObjectName(guid, '{}.mesh'.format(self.datastructure.name)) if color: rs.ObjectColor(guid, color) return guid
def draw_interfaces(self, keys=None, color=None): """Draw the interfaces between the blocks. Parameters ---------- keys : list A list of interface identifiers (i.e. assembly edge (u, v) tuples). Default is ``None``, in which case all interfaces are drawn. color : str, tuple, dict The color specififcation for the interfaces. Colors should be specified in the form of a string (hex colors) or as a tuple of RGB components. To apply the same color to all interfaces, provide a single color specification. Individual colors can be assigned using a dictionary of key-color pairs. Missing keys will be assigned the default interface color (``self.settings['color.interface']``). The default is ``None``, in which case all interfaces are assigned the default interface color. Notes ----- * Interfaces are drawn as mesh faces. * Interfaces are drawn on a sub-layer *Interfaces* of the base layer, if a base layer was provided. * Interface names have the following pattern: ``"{assembly_name}.interface.{from block_id}-{to block_id}"`` * Interfaces have a direction, as suggested by the naming convention. """ layer = "{}::Interfaces".format(self.layer) if self.layer else None faces = [] keys = keys or list(self.assembly.edges()) colordict = color_to_colordict( color, keys, default=self.settings.get('color.interface'), colorformat='rgb', normalize=False) for (u, v), attr in self.assembly.edges(True): faces.append({ 'points': attr['interface_points'], 'name': "{}.interface.{}-{}".format(self.assembly.name, u, v), 'color': colordict[(u, v)] }) compas_rhino.draw_faces(faces, layer=layer, clear=False, redraw=False)
def draw_faces(self, keys=None, color=None, join_faces=False): """Draw a selection of faces. Parameters ---------- fkeys : list A list of face keys identifying which faces to draw. The default is ``None``, in which case all faces are drawn. color : str, tuple, dict The color specififcation for the faces. Colors should be specified in the form of a string (hex colors) or as a tuple of RGB components. To apply the same color to all faces, provide a single color specification. Individual colors can be assigned using a dictionary of key-color pairs. Missing keys will be assigned the default face color (``self.settings['color.faces']``). The default is ``None``, in which case all faces are assigned the default face color. join_faces : bool, optional Join the faces into 1 mesh. Default is ``False``, in which case the faces are drawn as individual meshes. Returns ------- list The GUIDs of the created Rhino objects. """ faces = keys or list(self.mesh.faces()) face_color = color_to_colordict(color, faces, default=self.settings['color.faces'], colorformat='rgb', normalize=False) facets = [] for face in faces: facets.append({ 'points': self.mesh.face_coordinates(face), 'name': "{}.face.{}".format(self.mesh.name, face), 'color': face_color[face] }) guids = compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False) if not join_faces: self.guid_face = zip(guids, faces) return guids guid = compas_rhino.rs.JoinMeshes(guids, delete_input=True) compas_rhino.rs.ObjectLayer(guid, self.layer) compas_rhino.rs.ObjectName(guid, '{}.mesh'.format(self.mesh.name)) if color: compas_rhino.rs.ObjectColor(guid, color) self.guids += [guid] return [guid]
def draw(self, show_points=False, show_edges=False, show_face=True): """Draw the polygon. Parameters ---------- show_points : bool, optional If True, draw the corner points of the polygon. show_edges : bool, optional If True, draw the boundary edges of the polygon. show_face : bool, optional If True, draw the face of the polygon. Returns ------- list[System.Guid] The GUIDs of the created Rhino objects. """ _points = map(list, self.primitive.points) guids = [] if show_points: points = [{ 'pos': point, 'color': self.color, 'name': self.primitive.name } for point in _points] guids += compas_rhino.draw_points(points, layer=self.layer, clear=False, redraw=False) if show_edges: lines = [{ 'start': list(a), 'end': list(b), 'color': self.color, 'name': self.primitive.name } for a, b in self.primitive.lines] guids += compas_rhino.draw_lines(lines, layer=self.layer, clear=False, redraw=False) if show_face: polygons = [{ 'points': _points, 'color': self.color, 'name': self.primitive.name }] guids += compas_rhino.draw_faces(polygons, layer=self.layer, clear=False, redraw=False) return guids
def draw(self, u=10, v=10, show_vertices=False, show_edges=False, show_faces=True, join_faces=True): """Draw the sphere associated with the artist. Parameters ---------- u : int, optional Number of faces in the "u" direction. Default is ``10``. v : int, optional Number of faces in the "v" direction. Default is ``10``. show_vertices : bool, optional Default is ``False``. show_edges : bool, optional Default is ``False``. show_faces : bool, optional Default is ``True``. join_faces : bool, optional Default is ``True``. Returns ------- list The GUIDs of the objects created in Rhino. """ vertices, faces = self.shape.to_vertices_and_faces(u=u, v=v) vertices = [list(vertex) for vertex in vertices] guids = [] if show_vertices: points = [{'pos': point, 'color': self.color} for point in vertices] guids += compas_rhino.draw_points(points, layer=self.layer, clear=False, redraw=False) if show_edges: lines = [] seen = set() for face in faces: for u, v in pairwise(face + face[:1]): if (u, v) not in seen: seen.add((u, v)) seen.add((v, u)) lines.append({'start': vertices[u], 'end': vertices[v], 'color': self.color}) guids += compas_rhino.draw_lines(lines, layer=self.layer, clear=False, redraw=False) if show_faces: if join_faces: guid = compas_rhino.draw_mesh(vertices, faces, layer=self.layer, name=self.name, color=self.color, disjoint=True) guids.append(guid) else: polygons = [{'points': [vertices[index] for index in face], 'color': self.color} for face in faces] guids += compas_rhino.draw_faces(polygons, layer=self.layer, clear=False, redraw=False) self._guids = guids return guids
def draw_cells(self, cells=None, color=None): """Draw a selection of cells. Parameters ---------- cells : list[int], optional A list of cells to draw. The default is None, in which case all cells are drawn. color : tuple[int, int, int] or dict[int, tuple[int, int, int]], optional The color of the cells. The default color is :attr:`VolMeshArtist.default_cellcolor`. Returns ------- list[System.Guid] The GUIDs of the created Rhino objects. Every cell is drawn as an individual mesh. """ self.cell_color = color cells = cells or list(self.volmesh.cells()) vertex_xyz = self.vertex_xyz meshes = [] for cell in cells: cell_faces = [] for fkey in self.volmesh.cell_faces(cell): cell_faces.append({ 'points': [ vertex_xyz[vertex] for vertex in self.volmesh.face_vertices(fkey) ], 'name': "{}.cell.{}.face.{}".format(self.volmesh.name, cell, fkey), 'color': self.cell_color.get(cell, self.default_cellcolor) }) guids = compas_rhino.draw_faces(cell_faces, layer=self.layer, clear=False, redraw=False) guid = compas_rhino.rs.JoinMeshes(guids, delete_input=True) compas_rhino.rs.ObjectLayer(guid, self.layer) compas_rhino.rs.ObjectName( guid, '{}.cell.{}'.format(self.volmesh.name, cell)) compas_rhino.rs.ObjectColor( guid, self.cell_color.get(cell, self.default_cellcolor)) meshes.append(guid) return meshes
def draw_faces(self, faces=None, color=None, join_faces=False): """Draw a selection of faces. Parameters ---------- faces : list, optional A selection of faces to draw. The default is ``None``, in which case all faces are drawn. color : tuple or dict of tuple, optional The color specififcation for the faces. The default color is black ``(0, 0, 0)``. join_faces : bool, optional Join the faces into 1 mesh. Default is ``False``, in which case the faces are drawn as individual meshes. Returns ------- list The GUIDs of the created Rhino objects. """ faces = faces or list(self.mesh.faces()) vertex_xyz = self.vertex_xyz face_color = colordict(color, faces, default=self.color_faces) facets = [] for face in faces: facets.append({ 'points': [ vertex_xyz[vertex] for vertex in self.mesh.face_vertices(face) ], 'name': "{}.face.{}".format(self.mesh.name, face), 'color': face_color[face] }) guids = compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False) if not join_faces: return guids guid = compas_rhino.rs.JoinMeshes(guids, delete_input=True) compas_rhino.rs.ObjectLayer(guid, self.layer) compas_rhino.rs.ObjectName(guid, '{}'.format(self.mesh.name)) if color: compas_rhino.rs.ObjectColor(guid, color) return [guid]
def draw_cells(self, cells=None, color=None): """Draw a selection of cells. Parameters ---------- cells : list A list of cells to draw. The default is ``None``, in which case all cells are drawn. color : str, tuple, dict The color specififcation for the cells. The default color is ``(255, 0, 0)``. Returns ------- list The GUIDs of the created Rhino objects. Every cell is drawn as an individual mesh. """ cells = cells or list(self.volmesh.cells()) vertex_xyz = self.vertex_xyz cell_color = colordict(color, cells, default=self.color_cells) meshes = [] for cell in cells: cell_faces = [] for fkey in self.volmesh.cell_faces(cell): cell_faces.append({ 'points': [ vertex_xyz[vertex] for vertex in self.volmesh.face_vertices(fkey) ], 'name': "{}.cell.{}.face.{}".format(self.volmesh.name, cell, fkey), 'color': cell_color[cell] }) guids = compas_rhino.draw_faces(cell_faces, layer=self.layer, clear=False, redraw=False) guid = compas_rhino.rs.JoinMeshes(guids, delete_input=True) compas_rhino.rs.ObjectLayer(guid, self.layer) compas_rhino.rs.ObjectName( guid, '{}.cell.{}'.format(self.volmesh.name, cell)) compas_rhino.rs.ObjectColor(guid, cell_color[cell]) meshes.append(guid) return meshes
def draw_faces(self, faces=None, color=None, join_faces=False): """Draw a selection of faces. Parameters ---------- faces : list[int], optional A selection of faces to draw. The default is None, in which case all faces are drawn. color : tuple[int, int, int] or dict[int, tuple[int, int, int]], optional The color of the faces. The default color is the value of :attr:`MeshArtist.default_facecolor`. join_faces : bool, optional If True, join the faces into a single mesh. Returns ------- list[System.Guid] The GUIDs of the created Rhino objects. """ self.face_color = color faces = faces or self.faces vertex_xyz = self.vertex_xyz facets = [] for face in faces: facets.append({ 'points': [ vertex_xyz[vertex] for vertex in self.mesh.face_vertices(face) ], 'name': "{}.face.{}".format(self.mesh.name, face), 'color': self.face_color.get(face, self.default_facecolor) }) guids = compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False) if join_faces: guid = compas_rhino.rs.JoinMeshes(guids, delete_input=True) compas_rhino.rs.ObjectLayer(guid, self.layer) compas_rhino.rs.ObjectName(guid, '{}.mesh'.format(self.mesh.name)) compas_rhino.rs.ObjectColor(guid, color) guids = [guid] return guids
def draw_faces(self, faces=None, color=None, join_faces=False): """Draw a selection of faces. Parameters ---------- faces : list, optional A selection of faces to draw. The default is ``None``, in which case all faces are drawn. color : tuple or dict of tuple, optional The color specification for the faces. The default color is the value of ``~MeshArtist.default_facecolor``. join_faces : bool, optional Join the faces into 1 mesh. Default is ``False``, in which case the faces are drawn as individual meshes. Returns ------- list The GUIDs of the created Rhino objects. """ self.face_color = color faces = faces or self.faces vertex_xyz = self.vertex_xyz facets = [] for face in faces: facets.append({ 'points': [vertex_xyz[vertex] for vertex in self.mesh.face_vertices(face)], 'name': "{}.face.{}".format(self.mesh.name, face), 'color': self.face_color.get(face, self.default_facecolor) }) guids = compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False) if join_faces: guid = compas_rhino.rs.JoinMeshes(guids, delete_input=True) compas_rhino.rs.ObjectLayer(guid, self.layer) compas_rhino.rs.ObjectName(guid, '{}.mesh'.format(self.mesh.name)) compas_rhino.rs.ObjectColor(guid, color) guids = [guid] return guids
def draw(self, show_vertices=False, show_edges=False, show_faces=True, join_faces=True): """Draw the polyhedron associated with the artist. Parameters ---------- show_vertices : bool, optional Default is ``False``. show_edges : bool, optional Default is ``False``. show_faces : bool, optional Default is ``True``. join_faces : bool, optional Default is ``True``. Returns ------- list The GUIDs of the objects created in Rhino. """ vertices = [list(vertex) for vertex in self.shape.vertices] guids = [] if show_vertices: points = [{'pos': point, 'color': self.color, 'name': str(index)} for index, point in enumerate(vertices)] guids += compas_rhino.draw_points(points, layer=self.layer, clear=False, redraw=False) if show_edges: edges = self.shape.edges lines = [{'start': vertices[i], 'end': vertices[j], 'color': self.color} for i, j in edges] guids += compas_rhino.draw_lines(lines, layer=self.layer, clear=False, redraw=False) if show_faces: faces = self.shape.faces if join_faces: guid = compas_rhino.draw_mesh(vertices, faces, layer=self.layer, name=self.name, color=self.color, disjoint=True) guids.append(guid) else: polygons = [{'points': [vertices[index] for index in face], 'color': self.color} for face in faces] guids += compas_rhino.draw_faces(polygons, layer=self.layer, clear=False, redraw=False) self._guids = guids return guids
def draw_faces(self, faces=None, color=None): """Draw a selection of faces. Parameters ---------- faces : list A list of faces to draw. The default is ``None``, in which case all faces are drawn. color : str, tuple, dict The color specififcation for the faces. The default color is ``(210, 210, 210)``. Returns ------- list The GUIDs of the created Rhino objects. """ faces = faces or list(self.volmesh.faces()) vertex_xyz = self.vertex_xyz face_color = colordict(color, faces, default=self.color_faces) facets = [] for face in faces: facets.append({ 'points': [ vertex_xyz[vertex] for vertex in self.volmesh.halfface_vertices(face) ], 'name': "{}.face.{}".format(self.volmesh.name, face), 'color': face_color[face] }) return compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False)
def draw_faces(self, faces=None, color=None): """Draw a selection of faces. Parameters ---------- faces : list[int], optional A list of faces to draw. The default is None, in which case all faces are drawn. color : tuple[int, int, int] or dict[int, tuple[int, int, int]], optional The color of the faces. The default color is :attr:`VolMeshArtist.default_facecolor`. Returns ------- list[System.Guid] The GUIDs of the created Rhino objects. """ self.face_color = color faces = faces or list(self.volmesh.faces()) vertex_xyz = self.vertex_xyz facets = [] for face in faces: facets.append({ 'points': [ vertex_xyz[vertex] for vertex in self.volmesh.halfface_vertices(face) ], 'name': "{}.face.{}".format(self.volmesh.name, face), 'color': self.face_color.get(face, self.default_facecolor) }) return compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False)
f1 = mesh.halfedge_face(vertex, nbr) c1 = mesh.face_centroid(f1) v1 = subtract_vectors(c1, a) f2 = mesh.halfedge_face(nbr, vertex) c2 = mesh.face_centroid(f2) v2 = subtract_vectors(c2, a) a1 = 0.25 * length_vector(cross_vectors(v0, v1)) a2 = 0.25 * length_vector(cross_vectors(v0, v2)) lines.append({'start': a, 'end': b, 'arrow': 'end', 'color': (0, 0, 255)}) lines.append({'start': a, 'end': c1, 'arrow': 'end', 'color': (255, 0, 0)}) polygons.append({'points': [a, b, add_vectors(b, v1), c1], 'color': (255, 0, 0)}) polygons.append({'points': [a, b, add_vectors(b, v2), c2], 'color': (0, 0, 255)}) # visualize artist = CablenetArtist(mesh, layer="ITA20::L5::FormFinding") artist.clear_layer() artist.draw_vertices(color={vertex: (255, 0, 0) for vertex in mesh.vertices_where({'is_anchor': True})}) artist.draw_edges() artist.draw_faces() compas_rhino.draw_lines(lines, layer=artist.layer) compas_rhino.draw_faces(polygons, layer=artist.layer)
from __future__ import absolute_import
def draw(self): """Draw the objects representing the thrust diagram. """ layer = self.settings['layer'] self.artist.layer = layer self.artist.clear_layer() self.clear() if not self.visible: return self.artist.vertex_xyz = self.vertex_xyz # ====================================================================== # Groups # ------ # Create groups for vertices, edges, and faces. # These groups will be turned on/off based on the visibility settings of the diagram. # Separate groups are created for free and anchored vertices. # ====================================================================== group_free = "{}::vertices_free".format(layer) group_anchor = "{}::vertices_anchor".format(layer) group_edges = "{}::edges".format(layer) group_faces = "{}::faces".format(layer) if not compas_rhino.rs.IsGroup(group_free): compas_rhino.rs.AddGroup(group_free) if not compas_rhino.rs.IsGroup(group_anchor): compas_rhino.rs.AddGroup(group_anchor) if not compas_rhino.rs.IsGroup(group_edges): compas_rhino.rs.AddGroup(group_edges) if not compas_rhino.rs.IsGroup(group_faces): compas_rhino.rs.AddGroup(group_faces) # ====================================================================== # Vertices # -------- # Draw the vertices and add them to the vertex group. # Free vertices and anchored vertices are drawn separately. # ====================================================================== free = list(self.mesh.vertices_where({'is_anchor': False})) anchors = list(self.mesh.vertices_where({'is_anchor': True})) color_free = self.settings['color.vertices'] if self.settings['_is.valid'] else self.settings['color.invalid'] color_anchor = self.settings['color.vertices:is_anchor'] color = {vertex: color_free for vertex in free} color.update({vertex: color_anchor for vertex in anchors}) guids_free = self.artist.draw_vertices(free, color) guids_anchor = self.artist.draw_vertices(anchors, color) self.guid_free = zip(guids_free, free) self.guid_anchor = zip(guids_anchor, anchors) compas_rhino.rs.AddObjectsToGroup(guids_free, group_free) compas_rhino.rs.AddObjectsToGroup(guids_anchor, group_anchor) if self.settings['show.vertices']: compas_rhino.rs.HideGroup(group_free) compas_rhino.rs.ShowGroup(group_anchor) else: compas_rhino.rs.HideGroup(group_free) compas_rhino.rs.HideGroup(group_anchor) # ====================================================================== # Edges # ----- # Draw the edges and add them to the edge group. # ====================================================================== edges = list(self.mesh.edges_where({'_is_edge': True})) color = {edge: self.settings['color.edges'] if self.settings['_is.valid'] else self.settings['color.invalid'] for edge in edges} # color analysis if self.scene and self.scene.settings['RV2']['show.forces']: if self.mesh.dual: _edges = list(self.mesh.dual.edges()) lengths = [self.mesh.dual.edge_length(*edge) for edge in _edges] edges = [self.mesh.dual.primal_edge(edge) for edge in _edges] lmin = min(lengths) lmax = max(lengths) for edge, length in zip(edges, lengths): if lmin != lmax: color[edge] = i_to_rgb((length - lmin) / (lmax - lmin)) guids = self.artist.draw_edges(edges, color) self.guid_edge = zip(guids, edges) compas_rhino.rs.AddObjectsToGroup(guids, group_edges) if self.settings['show.edges']: compas_rhino.rs.ShowGroup(group_edges) else: compas_rhino.rs.HideGroup(group_edges) # ====================================================================== # Faces # ----- # Draw the faces and add them to the face group. # ====================================================================== if self.settings['show.faces']: faces = list(self.mesh.faces_where({'_is_loaded': True})) color = {face: self.settings['color.faces'] if self.settings['_is.valid'] else self.settings['color.invalid'] for face in faces} if self.settings['show.stresses'] and self.settings['_is.valid']: vertices = list(self.mesh.vertices()) vertex_colors = {vertex: self.settings['color.vertices'] if self.settings['_is.valid'] else self.settings['color.invalid'] for vertex in vertices} stresses = [self.mesh.vertex_lumped_stress(vertex) for vertex in vertices] smin = min(stresses) smax = max(stresses) for vertex, stress in zip(vertices, stresses): if smin != smax: vertex_colors[vertex] = i_to_rgb((stress - smin) / (smax - smin)) facets = [] for face in faces: facets.append({ 'points': self.mesh.face_coordinates(face), 'name': "{}.face.{}".format(self.mesh.name, face), 'vertexcolors': [vertex_colors[vertex] for vertex in self.mesh.face_vertices(face)]}) guids = compas_rhino.draw_faces(facets, layer=self.layer, clear=False, redraw=False) else: guids = self.artist.draw_faces(faces, color) self.guid_face = zip(guids, faces) compas_rhino.rs.AddObjectsToGroup(guids, group_faces) compas_rhino.rs.ShowGroup(group_faces) else: compas_rhino.rs.HideGroup(group_faces) # ====================================================================== # Overlays # -------- # Color overlays for various display modes. # ====================================================================== if self.settings['_is.valid'] and self.settings['show.selfweight']: tol = self.settings['tol.selfweight'] vertices = list(self.mesh.vertices()) color = self.settings['color.selfweight'] scale = self.settings['scale.selfweight'] guids = self.artist.draw_selfweight(vertices, color, scale, tol) self.guid_selfweight = zip(guids, vertices) if self.settings['_is.valid'] and self.settings['show.loads']: tol = self.settings['tol.externalforces'] vertices = list(self.mesh.vertices()) color = self.settings['color.loads'] scale = self.settings['scale.externalforces'] guids = self.artist.draw_loads(vertices, color, scale, tol) self.guid_load = zip(guids, vertices) if self.settings['_is.valid'] and self.settings['show.residuals']: tol = self.settings['tol.residuals'] vertices = list(self.mesh.vertices_where({'is_anchor': False})) color = self.settings['color.residuals'] scale = self.settings['scale.residuals'] guids = self.artist.draw_residuals(vertices, color, scale, tol) self.guid_residual = zip(guids, vertices) if self.settings['_is.valid'] and self.settings['show.reactions']: tol = self.settings['tol.externalforces'] anchors = list(self.mesh.vertices_where({'is_anchor': True})) color = self.settings['color.reactions'] scale = self.settings['scale.externalforces'] guids = self.artist.draw_reactions(anchors, color, scale, tol) self.guid_reaction = zip(guids, anchors) if self.settings['_is.valid'] and self.settings['show.pipes']: tol = self.settings['tol.pipes'] edges = list(self.mesh.edges_where({'_is_edge': True})) color = {edge: self.settings['color.pipes'] for edge in edges} # color analysis if self.scene and self.scene.settings['RV2']['show.forces']: if self.mesh.dual: _edges = list(self.mesh.dual.edges()) lengths = [self.mesh.dual.edge_length(*edge) for edge in _edges] edges = [self.mesh.dual.primal_edge(edge) for edge in _edges] lmin = min(lengths) lmax = max(lengths) for edge, length in zip(edges, lengths): if lmin != lmax: color[edge] = i_to_rgb((length - lmin) / (lmax - lmin)) scale = self.settings['scale.pipes'] guids = self.artist.draw_pipes(edges, color, scale, tol) self.guid_pipe = zip(guids, edges)
uv_c_dict = get_force_colors_uv(forcediagram, formdiagram, gradient=True) # uv_c_dict = get_index_colordict(list(formdiagram.edges())) hf_c_dict = get_force_colors_hf(forcediagram, formdiagram, uv_c_dict=uv_c_dict) # 2. compute unified diagram geometries ---------------------------------------- halffaces, prism_faces = volmesh_ud(forcediagram, formdiagram, scale=alpha) # 3. halffaces and prisms ------------------------------------------------------ faces = [] for hfkey in hfkeys: vkeys = forcediagram.halfface[hfkey] hf_xyz = [halffaces[hfkey][i] for i in vkeys] name = '{}.face.ud.{}'.format(forcediagram.name, hfkey) faces.append({'points': hf_xyz, 'name': name, 'color': hf_color}) forces = get_force_mags(forcediagram, formdiagram) for uv in prism_faces: name = '{}.face.ud.prism.{}'.format(forcediagram.name, uv) for face in prism_faces[uv]: faces.append({'points': face, 'name': name, 'color': uv_c_dict[uv]}) # 4. draw ---------------------------------------------------------------------- formdiagram.draw_edges(color=uv_c_dict) compas_rhino.draw_faces(faces, layer=forcediagram.layer, clear=False, redraw=False)