def discretise_mesh(mesh, layer, target, min_angle=15, factor=1): """ Discretise a mesh from an input triangulated coarse mesh into small denser meshes. Parameters ---------- mesh : guid The guid of the Rhino input mesh. layer : str Layer name to draw results. target : float Target length of each triangle. min_angle : float Minimum internal angle of triangles. factor : float Factor on the maximum area of each triangle. Returns ------- None """ rhinomesh = RhinoMesh(mesh) vertices = rhinomesh.get_vertex_coordinates() faces = [face[:3] for face in rhinomesh.get_face_vertices()] try: points, tris = meshing.discretise_faces(vertices=vertices, faces=faces, target=target, min_angle=min_angle, factor=factor) rs.CurrentLayer(rs.AddLayer(layer)) rs.DeleteObjects(rs.ObjectsByLayer(layer)) rs.EnableRedraw(False) for pts, tri in zip(points, tris): mesh_faces = [] for i in tri: face_ = i + [i[-1]] mesh_faces.append(face_) rs.AddMesh(pts, mesh_faces) rs.EnableRedraw(True) except: print('***** Error using MeshPy (Triangle) or drawing faces *****')
def _get_building_member_info(self, gripping_config): start = timer() if self.debug else None self.simulator.set_robot_config(self.robot, gripping_config) mesh = RhinoMesh.from_guid(self.building_member).to_compas() handle = self.simulator.add_attached_collision_mesh( mesh, options={'robot_name': self.robot.name}) matrix = self.simulator.get_object_matrices([handle])[handle] parent_handle = self.simulator.get_object_handle('customGripper' + self.robot.name) _, _, mesh_matrix, _, _ = self.simulator.run_child_script( 'getShapeMatrixRelative', [handle, parent_handle], [], []) relative_transform = _to_xform(mesh_matrix) transform = _to_xform(matrix) mesh_at_origin = _transform_to_origin( rs.coercemesh(self.building_member), transform) if self.debug: LOG.debug('Execution time: building member=%.2f', timer() - start) return { 'mesh': mesh_at_origin, 'parent_handle': parent_handle, 'relative_transform': relative_transform }
def from_rhinomesh(cls, guid, **kwargs): """Construct a FormDiagram from a Rhino mesh represented by a guid. Parameters ---------- guid : str A globally unique identifier. Returns ------- FormDiagram A FormDiagram object. Examples -------- .. code-block:: python import compas_rhino from compas_tna.diagrams import FormDiagram guid = compas_rhino.select_mesh() form = FormDiagram.from_rhinomesh(guid) """ from compas_rhino.geometry import RhinoMesh mesh = RhinoMesh.from_guid(guid).to_compas(cls) if 'name' in kwargs: mesh.name = kwargs['name'] return mesh
def RunScript(self, scene, M, name, add, remove): ok = False if scene and M and name: mesh = RhinoMesh.from_geometry(M).to_compas() collision_mesh = CollisionMesh(mesh, name) if add: scene.add_collision_mesh(collision_mesh) ok = True if remove: scene.remove_collision_mesh(name) ok = True return ok
def RunScript(self, scene, mesh, identifier, link_name, touch_links, add, remove): attached_collision_mesh = None if scene and mesh and identifier and link_name: compas_mesh = RhinoMesh.from_geometry(mesh).to_compas() collision_mesh = CollisionMesh(compas_mesh, identifier) attached_collision_mesh = AttachedCollisionMesh(collision_mesh, link_name, touch_links) if add: scene.add_attached_collision_mesh(attached_collision_mesh) if remove: scene.remove_attached_collision_mesh(identifier) scene.remove_collision_mesh(identifier) return attached_collision_mesh
def gh_from_rhino_mesh(mesh_guid, pole_guids): rhino_mesh = RhinoMesh.from_guid(mesh_guid) vertices, faces = rhino_mesh.vertices, rhino_mesh.faces face_no_dup = [] for face in faces: fv = [] for vertex in face: if vertex not in fv: fv.append(vertex) face_no_dup.append(fv) poles = [rs.PointCoordinates(point) for point in pole_guids] # warning if ambiguous selection of poles return CoarsePseudoQuadMesh.from_vertices_and_faces_with_poles(vertices, face_no_dup, poles)
def from_rhinomesh(cls, guid, frame): """Class method for constructing a block from a Rhino mesh. Parameters ---------- guid : str The GUID of the mesh. frame : :class:`Frame` Origin frame of the element. """ from compas_rhino.geometry import RhinoMesh element = cls(frame) element._source = RhinoMesh.from_guid(guid) element._mesh = element._source.mesh.to_compas() return element
def get_dense_mesh(): guid = rs.GetObject('get dense mesh', filter=32) vertices, faces = RhinoMesh.from_guid(guid).get_vertices_and_faces() clean_faces(faces) poles = [] for face in faces: if len(face) != 4: poles = [ rs.PointCoordinates(point) for point in rs.GetObjects('get pole points', filter=1) ] break singularity_mesh = CoarsePseudoQuadMesh.from_quad_mesh( PseudoQuadMesh.from_vertices_and_faces_with_poles( vertices, faces, poles)) return singularity_mesh
def from_rhinomesh(cls, guid): """Class method for constructing a block from a Rhino mesh. Parameters ---------- guid : str The GUID of the mesh. Returns ------- Block The block corresponding to the Rhino mesh. """ from compas_rhino.geometry import RhinoMesh mesh = RhinoMesh.from_guid(guid) return mesh.to_compas(cls)
def from_rhinomesh(cls, guid): """Make a cable net from a Rhino mesh. Parameters ---------- guid : str The GUID of the Rhino mesh. Returns ------- :class:`Cablenet` An instance of a cable net. """ from compas_rhino.geometry import RhinoMesh return RhinoMesh.from_guid(guid).to_compas(cls=cls)
def RunCommand(is_interactive): scene = get_scene() if not scene: return guid = compas_rhino.select_mesh() if not guid: return pattern = RhinoMesh.from_guid(guid).to_compas(cls=Pattern) compas_rhino.rs.HideObject(guid) scene.clear() scene.add(pattern, name='pattern') scene.update() print("Pattern object successfully created. Input mesh has been hidden.")
def from_guid(guid): """Create a ``RhinoGeometry`` instance of the correct type based on a given guid. Parameters ---------- guid : str or System.Guid The *guid* of the Rhino object. Returns ------- RhinoPoint If the type of the Rhino object is ``rs.filter.point``. RhinoCurve If the type of the Rhino object is ``rs.filter.curve``. RhinoMesh If the type of the Rhino object is ``rs.filter.mesh``. RhinoSurface If the type of the Rhino object is ``rs.filter.surface``. Examples -------- >>> """ from compas_rhino.geometry import RhinoPoint from compas_rhino.geometry import RhinoCurve from compas_rhino.geometry import RhinoMesh from compas_rhino.geometry import RhinoSurface otype = rs.ObjectType(guid) if otype == rs.filter.point: return RhinoPoint(guid) if otype == rs.filter.curve: return RhinoCurve(guid) if otype == rs.filter.mesh: return RhinoMesh(guid) if otype == rs.filter.surface: return RhinoSurface(guid)
def callback(k, args): mesh, constraints = args for vkey, constraint in constraints.items(): if rs.ObjectType(constraint) == 1: x, y, z = RhinoPoint.from_guid(constraint).xyz elif rs.ObjectType(constraint) == 4: x, y, z = RhinoCurve.from_guid(constraint).closest_point( mesh.vertex_coordinates(vkey)) elif rs.ObjectType(constraint) == 8: x, y, z = RhinoSurface.from_guid(constraint).closest_point( mesh.vertex_coordinates(vkey)) elif rs.ObjectType(constraint) == 32: x, y, z = RhinoMesh.from_guid(constraint).closest_point( mesh.vertex_coordinates(vkey)) else: continue mesh.vertex[vkey]['x'] = x mesh.vertex[vkey]['y'] = y mesh.vertex[vkey]['z'] = z
import rhinoscriptsyntax as rs from compas_rhino.geometry import RhinoMesh from compas_pattern.datastructures.mesh_quad_pseudo.mesh_quad_pseudo import PseudoQuadMesh from compas_pattern.cad.rhino.draw import draw_graph guids = rs.GetObjects('get quad meshes', filter=32) poles = rs.GetObjects('get pole points', filter=1) if poles is None: poles = [] else: poles = [rs.PointCoordinates(pole) for pole in poles] rs.EnableRedraw(False) for guid in guids: vertices, faces = RhinoMesh.from_guid(guid).get_vertices_and_faces() mesh = PseudoQuadMesh.from_vertices_and_faces_with_poles( vertices, faces, poles) #mesh = QuadMesh.from_vertices_and_faces(*RhinoMesh.from_guid(guid).get_vertices_and_faces()) #print('euler', mesh.euler()) #print('nb_boundaries', len(mesh.boundaries())) #mesh.collect_strips() #mesh.collect_polyedges() #polylines = [rs.AddPolyline(mesh.strip_edge_midpoint_polyline(skey)) for skey in mesh.strips()] #for i, polyline in enumerate(polylines): # #polylines = [rs.AddPolyline(polyline) for polyline in mesh.singularity_polylines()] #polylines = [rs.AddPolyline(polyline) for polyline in mesh.polylines()] #for polyline in polylines: # rs.CurveArrows(polyline, 3) #for i, vkey in enumerate(mesh.vertices()): # rs.AddCircle(mesh.vertex_coordinates(vkey), 2) # rs.AddText(str(i), mesh.vertex_coordinates(vkey), 2)
from compas.utilities import XFunc from math import sin from math import cos import rhinoscriptsyntax as rs __author__ = ['Andrew Liew <*****@*****.**>'] __copyright__ = 'Copyright 2017, BLOCK Research Group - ETH Zurich' __license__ = 'MIT License' __email__ = '*****@*****.**' # Input guid = rs.ObjectsByLayer('Plane')[0] rhinomesh = RhinoMesh(guid) vertices, faces = rhinomesh.get_vertices_and_faces() points = [[x, y, sin(x) * cos(y)] for x, y, z in vertices] # Set-up XFunc basedir = 'D:/compas-dev/examples/' tmpdir = 'C:/Temp/' xfunc = XFunc(basedir=basedir, tmpdir=tmpdir) # Python xfunc.funcname = 'hpc_normals_func.python_normals' normals, toc1 = xfunc(points, offset=0.5)['data'] print('Python : {0:.6f} ms'.format(toc1 * 1000))
def add_tets_from_mesh(structure, name, mesh, draw_tets=False, volume=None, layer='Default', acoustic=False, thermal=False): """ Adds tetrahedron elements from a Rhino mesh to the Structure object. Parameters ---------- structure : obj Structure object to update. name : str Name for the element set of tetrahedrons. mesh : obj The Rhino mesh representing the outer surface. draw_tets : bool Draw the generated tetrahedrons. volume : float Maximum volume for each tet. layer : str Layer to draw tetrahedrons if draw_tets=True. acoustic : bool Acoustic properties on or off. thermal : bool Thermal properties on or off. Returns ------- None Nodes and elements are updated in the Structure object. """ rhinomesh = RhinoMesh(mesh) vertices = rhinomesh.get_vertex_coordinates() faces = [face[:3] for face in rhinomesh.get_face_vertices()] basedir = utilities.__file__.split('__init__.py')[0] xfunc = XFunc('tets', basedir=basedir, tmpdir=structure.path) xfunc.funcname = 'functions.tets_from_vertices_faces' try: tets_points, tets_elements = xfunc(vertices=vertices, faces=faces, volume=volume) for point in tets_points: structure.add_node(point) ekeys = [] for element in tets_elements: nodes = [ structure.check_node_exists(tets_points[i]) for i in element ] ekey = structure.add_element(nodes=nodes, type='TetrahedronElement', acoustic=acoustic, thermal=thermal) ekeys.append(ekey) structure.add_set(name=name, type='element', selection=ekeys) if draw_tets: rs.EnableRedraw(False) rs.DeleteObjects(rs.ObjectsByLayer(layer)) rs.CurrentLayer(layer) tet_faces = [[0, 2, 1, 1], [1, 2, 3, 3], [1, 3, 0, 0], [0, 3, 2, 2]] for i, points in enumerate(tets_elements): xyz = [tets_points[j] for j in points] rs.AddMesh(vertices=xyz, face_vertices=tet_faces) rs.EnableRedraw(True) except: print('***** Error using MeshPy or drawing Tets *****')
def mesh_extrude(structure, guid, layers, thickness, mesh_name='', links_name='', blocks_name='', points_name='', plot_mesh=False, plot_links=False, plot_blocks=False, plot_points=False): """ Extrudes a Rhino mesh and adds/creates elements. Parameters ---------- structure : obj Structure object to update. guid : guid Rhino mesh guid. layers : int Number of layers. thickness : float Layer thickness. mesh_name : str Name of set for mesh on final surface. links_name : str Name of set for adding links along extrusion. blocks_name : str Name of set for solid elements. points_name : str Name of aded points. plot_mesh : bool Plot outer mesh. plot_links : bool Plot links. plot_blocks : bool Plot blocks. plot_points : bool Plot end points. Returns ------- None Notes ----- - Extrusion is along the mesh vertex normals. """ mesh = RhinoMesh.from_guid(guid).to_compas(cls=Mesh) extrude_mesh(structure=structure, mesh=mesh, layers=layers, thickness=thickness, mesh_name=mesh_name, links_name=links_name, blocks_name=blocks_name) block_faces = [[0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4], [1, 2, 6, 5], [2, 3, 7, 6], [3, 0, 4, 7]] xyz = structure.nodes_xyz() rs.EnableRedraw(False) if plot_blocks: rs.CurrentLayer(rs.AddLayer(blocks_name)) rs.DeleteObjects(rs.ObjectsByLayer(blocks_name)) for i in structure.sets[blocks_name]['selection']: nodes = structure.elements[i].nodes xyz = structure.nodes_xyz(nodes) rs.AddMesh(xyz, block_faces) if plot_mesh: rs.CurrentLayer(rs.AddLayer(mesh_name)) rs.DeleteObjects(rs.ObjectsByLayer(mesh_name)) faces = [] for i in structure.sets[mesh_name]['selection']: enodes = structure.elements[i].nodes if len(enodes) == 3: enodes.append(enodes[-1]) faces.append(enodes) rs.AddMesh(xyz, faces) if plot_links: rs.CurrentLayer(rs.AddLayer(links_name)) rs.DeleteObjects(rs.ObjectsByLayer(links_name)) if plot_points: rs.CurrentLayer(rs.AddLayer(points_name)) rs.DeleteObjects(rs.ObjectsByLayer(points_name)) for i in structure.sets[links_name]['selection']: nodes = structure.elements[i].nodes xyz = structure.nodes_xyz(nodes) rs.CurrentLayer(links_name) rs.AddLine(xyz[0], xyz[1]) if plot_points: rs.CurrentLayer(points_name) rs.AddPoint(xyz[1]) rs.EnableRedraw(True) rs.CurrentLayer(rs.AddLayer('Default'))
import rhinoscriptsyntax as rs from compas_rhino.geometry import RhinoMesh from compas_pattern.datastructures.mesh_quad.mesh_quad import QuadMesh guids = rs.GetObjects('get quad meshes', filter = 32) rs.EnableRedraw(False) for guid in guids: mesh = QuadMesh.from_vertices_and_faces(*RhinoMesh.from_guid(guid).get_vertices_and_faces()) mesh.collect_strips() polylines = [rs.AddPolyline(mesh.strip_edge_polyline(skey)) for skey in mesh.strips()] for polyline in polylines: rs.CurveArrows(polyline, 3)
def add_tets_from_mesh(structure, name, mesh, draw_tets=False, volume=None, thermal=False): """ Adds tetrahedron elements from a mesh in Rhino to the Structure object. Parameters ---------- structure : obj Structure object to update. name : str Name for the element set of tetrahedrons. mesh : guid The mesh in Rhino representing the outer surface. draw_tets : str Layer to draw tetrahedrons on. volume : float Maximum volume for each tet. thermal : bool Thermal properties on or off. Returns ------- None """ rhinomesh = RhinoMesh(mesh) vertices = rhinomesh.get_vertex_coordinates() faces = [face[:3] for face in rhinomesh.get_face_vertices()] try: tets_points, tets_elements = meshing.tets_from_vertices_faces( vertices=vertices, faces=faces, volume=volume) for point in tets_points: structure.add_node(point) ekeys = [] for element in tets_elements: nodes = [ structure.check_node_exists(tets_points[i]) for i in element ] ekey = structure.add_element(nodes=nodes, type='TetrahedronElement', thermal=thermal) ekeys.append(ekey) structure.add_set(name=name, type='element', selection=ekeys) if draw_tets: rs.EnableRedraw(False) rs.DeleteObjects(rs.ObjectsByLayer(draw_tets)) rs.CurrentLayer(draw_tets) tet_faces = [[0, 2, 1, 1], [1, 2, 3, 3], [1, 3, 0, 0], [0, 3, 2, 2]] for i, points in enumerate(tets_elements): xyz = [tets_points[j] for j in points] rs.AddMesh(vertices=xyz, face_vertices=tet_faces) rs.EnableRedraw(True) print('***** MeshPy (TetGen) successfull *****') except: print('***** Error using MeshPy (TetGen) or drawing Tets *****')
import rhinoscriptsyntax as rs from compas_rhino.geometry import RhinoMesh from compas_pattern.datastructures.mesh_quad_pseudo_coarse.mesh_quad_pseudo_coarse import CoarsePseudoQuadMesh #from compas_pattern.cad.rhino.artist import select_quad_mesh_strip from compas_rhino.artists import MeshArtist guid = rs.GetObject('get (coarse) quad mesh', filter=32) poles = rs.GetObjects('get pole points', filter=1) if poles is None: poles = [] else: poles = [rs.PointCoordinates(pole) for pole in poles] mesh = RhinoMesh.from_guid(guid) vertices, faces = mesh.vertices, mesh.faces mesh = CoarsePseudoQuadMesh.from_vertices_and_faces_with_poles( vertices, faces, poles) print(mesh.boundaries()) #mesh.collect_strips() #mesh.set_strips_density(1) #mesh.densification() # # #count = 100 #while count: # count -= 1 # # artist = MeshArtist(mesh.get_quad_mesh()) # guid = artist.draw_mesh()
def add_nodes_elements_from_layers(structure, layers, line_type=None, mesh_type=None, thermal=False, pA=None, pL=None): """ Adds node and element data from Rhino layers to the Structure object. Parameters ---------- structure : obj Structure object to update. layers : list Layer string names to extract nodes and elements. line_type : str Element type for line objects. mesh_type : str Element type for mesh objects. thermal : bool Thermal properties on or off. pA : float Mass area density [kg/m2]. pL : float Mass length density [kg/m]. Returns ------- list Node keys that were added to the Structure. list Element keys that were added to the Structure. """ if isinstance(layers, str): layers = [layers] added_nodes = set() added_elements = set() for layer in layers: elset = set() for guid in rs.ObjectsByLayer(layer): if line_type and rs.IsCurve(guid): sp_xyz = rs.CurveStartPoint(guid) ep_xyz = rs.CurveEndPoint(guid) ez = subtract_vectors(ep_xyz, sp_xyz) L = length_vector(ez) m = 0.5 * L * pL if pL else None sp = structure.add_node(xyz=sp_xyz, mass=m) ep = structure.add_node(xyz=ep_xyz, mass=m) added_nodes.add(sp) added_nodes.add(ep) try: name = rs.ObjectName(guid).replace("'", '"') if name[0] in ['_', '^']: name = name[1:] dic = json.loads(name) ex = dic.get('ex', None) ey = dic.get('ey', None) if ex and not ey: ey = cross_vectors(ex, ez) except: ex = None ey = None axes = {'ex': ex, 'ey': ey, 'ez': ez} ekey = structure.add_element(nodes=[sp, ep], type=line_type, thermal=thermal, axes=axes) if (line_type == 'BeamElement') and (ex is None): if (ez[0] == 0) and (ez[1] == 0): print('***** WARNING: vertical BeamElement with no ex axis, element {0} *****'.format(ekey)) if ekey is not None: added_elements.add(ekey) elset.add(ekey) elif mesh_type and rs.IsMesh(guid): mesh = RhinoMesh.from_guid(guid).to_compas() vertices = rs.MeshVertices(guid) nodes = [] masses = [] for c, vertex in enumerate(vertices): m = mesh.vertex_area(c) * pA if pA else None masses.append(m) nodes.append(structure.add_node(xyz=vertex, mass=m)) added_nodes.update(nodes) if mesh_type in ['HexahedronElement', 'TetrahedronElement', 'SolidElement', 'PentahedronElement']: ekey = structure.add_element(nodes=nodes, type=mesh_type, thermal=thermal) if ekey is not None: added_elements.add(ekey) elset.add(ekey) elif mesh_type=='MassElement': node_iterator=0 for node in nodes: ekey = structure.add_element(nodes=[node], type=mesh_type, thermal=thermal, mass=masses[node_iterator]) #structure.nodes[node].mass node_iterator += 1 if ekey is not None: added_elements.add(ekey) elset.add(ekey) else: try: name = rs.ObjectName(guid).replace("'", '"') if name[0] in ['_', '^']: name = name[1:] dic = json.loads(name) ex = dic.get('ex', None) ey = dic.get('ey', None) ez = dic.get('ez', None) if (ex and ey) and (not ez): ez = cross_vectors(ex, ey) except: ex = None ey = None ez = None axes = {'ex': ex, 'ey': ey, 'ez': ez} for face in rs.MeshFaceVertices(guid): nodes = [structure.check_node_exists(vertices[i]) for i in face] if nodes[-1] == nodes[-2]: del nodes[-1] ekey = structure.add_element(nodes=nodes, type=mesh_type, thermal=thermal, axes=axes) if ekey is not None: added_elements.add(ekey) elset.add(ekey) structure.add_set(name=layer, type='element', selection=list(elset)) return list(added_nodes), list(added_elements)
def singular(): """Explore a pattern, its topology (singularities, densities and symmetries) and its geoemtry (via smoothing). """ layer = rs.CurrentLayer() pattern_from = rs.GetString('start pattern from?', strings=[ 'coarse_pseudo_quad_mesh', 'pseudo_quad_mesh', 'surface_and_features' ]) if pattern_from == 'coarse_pseudo_quad_mesh': guid = rs.GetObject('get coarse quad mesh', filter=32) vertices, faces = RhinoMesh.from_guid(guid).get_vertices_and_faces() clean_faces(faces) poles = [] #print(faces) for face in faces: if len(face) != 4: poles = [ rs.PointCoordinates(point) for point in rs.GetObjects('get pole points', filter=1) ] break coarse_pseudo_quad_mesh = CoarsePseudoQuadMesh.from_vertices_and_faces_with_poles( vertices, faces, poles) coarse_pseudo_quad_mesh.collect_strips() print(coarse_pseudo_quad_mesh.data['attributes']['strips']) coarse_pseudo_quad_mesh.set_strips_density(1) coarse_pseudo_quad_mesh.set_quad_mesh(coarse_pseudo_quad_mesh.copy()) coarse_pseudo_quad_mesh.set_polygonal_mesh( coarse_pseudo_quad_mesh.copy()) print(coarse_pseudo_quad_mesh.data['attributes']['strips']) elif pattern_from == 'pseudo_quad_mesh': guid = rs.GetObject('get quad mesh', filter=32) vertices, faces = RhinoMesh.from_guid(guid).get_vertices_and_faces() clean_faces(faces) poles = [] for face in faces: if len(face) != 4: poles = [ rs.PointCoordinates(point) for point in rs.GetObjects('get pole points', filter=1) ] break coarse_pseudo_quad_mesh = CoarsePseudoQuadMesh.from_quad_mesh( PseudoQuadMesh.from_vertices_and_faces_with_poles( vertices, faces, poles)) elif pattern_from == 'surface_and_features': srf_guid = rs.GetObject('get surface', filter=8) crv_guids = rs.GetObjects('get optional curve features', filter=4) if crv_guids is None: crv_guids = [] pt_guids = rs.GetObjects('get optional point features', filter=1) if pt_guids is None: pt_guids = [] coarse_pseudo_quad_mesh = surface_decomposition( srf_guid, rs.GetReal('precision', number=1.), crv_guids=crv_guids, pt_guids=pt_guids, output_skeleton=False)[0] coarse_pseudo_quad_mesh.collect_strips() coarse_pseudo_quad_mesh.set_strips_density(1) coarse_pseudo_quad_mesh.set_quad_mesh(coarse_pseudo_quad_mesh.copy()) coarse_pseudo_quad_mesh.set_polygonal_mesh( coarse_pseudo_quad_mesh.copy()) artist = rhino_artist.MeshArtist(coarse_pseudo_quad_mesh) guid = artist.draw_mesh() else: return 0 while True: #edit = rs.GetString('edit pattern?', strings = ['topology', 'density', 'symmetry', 'geometry', 'evaluate', 'exit']) edit = rs.GetString('edit pattern?', strings=[ 'topology', 'density', 'symmetry', 'geometry', 'save', 'exit' ]) if type(guid) == list: rs.DeleteObjects(guid) else: rs.DeleteObject(guid) if edit is None or edit == 'exit': rs.EnableRedraw(False) artist = rhino_artist.MeshArtist( coarse_pseudo_quad_mesh.get_polygonal_mesh()) return artist.draw_mesh() if edit == 'topology': editing_topology(coarse_pseudo_quad_mesh) coarse_pseudo_quad_mesh.densification() coarse_pseudo_quad_mesh.set_polygonal_mesh( coarse_pseudo_quad_mesh.get_quad_mesh().copy()) elif edit == 'density': editing_density(coarse_pseudo_quad_mesh) coarse_pseudo_quad_mesh.set_polygonal_mesh( coarse_pseudo_quad_mesh.get_quad_mesh().copy()) elif edit == 'symmetry': editing_symmetry(coarse_pseudo_quad_mesh) elif edit == 'geometry': editing_geometry(coarse_pseudo_quad_mesh) rs.EnableRedraw(False) artist = rhino_artist.MeshArtist( coarse_pseudo_quad_mesh.get_polygonal_mesh()) guid = artist.draw_mesh() rs.EnableRedraw(True) if edit == 'save': save_design(coarse_pseudo_quad_mesh, layer) if edit == 'evaluate': evaluate_pattern(coarse_pseudo_quad_mesh.get_polygonal_mesh())
length = 0.25 kmax = 300 # select the original mesh # select the border # select the fixed points guid_target = compas_rhino.select_mesh() guid_border = compas_rhino.select_polyline() guid_points = compas_rhino.select_points() # wrap the Rhino mesh object for convenience # wrap the Rhino curve object for convenience # get the point coordinates target = RhinoMesh(guid_target) border = RhinoCurve(guid_border) points = compas_rhino.get_point_coordinates(guid_points) # make a mesh datastructure from the Rhino mesh # triangulate the mesh mesh = mesh_from_guid(Mesh, guid_target) mesh_quads_to_triangles(mesh) # identify the fixed vertices # by matching the coordinates of the selected points # up to a precision keys = mesh_identify_vertices(mesh, points, '1f') fixed = set(keys)
def rgmesh_to_cgmesh(mesh, cls=None): return RhinoMesh.from_geometry(mesh).to_compas(cls=cls)