def draw_edges(self, edges=None, color=None): """Draw a selection of edges. Parameters ---------- edges : list, optional A list of edges to draw. The default is ``None``, in which case all edges are drawn. color : 3-tuple or dict of 3-tuple, optional The color specififcation for the edges. The default color is ``(0, 0, 0)``. Returns ------- list of :class:`Rhino.Geometry.Line` """ edges = edges or list(self.network.edges()) edge_color = colordict(color, edges, default=self.color_edges) lines = [] for edge in edges: start, end = self.network.edge_coordinates(*edge) lines.append({ 'start': start, 'end': end, 'color': edge_color[edge], 'name': "{}.edge.{}-{}".format(self.network.name, *edge) }) return compas_ghpython.draw_lines(lines)
def draw_edges(self, edges=None, color=None): """Draw a selection of edges. Parameters ---------- edges : list, optional A list of edges to draw. The default is ``None``, in which case all edges are drawn. color : str, tuple, dict The color specification for the edges. The default color is ``~VolMeshArtist.default_edgecolor``. Returns ------- list of :class:`Rhino.Geometry.Line` """ self.edge_color = color edges = edges or list(self.volmesh.edges()) vertex_xyz = self.vertex_xyz lines = [] for edge in edges: lines.append({ 'start': vertex_xyz[edge[0]], 'end': vertex_xyz[edge[1]], 'color': self.edge_color.get(edge, self.default_edgecolor), 'name': "{}.edge.{}-{}".format(self.volmesh.name, *edge) }) return compas_ghpython.draw_lines(lines)
def draw_edges(self, edges=None, color=None): """Draw a selection of edges. Parameters ---------- edges : list[tuple[hashable, hashable]], optional A list of edges to draw. The default is None, in which case all edges are drawn. color : tuple[int, int, int] or dict[tuple[hashable, hashable], tuple[int, int, int]], optional The color specification for the edges. The default color is the value of :attr:`NetworkArtist.default_edgecolor`. Returns ------- list[:rhino:`Rhino.Geometry.Line`] """ self.edge_color = color node_xyz = self.node_xyz edges = edges or list(self.network.edges()) lines = [] for edge in edges: lines.append({ 'start': node_xyz[edge[0]], 'end': node_xyz[edge[1]], 'color': self.edge_color.get(edge, self.default_edgecolor), 'name': "{}.edge.{}-{}".format(self.network.name, *edge) }) return compas_ghpython.draw_lines(lines)
def draw(self): """Draw the line. Returns ------- :class:`Rhino.Geometry.Line` """ lines = [self._get_args(self.primitive)] return compas_ghpython.draw_lines(lines)[0]
def draw_axes(self): """Draw the frame's axes. Returns ------- list of :class:`Rhino.Geometry.Line` """ _, lines = self._get_args(self.primitive, self.scale, self.color_origin, self.color_xaxis, self.color_yaxis, self.color_zaxis) return compas_ghpython.draw_lines(lines)
def draw(self): """Draw the line. Returns ------- list of :class:`Rhino.Geometry.Line` """ start = list(self.primitive.start) end = list(self.primitive.end) lines = [{'start': start, 'end': end}] return compas_ghpython.draw_lines(lines)
def draw_collection(collection): """Draw the collection of lines. Parameters ---------- collection : list of compas.geometry.Line A collection of ``Line`` objects. Returns ------- list of :class:`Rhino.Geometry.Line` """ lines = [LineArtist._get_args(primitive) for primitive in collection] return compas_ghpython.draw_lines(lines)
def draw_edges(self, keys=None, color=None): """Draw a selection of edges. Parameters ---------- keys : list A list of edge keys (as uv pairs) identifying which edges to draw. The default is ``None``, in which case all edges are drawn. color : str, tuple, dict The color specififcation for the edges. 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 edges, 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['edge.color']``). The default is ``None``, in which case all edges are assigned the default edge color. Notes ----- All edges are named using the following template: ``"{}.edge.{}-{}".fromat(self.datastructure.name, u, v)``. This name is used afterwards to identify edges in the Rhino model. """ keys = keys or list(self.datastructure.edges()) colordict = color_to_colordict(color, keys, default=self.defaults.get('color.edge'), colorformat='rgb', normalize=False) lines = [] for u, v in keys: start, end = self.datastructure.edge_coordinates(u, v) lines.append({ 'start': start, 'end': end, 'color': colordict[(u, v)], 'name': "{}.edge.{}-{}".format(self.datastructure.name, u, v), 'layer': self.datastructure.edge_attribute((u, v), 'layer') }) return compas_ghpython.draw_lines(lines)
def draw(self): """Draw the frame. Returns ------- geometry : list * geometry[0] : :class:`Rhino.Geometry.Point` * geometry[1] : list of :class:`Rhino.Geometry.Line` """ point, lines = self._get_args(self.primitive, self.scale, self.color_origin, self.color_xaxis, self.color_yaxis, self.color_zaxis) geometry = [None, None] geometry[0] = compas_ghpython.draw_points([point]) geometry[1] = compas_ghpython.draw_lines(lines) return geometry
def draw(self, show_points=False, show_edges=False, show_face=True): """Draw the polygon. Parameters ---------- show_points : bool, optional If True, draw the points of the polygon. show_edges : bool, optional If True, draw the edges of the polygon. show_face : bool, optional If True, draw the face of the polygon. Returns ------- list[:rhino:`Rhino.Geometry.Point3d`, :rhino:`Rhino.Geometry.Line`, :rhino:`Rhino.Geometry.Mesh`] The Rhino points, lines and face. """ _points = map(list, self.primitive.points) result = [] if show_points: points = [{ 'pos': point, 'color': self.color, 'name': self.primitive.name } for point in _points] result += compas_ghpython.draw_points(points) if show_edges: lines = [{ 'start': list(a), 'end': list(b), 'color': self.color, 'name': self.primitive.name } for a, b in self.primitive.lines] result += compas_ghpython.draw_lines(lines) if show_face: polygons = [{ 'points': _points, 'color': self.color, 'name': self.primitive.name }] result += compas_ghpython.draw_faces(polygons) return result
def draw_edges(self, keys=None, color=None): """Draw a selection of edges. Parameters ---------- keys : list A list of edge keys (as uv pairs) identifying which edges to draw. The default is ``None``, in which case all edges are drawn. color : str, tuple, dict The color specififcation for the edges. 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 edges, 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.edges']``). The default is ``None``, in which case all edges are assigned the default edge color. Returns ------- list of :class:`Rhino.Geometry.Line` """ edges = keys or list(self.volmesh.edges()) colordict = color_to_colordict(color, edges, default=self.settings['color.edges'], colorformat='rgb', normalize=False) lines = [] for edge in edges: start, end = self.volmesh.edge_coordinates(*edge) lines.append({ 'start': start, 'end': end, 'color': colordict[edge], 'name': "{}.edge.{}-{}".format(self.volmesh.name, *edge) }) return compas_ghpython.draw_lines(lines)
def draw(self): """Draw the frame. Returns ------- geometry : list * geometry[0] : :class:`Rhino.Geometry.Point` * geometry[1] : list of :class:`Rhino.Geometry.Line` """ points = [] lines = [] origin = list(self.primitive.point) x = list(self.primitive.point + self.primitive.xaxis.scaled(self.scale)) y = list(self.primitive.point + self.primitive.yaxis.scaled(self.scale)) z = list(self.primitive.point + self.primitive.zaxis.scaled(self.scale)) points = [{'pos': origin, 'color': self.color_origin}] lines = [{ 'start': origin, 'end': x, 'color': self.color_xaxis, 'arrow': 'end' }, { 'start': origin, 'end': y, 'color': self.color_yaxis, 'arrow': 'end' }, { 'start': origin, 'end': z, 'color': self.color_zaxis, 'arrow': 'end' }] geometry = [None, None] geometry[0] = compas_ghpython.draw_points(points) geometry[1] = compas_ghpython.draw_lines(lines) return geometry
def draw(self, point=None, show_point=False): """Draw the vector. Parameters ---------- point : [float, float, float] or :class:`compas.geometry.Point`, optional Point of application of the vector. Default is ``Point(0, 0, 0)``. show_point : bool, optional If True, draw the point of application of the vector. Returns ------- list[:rhino:`Rhino.Geometry.Point3d`, :rhino:`Rhino.Geometry.Line`] The Rhino line and endpoints, if requested. """ if not point: point = [0, 0, 0] start = Point(*point) end = start + self.primitive start = list(start) end = list(end) result = [] if show_point: points = [{ 'pos': start, 'color': self.color, 'name': self.primitive.name }] result += compas_ghpython.draw_points(points) lines = [{ 'start': start, 'end': end, 'arrow': 'end', 'color': self.color, 'name': self.primitive.name }] result += compas_ghpython.draw_lines(lines) return result
def draw_collection(collection): """Draw the collections of frames. Parameters ---------- collection : list of compas.geometry.Frame A collection of ``Frame`` objects. Returns ------- geometry : list * geometry[0] : list of :class:`Rhino.Geometry.Point` * geometry[1] : list of :class:`Rhino.Geometry.Line` """ args = [FrameArtist._get_args(primitive) for primitive in collection] points, lines = zip(*args) lines = itertools.chain(*lines) geometry = [None, None] geometry[0] = compas_ghpython.draw_points(points) geometry[1] = compas_ghpython.draw_lines(lines) return geometry