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 from_surface(root): # add option for uv versus heighfield? # add option for patches? guid = compas_rhino.select_surface() if not guid: return form = FormDiagram.from_rhinosurface(guid) return form
def RunCommand(is_interactive): scene = get_scene() if not scene: return guid = compas_rhino.select_surface() if not guid: return u = PatternObject.SETTINGS['from_surface.density.U'] v = PatternObject.SETTINGS['from_surface.density.V'] options = ['U', 'V'] while True: option = compas_rhino.rs.GetString("Enter values for U and V:", strings=options) if not option: break if option == 'U': u = compas_rhino.rs.GetInteger("Density U", u, 2, 100) continue if option == 'V': v = compas_rhino.rs.GetInteger("Density V", v, 2, 100) continue density = u + 1, v + 1 pattern = RhinoSurface.from_guid(guid).uv_to_compas(cls=Pattern, density=density) compas_rhino.rs.HideObject(guid) scene.clear() scene.add(pattern, name='pattern') scene.update() print( "Pattern object successfully created. Input surface has been hidden.")
point = self.closest_point(xyz) dx, dy, dz = subtract_vectors(point, xyz) mesh.vertex[key]['x'] += d * dx mesh.vertex[key]['y'] += d * dy mesh.vertex[key]['z'] += d * dz # ============================================================================== # Debugging # ============================================================================== if __name__ == '__main__': import compas_rhino guid = compas_rhino.select_surface() surface = RhinoSurface(guid) points = [] for xyz in surface.heightfield(): points.append({ 'pos': xyz, 'name': 'heightfield', 'color': (0, 255, 0), }) compas_rhino.xdraw_points(points, layer='Layer 01', clear=True, redraw=True)
def from_selection(cls): guid = compas_rhino.select_surface() return cls.from_guid(guid)
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.')
from compas.datastructures import Mesh from compas.geometry import planarize_faces from compas.geometry import flatness __author__ = [ 'Tom Van Mele', ] __copyright__ = 'Copyright 2016 - Block Research Group, ETH Zurich' __license__ = 'MIT License' __email__ = '*****@*****.**' # select an input surface and convert it to a mesh guid = compas_rhino.select_surface('Select an input surface.') mesh = compas_rhino.mesh_from_surface_heightfield(Mesh, guid, density=(20, 10)) # create a surface constraint surf = RhinoSurface(guid) # vertices and faces key_index = mesh.key_index() vertices_0 = mesh.get_vertices_attributes('xyz') vertices_1 = deepcopy(vertices_0) faces = [[key_index[key] for key in mesh.face_vertices(fkey)] for fkey in mesh.faces()]
def create_cablenet_from_surface(settings): guid = compas_rhino.select_surface() if not guid: return cablenet = Cablenet.from_rhinosurface(guid) return cablenet
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 callback(mesh, k, args): conduit, surf, fixed = args # pull the not fixed points back to the target surface surf.pull_mesh(mesh, fixed=fixed) # update the conduit conduit.redraw(k) guid = rhino.select_mesh() mesh = rhino.mesh_from_guid(Mesh, guid) guid = rhino.select_surface() surf = RhinoSurface(guid) fixed = mesh.vertices_on_boundary() conduit = MeshConduit(mesh, color=(255, 255, 255), refreshrate=2) with conduit.enabled(): smooth_mesh_area(mesh, fixed, kmax=100, callback=callback, callback_args=(conduit, surf, fixed)) rhino.draw_mesh(mesh)