def clear(self): guids_nodes = list(self.guid_node.keys()) guids_edges = list(self.guid_edge.keys()) guids = guids_nodes + guids_edges compas_rhino.delete_objects(guids, purge=True) self._guid_node = {} self._guid_edge = {}
def display_mesh_face_normals(mesh, display=True, layer=None, scale=1.0, color=(0, 0, 255)): guids = compas_rhino.get_objects( name='{0}.face.normal.*'.format(mesh.attributes['name'])) compas_rhino.delete_objects(guids) if not display: return lines = [] for fkey in mesh.faces(): normal = mesh.face_normal(fkey) start = mesh.face_center(fkey) end = [start[axis] + normal[axis] for axis in range(3)] name = '{0}.face.normal.{1}'.format(mesh.attributes['name'], fkey) lines.append({ 'start': start, 'end': end, 'name': name, 'color': color, 'arrow': 'end', }) compas_rhino.xdraw_lines(lines, layer=layer, clear=False, redraw=True)
def clear(self): guids_vertices = list(self.guid_vertex.keys()) guids_faces = list(self.guid_face.keys()) guids_edges = list(self.guid_edge.keys()) guids = guids_vertices + guids_faces + guids_edges compas_rhino.delete_objects(guids, purge=True) self._guid_vertex = {} self._guid_face = {} self._guid_edge = {}
def clear(self): """Delete all objects drawn by this artist. Returns ------- None """ guids = compas_rhino.get_objects(name="{}.*".format(self.network.name)) compas_rhino.delete_objects(guids, purge=True)
def clear_mesh(self): """Delete the mesh drawn by this artist. Returns ------- None """ guids = compas_rhino.get_objects(name="{}.mesh".format(self.mesh.name)) compas_rhino.delete_objects(guids, purge=True)
def clear_vertices(self): """Delete all vertices drawn by this artist. Returns ------- None """ guids = compas_rhino.get_objects( name="{}.vertex.*".format(self.mesh.name)) compas_rhino.delete_objects(guids, purge=True)
def clear_vertexlabels(self, keys=None): if not keys: name = '{}.vertex.label.*'.format(self.datastructure.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = self.datastructure.vertex_label_name(key) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_vertices(self, keys=None): if not keys: name = '{}.vertex.*'.format(self.mesh.attributes['name']) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = '{}.vertex.{}'.format(self.attributes['name'], key) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_edges(self, keys=None): if not keys: name = '{}.edge.*'.format(self.mesh.attributes['name']) guids = compas_rhino.get_objects(name=name) else: guids = [] for u, v in keys: name = '{}.edge.{}-{}'.format(self.attributes['name'], u, v) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_edges(self, keys=None): if not keys: name = '{}.edge.*'.format(self.datastructure.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for u, v in keys: name = self.datastructure.edge_name(u, v) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_facelabels(self): """Delete all face labels drawn by this artist. Returns ------- None """ guids = compas_rhino.get_objects( name="{}.facelabel.*".format(self.mesh.name)) compas_rhino.delete_objects(guids, purge=True)
def clear(self): """Clear all objects previously drawn by this artist. """ compas_rhino.delete_objects(self.guids, purge=True) self._guid_vertex = {} self._guid_edge = {} self._guid_face = {} self._guid_cell = {} self._guid_vertexlabel = {} self._guid_edgelabel = {} self._guid_facelabel = {} self._guid_celllabel = {}
def clear(self): """Clear all Rhino objects associated with this object. """ compas_rhino.delete_objects(self.guids, purge=True) self._guids = [] self._guid_vertex = {} self._guid_edge = {} self._guid_face = {} self._guid_vertexnormal = {} self._guid_facenormal = {} self._guid_vertexlabel = {} self._guid_edgelabel = {} self._guid_facelabel = {}
def network_draw_axial_forces(network, scale=0.1, layer=None, clear_layer=False): cylinders = [] for u, v, attr in network.edges(True): if attr['f'] > 0.0: cylinders.append({ 'start' : network.vertex_coordinates(u), 'end' : network.vertex_coordinates(v), 'radius': scale * 3.14159 * attr['f'] ** 2, 'name' : '{}.axial.{}-{}'.format(network.name, u, v), 'color' : (255, 0, 0), }) guids = compas_rhino.get_objects(name='{}.axial.*'.format(network.name)) compas_rhino.delete_objects(guids) compas_rhino.xdraw_cylinders(cylinders, layer=layer, clear=clear_layer)
def move_network(network): """Move the entire network. Parameters: network (compas.datastructures.network.Network): A network object. """ color = Rhino.ApplicationSettings.AppearanceSettings.FeedbackColor origin = {key: network.vertex_coordinates(key) for key in network.vertices()} vertex = {key: network.vertex_coordinates(key) for key in network.vertices()} edges = network.edges() start = compas_rhino.pick_point('Point to move from?') if not start: return def OnDynamicDraw(sender, e): current = list(e.CurrentPoint) vec = [current[i] - start[i] for i in range(3)] for key in vertex: vertex[key] = [origin[key][i] + vec[i] for i in range(3)] for u, v in iter(edges): sp = vertex[u] ep = vertex[v] sp = Point3d(*sp) ep = Point3d(*ep) e.Display.DrawDottedLine(sp, ep, color) guids = compas_rhino.get_objects(name='{0}.*'.format(network.attributes['name'])) compas_rhino.delete_objects(guids, False) gp = Rhino.Input.Custom.GetPoint() gp.SetCommandPrompt('Point to move to?') gp.DynamicDraw += OnDynamicDraw gp.Get() if gp.CommandResult() == Rhino.Commands.Result.Success: end = list(gp.Point()) vec = [end[i] - start[i] for i in range(3)] for key, attr in network.vertices(True): attr['x'] += vec[0] attr['y'] += vec[1] attr['z'] += vec[2] try: network.draw() except AttributeError: # this may result in the network being drawn in a different layer then before draw_network(network)
def draw_mesh_as_faces(mesh, layer=None, clear_layer=False, facecolor=None, redraw=True): guids = compas_rhino.get_objects( name='{0}.*'.format(mesh.attributes['name'])) compas_rhino.delete_objects(guids) if clear_layer: if not layer: compas_rhino.clear_current_layer() else: compas_rhino.clear_layer(layer) facecolor = facecolor or {} meshes = [] for fkey in mesh.faces(): vertices = mesh.face_coordinates(fkey) faces = [range(len(vertices))] color = facecolor.get(fkey, (255, 255, 255)) guid = compas_rhino.xdraw_mesh(vertices, faces, None, '{0}.face.{1}'.format( mesh.attributes['name'], fkey), layer=layer, clear=False, redraw=False) compas_rhino.set_mesh_vertex_colors( guid, [color for i in range(len(vertices))]) meshes.append(guid) if layer: previous = rs.CurrentLayer(layer) guid = rs.JoinMeshes(meshes, delete_input=True) if layer: rs.CurrentLayer(previous) rs.ObjectName(guid, '{0}'.format(mesh.attributes['name'])) rs.EnableRedraw() rs.Redraw()
def network_draw_loads(network, scale=1.0, layer=None, clear_layer=False): lines = [] for key, attr in network.vertices(True): if not attr['is_fixed']: force = attr['px'], attr['py'], attr['pz'] start = network.vertex_coordinates(key) end = [start[axis] + scale * force[axis] for axis in (0, 1, 2)] lines.append({ 'start': start, 'end' : end, 'name' : '{}.load.{}'.format(network.name, key), 'color': (0, 255, 255), 'arrow': 'end', }) guids = compas_rhino.get_objects(name='{}.load.*'.format(network.name)) compas_rhino.delete_objects(guids) compas_rhino.xdraw_lines(lines, layer=layer, clear=clear_layer)
def clear(self): super(ThrustObject, self).clear() guids = [] guids += list(self.guid_free) guids += list(self.guid_anchor) guids += list(self.guid_selfweight) guids += list(self.guid_reaction) guids += list(self.guid_load) guids += list(self.guid_residual) guids += list(self.guid_pipe) compas_rhino.delete_objects(guids, purge=True) self._guid_free = {} self._guid_anchor = {} self._guid_selfweight = {} self._guid_load = {} self._guid_residual = {} self._guid_reaction = {} self._guid_pipe = {}
def clear_edgelabels(self, keys=None): """Clear all previously drawn edge labels. Parameters ---------- keys : list, optional The keys of a specific set of edges of which the labels should be cleared. Default is to clear all edge labels. """ if not keys: name = '{}.edge.label.*'.format(self.mesh.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for u, v in keys: name = '{}.edge.label.{}-{}'.format(self.mesh.name, u, v) guids += compas_rhino.get_objects(name=name) compas_rhino.delete_objects(guids)
def RunCommand(is_interactive): scene = get_scene() if not scene: return guids = compas_rhino.select_point() if not guids: return pt = compas_rhino.get_point_coordinates([guids])[0] skeleton = Skeleton.from_center_point(pt) if not skeleton: return compas_rhino.delete_objects([guids]) rhinoskeleton = scene.add(skeleton, 'skeleton') rhinoskeleton.dynamic_draw_self() rhinoskeleton.draw_self()
def clear_vertexlabels(self, keys=None): """Clear all previously drawn vertex labels. Parameters ---------- keys : list, optional The keys of a specific set of vertex labels that should be cleared. Default is to clear all vertex labels. """ if not keys: name = '{}.vertex.label.*'.format(self.mesh.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = '{}.vertex.label.{}'.format(self.mesh.name, key) guids += compas_rhino.get_objects(name=name) compas_rhino.delete_objects(guids)
def clear_facenormals(self, keys=None): """Clear the all previously drawn face normals. Parameters ---------- keys : list, optional The keys of a specific set of faces of which the normals should be cleared. Default is to clear the normals of all faces. """ if not keys: name = '{}.face.normal.*'.format(self.mesh.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = '{}.face.normal.{}'.format(self.mesh.name, key) guids += compas_rhino.get_objects(name=name) compas_rhino.delete_objects(guids)
def clear_nodes(self, keys=None): """Clear all previously drawn nodes. Parameters ---------- keys : list, optional The keys of a specific set of nodes that should be cleared. Default is to clear all nodes. """ if not keys: name = '{}.node.*'.format(self.network.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = '{}.node.{}'.format(self.network.name, key) guids += compas_rhino.get_objects(name=name) compas_rhino.delete_objects(guids)
def closest_point_on_boundaries(self, xyz): """Return the XYZ coordinates of the closest point on the boundaries of the surface from input XYZ-coordinates. Parameters ---------- xyz : list XYZ coordinates. Returns ------- list The XYZ coordinates of the closest point on the boundaries of the surface. """ from .curve import RhinoCurve borders = self.borders(type=0) proj_dist = {tuple(proj_xyz): distance_point_point(xyz, proj_xyz) for proj_xyz in [RhinoCurve(border).closest_point(xyz) for border in borders]} compas_rhino.delete_objects(borders) return min(proj_dist, key=proj_dist.get)
def clear_facenormals(self, keys=None): """Clear the normals of all faces previously drawn by the ``FaceArtist``. Parameters ---------- keys : list, optional The keys of a specific set of faces of which the normals should be cleared. Default is to clear the normals of all faces. """ if not keys: name = '{}.face.normal.*'.format(self.datastructure.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = self.datastructure.face_name(key) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_edges(self, keys=None): """Clear all edges previously drawn by the ``EdgeArtist``. Parameters ---------- keys : list, optional The keys of a specific set of edges that should be cleared. Default is to clear all edges. """ if not keys: name = '{}.edge.*'.format(self.datastructure.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for u, v in keys: name = self.datastructure.edge_name(u, v) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_vertexlabels(self, keys=None): """Clear all vertex labels previously drawn by the ``VertexArtist``. Parameters ---------- keys : list, optional The keys of a specific set of vertex labels that should be cleared. Default is to clear all vertex labels. """ if not keys: name = '{}.vertex.label.*'.format(self.datastructure.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = self.datastructure.vertex_label_name(key) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def clear_normals(self, keys=None): """Clear all normals previously drawn by the ``MeshArtist``. Parameters ---------- keys : list, optional The keys of a specific set of normals that should be cleared. Default is to clear all normals. """ if not keys: name = '{}.normal.*'.format(self.mesh.name) guids = compas_rhino.get_objects(name=name) else: guids = [] for key in keys: name = '{}.normal.{}'.format(self.mesh.name, key) guid = compas_rhino.get_object(name=name) guids.append(guid) compas_rhino.delete_objects(guids)
def display_network_residual_forces(network, display=True, layer=None, clear_layer=False, scale=1.0, color=(0, 255, 255), attr_name='is_anchor'): tol = compas_rhino.get_tolerance() guids = compas_rhino.get_objects(name='{0}.force:residual.*'.format(network.attributes['name'])) compas_rhino.delete_objects(guids) if not display: return lines = [] for key, attr in network.vertices(True): if attr[attr_name]: continue force = attr['rx'], attr['ry'], attr['rz'] start = network.vertex_coordinates(key) end = [start[i] + scale * force[i] for i in range(3)] length = distance_point_point(start, end) arrow = 'end' name = '{0}.force:residual.{1}'.format(network.attributes['name'], key) if length < tol: continue lines.append({ 'start' : start, 'end' : end, 'name' : name, 'color' : color, 'arrow' : arrow, }) compas_rhino.xdraw_lines(lines, layer=layer, clear=clear_layer)
def draw_reactions(self, scale=1.0, color=None): compas_rhino.delete_objects( compas_rhino.get_objects( name="{}.reaction.*".format(self.mesh.name))) color = color or (0, 255, 0) lines = [] for key, attr in self.mesh.vertices(True): if not attr['is_anchor']: continue r = [attr['rx'], attr['ry'], attr['rz']] sp = [attr['x'], attr['y'], attr['z']] ep = add_vectors(sp, scale_vector(r, -scale)) lines.append({ 'start': sp, 'end': ep, 'color': color, 'name': "{}.reaction.{}".format(self.mesh.name, key), 'arrow': 'end' }) compas_rhino.xdraw_lines(lines, layer=self.layer, redraw=True)