def RunCommand(is_interactive): config = { "name": "Cloud", "message": "start cloud in ?", "options": [ { "name": "background", "message": "background", "action": None }, { "name": "console", "message": "console", "action": None } ] } menu = CommandMenu(config) action = menu.select_action() if action['name'] == 'background': background = True if action['name'] == 'console': background = False p = get_proxy() p.background = background p.restart()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return pattern = scene.get("pattern")[0] if not pattern: print("There is no Pattern in the scene.") return options = ["Finer", "Coarser"] while True: option = compas_rhino.rs.GetString("Select mode", strings=options) if not option: break if option == "Finer": raise NotImplementedError elif option == "Coarser": raise NotImplementedError else: raise NotImplementedError
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return form = scene.get("form")[0] if not form: print("There is no FormDiagram in the scene.") return thrust = scene.get("thrust")[0] anchors = list(form.datastructure.vertices_where({'is_anchor': True})) fixed = list(form.datastructure.vertices_where({'is_fixed': True})) fixed = anchors + fixed options = ['True', 'False'] option = compas_rhino.rs.GetString( "Press Enter to smooth or ESC to exit. Keep all boundaries fixed?", options[0], options) if option is None: print('Form smoothing aborted!') return if option == 'True': fixed += list(flatten(form.datastructure.vertices_on_boundaries())) fixed += list( flatten([ form.datastructure.face_vertices(face) for face in form.datastructure.faces_where({'_is_loaded': False}) ])) fixed = list(set(fixed)) form.datastructure.smooth_area(fixed=fixed) if thrust: thrust.settings['_is.valid'] = False scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return pattern = scene.get("pattern")[0] if not pattern: print("There is no Pattern in the scene.") return keys = pattern.select_vertices() for key in keys: if pattern.datastructure.has_vertex(key): pattern.datastructure.delete_vertex(key) scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return pattern = scene.get("pattern")[0] if not pattern: print("There is no Pattern in the scene.") return fixed = list(pattern.datastructure.vertices_where({'is_fixed': True})) if not fixed: print( "Pattern has no fixed vertices! Relaxation requires fixed vertices." ) return relax = proxy.function("compas.numerical.fd_numpy") key_index = pattern.datastructure.key_index() xyz = pattern.datastructure.vertices_attributes('xyz') loads = [[0.0, 0.0, 0.0] for _ in xyz] fixed[:] = [key_index[key] for key in fixed] edges = [(key_index[u], key_index[v]) for u, v in pattern.datastructure.edges()] q = pattern.datastructure.edges_attribute('q') xyz, q, f, l, r = relax(xyz, edges, fixed, q, loads) for key in pattern.datastructure.vertices(): index = key_index[key] pattern.datastructure.vertex_attributes(key, 'xyz', xyz[index]) scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return form = scene.get("form")[0] if not form: print("There is no FormDiagram in the scene.") return thrust = scene.get("thrust")[0] anchors = list(form.datastructure.vertices_where({'is_anchor': True})) fixed = list(form.datastructure.vertices_where({'is_fixed': True})) fixed = list(set(anchors + fixed)) relax = proxy.function("compas.numerical.fd_numpy") key_index = form.datastructure.key_index() xyz = form.datastructure.vertices_attributes('xyz') loads = [[0.0, 0.0, 0.0] for _ in xyz] fixed[:] = [key_index[key] for key in fixed] edges = [(key_index[u], key_index[v]) for u, v in form.datastructure.edges()] q = form.datastructure.edges_attribute('q') xyz, q, f, l, r = relax(xyz, edges, fixed, q, loads) for key in form.datastructure.vertices(): index = key_index[key] form.datastructure.vertex_attributes(key, 'xyz', xyz[index]) if thrust: thrust.settings['_is.valid'] = False scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return pattern = scene.get("pattern")[0] if not pattern: print("There is no Pattern in the scene.") return fixed = list(pattern.datastructure.vertices_where({'is_fixed': True})) if not fixed: print( "Pattern has no fixed vertices! Smoothing requires fixed vertices." ) return options = ['True', 'False'] option = compas_rhino.rs.GetString( "Press Enter to smooth or ESC to exit. Keep all boundaries fixed?", options[0], options) if option is None: print('Pattern smoothing aborted!') return if option == 'True': fixed = fixed + list( flatten(pattern.datastructure.vertices_on_boundaries())) pattern.datastructure.smooth_area(fixed=fixed) scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return delaunay = proxy.function('compas.geometry.delaunay_from_points_numpy') # Get input data. surf_guid = compas_rhino.select_surface("Select a surface to decompose.") if not surf_guid: return point_guids = compas_rhino.select_points( "Select points to include in the decomposition.") curve_guids = [] compas_rhino.rs.HideObjects([surf_guid] + point_guids + curve_guids) surface = RhinoSurface.from_guid(surf_guid) curves = [RhinoCurve.from_guid(guid) for guid in curve_guids] points = [RhinoPoint.from_guid(guid) for guid in point_guids] # Compute the feature discretisation length. box = compas_rhino.rs.BoundingBox([surf_guid]) diagonal = compas_rhino.rs.Distance(box[0], box[6]) D = 0.05 * diagonal # Get the target length for the final quad mesh. L = compas_rhino.rs.GetReal( "Define the target edge length of the pattern.", 1.0) # Generate the pattern pattern = Pattern.from_surface_and_features(D, L, surf_guid, curve_guids, point_guids, delaunay=delaunay) scene.clear() scene.add(pattern, name='pattern') scene.update() kmax = 10 # Constrain mesh components to the feature geometry. constraints = automated_smoothing_surface_constraints(pattern, surface) constraints.update( automated_smoothing_constraints(pattern, rhinopoints=points, rhinocurves=curves)) while True: option = compas_rhino.rs.GetString("Smoothen the pattern?", "No", ["Yes", "No"]) if not option: break if option != "Yes": break constrained_smoothing(pattern, kmax=kmax, damping=0.5, constraints=constraints, algorithm="area") scene.update() print('Pattern object successfully created. Input object has been hidden.')
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return vertical = proxy.function('compas_tna.equilibrium.vertical_from_zmax_proxy') form = scene.get('form')[0] force = scene.get('force')[0] thrust = scene.get('thrust')[0] if not form: print("There is no FormDiagram in the scene.") return if not force: print("There is no ForceDiagram in the scene.") return if not thrust: print("There is no ThrustDiagram in the scene.") return bbox = form.datastructure.bounding_box_xy() diagonal = length_vector(subtract_vectors(bbox[2], bbox[0])) zmax = scene.settings['Solvers']['tna.vertical.zmax'] kmax = scene.settings['Solvers']['tna.vertical.kmax'] options = ['TargetHeight'] while True: option = compas_rhino.rs.GetString('Press Enter to run or ESC to exit.', strings=options) if option is None: print("Vetical equilibrium aborted!") return if not option: break if option == 'TargetHeight': new_zmax = compas_rhino.rs.GetReal('Enter target height of the ThrustDiagram', zmax, 0.0, 1.0 * diagonal) if new_zmax or new_zmax is not None: zmax = new_zmax scene.settings['Solvers']['tna.vertical.zmax'] = zmax result = vertical(form.datastructure.data, zmax, kmax=kmax) if not result: print("Vertical equilibrium failed!") return formdata, scale = result force.datastructure.attributes['scale'] = scale form.datastructure.data = formdata thrust.datastructure.data = formdata form.datastructure.dual = force.datastructure force.datastructure.primal = form.datastructure thrust.datastructure.dual = force.datastructure thrust.settings['_is.valid'] = True scene.update() print('Vertical equilibrium found!') print('ThrustDiagram object successfully created with target height of {}.'.format(zmax))
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return relax = proxy.function("compas.numerical.fd_numpy") pattern = scene.get("pattern")[0] if not pattern: return # split the exterior boundary openings = split_boundary(pattern.datastructure) # make a label drawing function draw_labels = partial(_draw_labels, pattern, openings) # draw a label per opening guids = draw_labels() # convert the list of vertices to a list of segments openings = [list(pairwise(opening)) for opening in openings] # compute current opening sags targets = [] for opening in openings: sag = compute_sag(pattern.datastructure, opening) if sag < 0.05: sag = 0.05 targets.append(sag) # compute current opening Qs Q = [] for opening in openings: q = pattern.datastructure.edges_attribute('q', keys=opening) q = sum(q) / len(q) Q.append(q) pattern.datastructure.edges_attribute('q', q, keys=opening) # relax the pattern relax_pattern(pattern.datastructure, relax) # update Qs to match target sag count = 0 while True and count < 10: count += 1 sags = [ compute_sag(pattern.datastructure, opening) for opening in openings ] if all((sag - target)**2 < TOL2 for sag, target in zip(sags, targets)): break for i in range(len(openings)): sag = sags[i] target = targets[i] q = Q[i] q = sag / target * q Q[i] = q opening = openings[i] pattern.datastructure.edges_attribute('q', Q[i], keys=opening) relax_pattern(pattern.datastructure, relax) if count == 10: print("did not converge after 10 iterations") else: print("converged after %s iterations" % count) compas_rhino.delete_objects(guids, purge=True) scene.update() guids = draw_labels() # allow user to select label # and specify a target sag options1 = ['All'] + [ "Boundary{}".format(i) for i, opening in enumerate(openings) ] options2 = ["Sag_{}".format(i * 5) for i in range(1, 11)] while True: option1 = compas_rhino.rs.GetString("Select boundary:", strings=options1) if not option1: break if option1 == 'All': N = [i for i, opening in enumerate(openings)] else: N = [int(option1[8:])] while True: option2 = compas_rhino.rs.GetString("Select sag/span percentage:", strings=options2) if not option2: break for boundary in N: targets[boundary] = float(option2[4:]) / 100 count = 0 while True and count < 10: count += 1 sags = [ compute_sag(pattern.datastructure, opening) for opening in openings ] if all((sag - target)**2 < TOL2 for sag, target in zip(sags, targets)): break for i in range(len(openings)): sag = sags[i] target = targets[i] q = Q[i] q = sag / target * q Q[i] = q opening = openings[i] pattern.datastructure.edges_attribute('q', Q[i], keys=opening) relax_pattern(pattern.datastructure, relax) if count == 10: print("did not converge after 10 iterations") else: print("converged after %s iterations" % count) compas_rhino.delete_objects(guids, purge=True) scene.update() guids = draw_labels() break compas_rhino.delete_objects(guids, purge=True) scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return srf_guid = compas_rhino.select_surface("Select a surface.") if not srf_guid: return crv_guids = [] pt_guids = compas_rhino.select_points( "Step 1/3 (Optional) - Select points for pole singularities.") or [] box = compas_rhino.rs.BoundingBox([srf_guid]) input_subdivision_spacing = 0.01 * compas_rhino.rs.Distance(box[0], box[6]) mesh_edge_length = compas_rhino.rs.GetReal( "Step 2/3 - Enter target length for edges.", 1.0) delaunay = proxy.function( "compas.geometry.triangulation.triangulation_numpy.delaunay_from_points_numpy" ) pattern = Pattern.from_surface_and_features(input_subdivision_spacing, mesh_edge_length, srf_guid, crv_guids, pt_guids, delaunay) scene.clear() scene.add(pattern, name='pattern') scene.update() kmax = 10 while True: option = compas_rhino.rs.GetString( "Step 3/3 (Optional) - Press Enter to run constrained Laplacian smoothing or ESC to skip.", strings=['Iterations']) if option is None: break if not option: constraints = automated_smoothing_surface_constraints( pattern, srf_guid) constraints.update( automated_smoothing_constraints(pattern, points=pt_guids, curves=crv_guids)) constrained_smoothing(pattern, kmax=kmax, damping=0.5, constraints=constraints, algorithm='area') objs = set(constraints.values()) inputs = [srf_guid] + crv_guids + pt_guids for obj in objs: if obj not in inputs: compas_rhino.rs.DeleteObject(obj) compas_rhino.rs.HideObjects(inputs) break if option == 'Iterations': new_kmax = compas_rhino.rs.GetInteger("Number of iterations:", kmax) if new_kmax or new_kmax is not None: kmax = new_kmax scene.update() print('Pattern object successfully created. Input object has been hidden.')
def RunCommand(is_interactive): scene = get_scene() if not scene: return proxy = get_proxy() if not proxy: return conforming_delaunay_triangulation = proxy.function( 'compas.geometry.conforming_delaunay_triangulation') boundary_guids = compas_rhino.select_curves('Select outer boundary.') if not boundary_guids: return hole_guids = compas_rhino.select_curves('Select inner boundaries.') segments_guids = compas_rhino.select_curves('Select constraint curves.') target_length = rs.GetReal('Specifiy target edge length.', 1.0) if not target_length: return gkey_constraints = {} # outer boundary boundary = [] for guid in boundary_guids: compas_rhino.rs.EnableRedraw(False) segments = compas_rhino.rs.ExplodeCurves(guid) for segment in segments: curve = RhinoCurve.from_guid(segment) N = max(int(curve.length() / target_length), 1) points = map(list, curve.divide(N, over_space=True)) for point in points: gkey = geometric_key(point) if gkey not in gkey_constraints: gkey_constraints[gkey] = [] gkey_constraints[gkey].append(segment) boundary.extend(points) compas_rhino.delete_objects(segments, purge=True) compas_rhino.rs.EnableRedraw(True) # constraint polylines polylines = [] if segments_guids: for guid in segments_guids: curve = RhinoCurve.from_guid(guid) N = int(curve.length() / target_length) or 1 points = map(list, curve.divide(N, over_space=True)) for point in points: gkey = geometric_key(point) if gkey not in gkey_constraints: gkey_constraints[gkey] = [] gkey_constraints[gkey].append(guid) polylines.append(points) # hole polygons polygons = [] if hole_guids: for guid in hole_guids: curve = RhinoCurve.from_guid(guid) N = int(curve.length() / target_length) or 1 points = map(list, curve.divide(N, over_space=True)) for point in points[:-1]: gkey = geometric_key(point) if gkey not in gkey_constraints: gkey_constraints[gkey] = [] gkey_constraints[gkey].append(guid) polygons.append(points) area = target_length**2 * 0.5 * 0.5 * 1.732 vertices, faces = conforming_delaunay_triangulation(boundary, polylines=polylines, polygons=polygons, angle=30, area=area) # vertices, faces = constrained_delaunay_triangulation(boundary, polylines=polylines, polygons=polygons) vertices[:] = [[float(x), float(y), float(z)] for x, y, z in vertices] pattern = Pattern.from_vertices_and_faces(vertices, faces) gkey_key = { geometric_key(pattern.vertex_coordinates(key)): key for key in pattern.vertices() } for gkey in gkey_constraints: guids = gkey_constraints[gkey] if gkey in gkey_key: key = gkey_key[gkey] if len(guids) > 1: pattern.vertex_attribute(key, 'is_fixed', True) pattern.vertex_attribute(key, 'constraints', [str(guid) for guid in guids]) compas_rhino.rs.HideObject(boundary_guids + hole_guids + segments_guids) scene.clear() scene.add(pattern, name='pattern') scene.update() print( "Pattern object successfully created. Input geometry have been hidden." )
def check(): p = get_proxy() print(p.check())
def shutdown(): p = get_proxy() p.shutdown()
def RunCommand(is_interactive): p = get_proxy() print(p.check())