def load_session(session): print("loading session") scene = get_scene() scene.clear() if 'settings' in session: scene.settings = session['settings'] if 'data' in session: data = session['data'] if 'pattern' in data and data['pattern']: pattern = Pattern.from_data(data['pattern']) scene.add(pattern, name="pattern") else: if 'form' in data and data['form']: form = FormDiagram.from_data(data['form']) thrust = form.copy( cls=ThrustDiagram) # this is not a good idea scene.add(form, name="form") scene.add(thrust, name="thrust") if 'force' in data and data['force']: force = ForceDiagram.from_data(data['force']) force.primal = form form.dual = force force.update_angle_deviations() scene.add(force, name="force") scene.update()
def RunCommand(is_interactive): scene = get_scene() if not scene: return # get untrimmed surface(s) ------------------------------------------------- guid = compas_rhino.select_surface( message='select an untrimmed surface or a polysurface') if not guid: return compas_rhino.rs.HideObjects(guid) # make subd object --------------------------------------------------------- subdobject = SubdObject.from_guid(guid) if not subdobject: return compas_rhino.rs.HideObjects(guid) subdobject.draw_coarse() subdobject.get_draw_default_subd() subdobject.draw_subd() # interactively modify subdivision ---------------------------------------- while True: menu = CommandMenu(config) action = menu.select_action() if not action or action is None: subdobject.clear() print("Pattern from surface(s) aborted!") compas_rhino.rs.ShowObjects(guid) return if action['name'] == 'Finish': break action['action'](subdobject) # make pattern ------------------------------------------------------------- mesh = subdobject.subd xyz = mesh.vertices_attributes('xyz') faces = [mesh.face_vertices(fkey) for fkey in mesh.faces()] pattern = Pattern.from_vertices_and_faces(xyz, faces) # clear skeleton layer = subdobject.settings['layer'] subdobject.clear() compas_rhino.delete_layers([layer]) scene.clear() scene.add(pattern, name='pattern') scene.update() print( "Pattern object successfully created. Input surface(s) have been hidden." )
def RunCommand(is_interactive): scene = get_scene() if not scene: return guids = compas_rhino.select_lines() if not guids: return lines = compas_rhino.get_line_coordinates(guids) pattern = Pattern.from_lines(lines, delete_boundary_face=True) if not pattern.face: print("No faces found! Pattern object was not created.") return compas_rhino.rs.HideObjects(guids) scene.clear() scene.add(pattern, name='pattern') scene.update() print("Pattern object successfully created.")
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 # skeleton from single point or a set of lines guids_temp = compas_rhino.rs.GetObjects( message="Select a single point or a group of lines", filter=compas_rhino.rs.filter.point | compas_rhino.rs.filter.curve) if not guids_temp: return # detect input object type guids_points = [] guids_lines = [] for guid in guids_temp: if is_curve_line(guid): guids_lines.append(guid) if compas_rhino.rs.IsPoint(guid): guids_points.append(guid) if len(guids_points) == 1 and len(guids_lines) == 0: guids = guids_points point = compas_rhino.get_point_coordinates(guids)[0] skeleton = Skeleton.from_center_point(point) elif len(guids_points) == 0 and len(guids_lines) > 0: guids = guids_lines lines = compas_rhino.get_line_coordinates(guids) skeleton = Skeleton.from_skeleton_lines(lines) if not skeleton: return compas_rhino.rs.HideObjects(guids) skeletonobject = SkeletonObject(skeleton) skeletonobject.draw() skeletonobject.dynamic_draw_widths() # modify skeleton while True: menu = CommandMenu(config) action = menu.select_action() if not action: return if action['name'] == 'Finish': break action['action'](skeletonobject) skeletonobject.draw() # make pattern mesh = skeletonobject.skeleton.to_mesh() xyz = mesh.vertices_attributes('xyz') faces = [mesh.face_vertices(fkey) for fkey in mesh.faces()] pattern = Pattern.from_vertices_and_faces(xyz, faces) # clear skeleton layer = skeletonobject.settings['layer'] skeletonobject.clear() compas_rhino.delete_layers([layer]) scene.clear() scene.add(pattern, name='pattern') scene.update() print("Pattern object successfully created. Input lines have been hidden.")
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." )