def test(): opt_KeepLayer = Rhino.Input.Custom.OptionToggle("KeepLayer","No","Yes") go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep go.SetCommandPrompt("Select Breps") go.AddOptionToggle("KeepLayer",opt_KeepLayer) # go.GroupSelect = True # go.SubObjectSelect = False # go.AcceptEnterWhenDone(True) # go.AcceptNothing(True) # go.EnableClearObjectsOnEntry(False) # go.GroupSelect = True # go.SubObjectSelect = False # go.DeselectAllBeforePostSelect = False go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = True while True: res = go.GetMultiple(1,0) if res == Rhino.Input.GetResult.Option: go.EnablePreSelect(False, True) continue elif res != Rhino.Input.GetResult.Object: rs.Redraw() print "No Breps Selected!" return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: rs.Redraw() bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break print "testing..." return None
def divide_curve(): # get user input res, obj_refs = RhinoGet.GetMultipleObjects("Curves to divide", False, ObjectType.EdgeFilter | ObjectType.Curve) if res <> Result.Success: return res curves = [obj_ref.Curve() for obj_ref in obj_refs] distance_between_divisions = rs.GetReal( message = "Distance between divisions", number = 5.0, minimum = 1.0) if distance_between_divisions == None: return # generate the points points = [] for curve in curves: t0 = curve.Domain.Min points.append(curve.PointAt(t0)) sphere_center = curve.PointAt(t0) t = t0 rest_of_curve = curve while True: sphere = Sphere(sphere_center, distance_between_divisions) b, overlapCurves, intersectPoints = Intersection.CurveBrep( rest_of_curve, sphere.ToBrep(), 0.0) if b == False or (overlapCurves.Length == 0 and intersectPoints.Length == 0): break t, point = nextIntersectParamAndPoint( overlapCurves, intersectPoints, rest_of_curve) points.append(point) sphere_center = point rest_of_curve = curve.Split(t)[1] rs.AddPoints(points) rs.Redraw()
def SampleSynchronizeRenderColors(): objects = rs.AllObjects() if objects is None: return for obj in objects: color = rs.ObjectColor(obj) source = rs.ObjectColorSource(obj) material = -1 if source == 0: layer = rs.ObjectLayer(obj) material = rs.LayerMaterialIndex(layer) if material < 0: material = rs.AddMaterialToLayer(layer) elif source == 1: material = rs.ObjectMaterialIndex(obj) if material < 0: material = rs.AddMaterialToObject(obj) if material >= 0: if color != rs.MaterialColor(material): rs.MaterialColor(material, color) rs.Redraw()
def RunCommand(is_interactive): setGlobals() crvs = get_input() if isinstance(crvs, list): rc_get_tags(crvs) rs.EnableRedraw(True) rs.Redraw() return 0
def SampleTextDot(): gp = SampleGetTextDotPoint(); gp.Get() if (gp.CommandResult() == Rhino.Commands.Result.Success): point = gp.Point() str = gp.FormatPointString(point) rs.AddTextDot(str, point) rs.Redraw()
def jumps(self, magnitude): a = rs.GetPoint("Enter start point") p = rs.AddPoint(a) sphere = rs.AddSphere(p, 4) print self.direction prevPos = rs.PointCoordinates(self.point) for d in range(1, 50): nn = rs.Redraw() for i in range(1, 50): rs.MoveObject(sphere, (1, 1, 20 / i)) for i in range(1, 50): rs.MoveObject(sphere, (1, 1, -1 * i / 40))
def main(): max_flrs = 9999 # maximum number of folders to open max_fils = 9999 # maximum number of files to open in each folder folder_tic = time.clock() fdr_cnt = 0 for root, dirs, files in walklevel(src_path): print("{}\t {}".format(fdr_cnt, root)) #if (root == src_path): continue fil_cnt = 0 for full_filename in files: filename, file_extension = os.path.splitext(full_filename) if file_extension != ".3dm": continue file_tic = time.clock() filepath = os.path.join(root, full_filename) rs.DocumentModified(False) rs.Command('_-Open {} _Enter'.format('"' + filepath + '"')) pln = rs.PlaneFromPoints((100, 0, 0), (0, 100, 0), (100, 100, 0)) rs.AddRectangle(pln, 100, 100) set_active_view("Origin_SW_ISO") view = rs.CurrentView() set_disp_mode(disp_mode) rs.Redraw() """ rs.ViewProjection(view,2) rs.ViewCameraTarget(view,cam_pos,tar_pos) rs.ViewCameraLens(view,lens_len) rs.ZoomExtents(view) #rs.ViewCameraLens(view,25) """ capture_view_antialias( os.path.join(tar_path, "{}.png".format(filename)), image_size) t = round(time.clock() - file_tic) print(filename + "\ttime:\t" + str(t)) fil_cnt += 1 if fil_cnt > max_fils: break fdr_cnt += 1 if fdr_cnt > max_flrs: break t = round(time.clock() - folder_tic) print("TOTAL\ttime:\t" + str(t))
def __init__(self, color=None): self.point = rs.GetPoint() self.radius = .2 self.color = color self.block = Block() self.circle = None self.id = uuid.uuid4() self.hatch = None self.group_name = None self.center = None self.group_list = [] self.add_count() self.set_color(color) rs.Redraw()
def redraw(self, timeout=None): """Redraw the Rhino view. Parameters ---------- timeout : float, optional The amount of time the artist waits before updating the Rhino view. The time should be specified in seconds. Default is ``None``. """ if timeout: time.sleep(timeout) rs.EnableRedraw(True) rs.Redraw()
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 guessHorizontalShift(): """ This script will correct the horizontal distortion and set it in the V-Ray Camera. It levels the camera for this correction to work well and resets lens shift (vertical shift) to 0 Works with V-Ray 5.1 version 0.4 www.studiogijs.nl """ viewport = Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport if viewport.IsParallelProjection: print "Stupid, you should select a perspective view" return view = Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport #set camera location to target height pt = view.CameraLocation pt[2] = view.CameraTarget.Z dir = rs.VectorSubtract(view.CameraTarget, pt) view.SetCameraLocation(pt, False) view.SetCameraDirection(dir, False) #calculate camera direction angle relative to WorldXY plane cam = view.CameraZ vec = Rhino.Geometry.Vector3d(1, 0, 0) plane = Rhino.Geometry.Plane.WorldXY angle = Rhino.Geometry.Vector3d.VectorAngle(cam, vec, plane) #calculate the correction factor for i in range(3): if angle > math.pi / 2: angle -= math.pi / 2 else: break if 0 <= angle < math.pi / 4: factor = math.tan(angle) if math.pi / 4 <= angle < math.pi / 2: factor = -math.tan(math.pi / 2 - angle) rv = rs.GetPlugInObject("V-Ray for Rhino").Scene().Plugin( "/CameraPhysical") rv.Param("horizontal_shift").Value = factor print "Horizontal shift factor set to %r." % factor rv.Param("lens_shift").Value = 0 rs.Redraw()
def cloudrestore(id): """Retrieve settings document from a couchdb database and update the current application settings by these values Parameters: id: name of the document store in the database """ f = urllib.urlopen(couchdb_url + "/" + id) data = json.load(f) f.close() if data.has_key("error"): return data states = {} states[ "AppearanceSettings"] = Rhino.ApplicationSettings.AppearanceSettings.GetDefaultState( ) states[ "EdgeAnalysisSettings"] = Rhino.ApplicationSettings.EdgeAnalysisSettings.GetDefaultState( ) states[ "ModelAidSettings"] = Rhino.ApplicationSettings.ModelAidSettings.GetDefaultState( ) def restoresetting(state, name, setting): try: s = "state." + name if name.endswith("Color"): s += "=System.Drawing.ColorTranslator.FromHtml(\"" + setting + "\")" else: if type(setting) is str: s += "='" + setting + "'" else: s += "=" + str(setting) exec(s) except: print sys.exc_info() for setting, val in data.items(): if type(val) is dict and states.has_key(setting): state = states[setting] for k, v in val.items(): restoresetting(state, k, v) Rhino.ApplicationSettings.AppearanceSettings.UpdateFromState( states["AppearanceSettings"]) Rhino.ApplicationSettings.EdgeAnalysisSettings.UpdateFromState( states["EdgeAnalysisSettings"]) Rhino.ApplicationSettings.ModelAidSettings.UpdateFromState( states["ModelAidSettings"]) rs.Redraw()
def cloudrestore(id): """Retrieve settings from database and update the the current application settings by these values Parameters: id: name of the settings scheme in the database """ f = urllib.urlopen(appengine_url + '/' + id) received_data = f.read() f.close() if not received_data: return data = json.loads(received_data) color = data["ViewportBackgroundColor"] color = System.Drawing.ColorTranslator.FromHtml(color) Rhino.ApplicationSettings.AppearanceSettings.ViewportBackgroundColor = color rs.Redraw()
def on_selected(sender, event): try: rs.UnselectAllObjects() key = event.Item.Values[0] guid2key = getattr(sceneNode.artist, guid_field) key2guid = {str(guid2key[guid]): guid for guid in guid2key} if key in key2guid: find_object(key2guid[key]).Select(True) elif children_guid_field: if key == '': key = event.Item.Values[1] guid2key = getattr(sceneNode.artist, children_guid_field) key2guid = {str(guid2key[guid]): guid for guid in guid2key} find_object(key2guid[key]).Select(True) print('selected', key, key2guid[key]) rs.Redraw() except Exception as e: print(e)
def draw_light(mesh, temp=True): pts = [] faces = [] count = 0 for u, v in mesh.edges(): pts.append(mesh.vertex_coordinates(u)) pts.append(mesh.vertex_coordinates(v)) pts.append( (mesh.vertex[u]['x2'], mesh.vertex[u]['y2'], mesh.vertex[u]['z2'])) pts.append( (mesh.vertex[v]['x2'], mesh.vertex[v]['y2'], mesh.vertex[v]['z2'])) faces.append([count, count + 1, count + 3, count + 2]) count += 4 guid = rs.AddMesh(pts, faces) if temp: Rhino.RhinoApp.Wait() rs.Redraw() # rs.EnableRedraw(True) # rs.EnableRedraw(False) rs.DeleteObject(guid) return guid
def on_selected(sender, event): try: rs.UnselectAllObjects() key = event.Item.Values[1] guid2key = getattr(sceneNode, guid_field) key2guid = {str(guid2key[guid]): guid for guid in guid2key} if key in key2guid: find_object(key2guid[key]).Select(True) if dual: force_edge_index = int(event.Item.Values[0]) force_edge_key2index = dual.diagram.edge_index( dual.diagram.dual) force_edge_index2key = { force_edge_key2index[key]: key for key in force_edge_key2index } force_edge_key = force_edge_index2key[force_edge_index] guid2key = getattr(dual, guid_field) key2guid = {guid2key[guid]: guid for guid in guid2key} key2guid.update({(v, u): key2guid[(u, v)] for u, v in key2guid}) if force_edge_key in key2guid: find_object(key2guid[force_edge_key]).Select(True) # elif children_guid_field: # if key == '': # key = event.Item.Values[1] # guid2key = getattr(sceneNode.artist, children_guid_field) # key2guid = {str(guid2key[guid]): guid for guid in guid2key} # find_object(key2guid[key]).Select(True) # print('selected', key, key2guid[key]) rs.Redraw() except Exception as e: print(e)
def redraw(self): """Redraw the Rhino view.""" rs.EnableRedraw(True) rs.Redraw()
def rc_collapse_box(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_KeepLayer = sc.sticky["KeepLayer"] if sc.sticky.has_key( "KeepLayer") else False default_IgnoreOpen = sc.sticky["IgnoreOpen"] if sc.sticky.has_key( "IgnoreOpen") else False opt_KeepLayer = Rhino.Input.Custom.OptionToggle(default_KeepLayer, "No", "Yes") opt_IgnoreOpen = Rhino.Input.Custom.OptionToggle(default_IgnoreOpen, "No", "Yes") go.SetCommandPrompt("Select Breps") go.AddOptionToggle("KeepLayer", opt_KeepLayer) go.AddOptionToggle("IgnoreOpenBreps", opt_IgnoreOpen) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = True while True: res = go.GetMultiple(1, 0) if res == Rhino.Input.GetResult.Option: go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: rs.Redraw() print "No breps were selected!" return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: rs.Redraw() bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break OPT_IGNORE_OPEN = opt_IgnoreOpen.CurrentValue OPT_KEEP_LAYER = opt_KeepLayer.CurrentValue sticky["IgnoreOpen"] = OPT_IGNORE_OPEN sticky["KeepLayer"] = OPT_KEEP_LAYER rs.EnableRedraw(False) input_breps = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() input_breps.append(b_obj.Id) current_cplane = sc.doc.Views.ActiveView.ActiveViewport.GetConstructionPlane( ) temp_cplane = current_cplane.Plane current_cplane.Plane = rs.WorldXYPlane() solid_brep_count = 0 for brep in input_breps: if not rs.IsObjectSolid(brep): solid_brep_count += 1 if OPT_IGNORE_OPEN: continue if OPT_KEEP_LAYER: brep_layer = rs.ObjectLayer(rs.coerceguid(brep)) exploded = rs.ExplodePolysurfaces(brep, True) remaining_srfs = [] for srf in exploded: norm = rs.SurfaceNormal(srf, [0.5, 0.5]) if 10 > rs.VectorAngle(norm, [0, 0, 1]) or 10 > rs.VectorAngle( norm, [0, 0, -1]): rs.DeleteObject(srf) else: remaining_srfs.append(srf) areas = [rs.SurfaceArea(s) for s in remaining_srfs] areas = [x[0] for x in areas] srfs, areas = zip( *sorted(zip(remaining_srfs, areas), key=lambda x: x[1])) pt1, _ = rs.SurfaceAreaCentroid(srfs[-1]) pt2, _ = rs.SurfaceAreaCentroid(srfs[-2]) vect = rs.VectorCreate(pt2, pt1) vect = rs.VectorDivide(vect, 2) rs.MoveObject(srfs[-1], vect) if OPT_KEEP_LAYER: rs.ObjectLayer(srfs[-1], brep_layer) rs.SelectObjects(srfs[-1]) rs.DeleteObjects(srfs[:-1]) rs.EnableRedraw(True) rs.Redraw() current_cplane.Plane = temp_cplane if solid_brep_count > 0: outcome = " and were not collapsed." if OPT_IGNORE_OPEN else " and may have been flattened incorrectly. Check input geometry." report = str(solid_brep_count) + " brep(s) were not closed" + outcome print report
def rc_Bridge(): #get stickies default_bridge_size = sticky["defaultSize"] if sticky.has_key( "defaultSize") else 2 default_bridge_border = sticky["defaultBorder"] if sticky.has_key( "defaultBorder") else 2 default_bynum_bool = sticky["defaultByNum"] if sticky.has_key( "defaultByNum") else True go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve go.GeometryAttributeFilter = Rhino.Input.Custom.GeometryAttributeFilter.ClosedCurve opt_bridge_size = Rhino.Input.Custom.OptionDouble(default_bridge_size, 0.2, 1000) opt_bridge_border = Rhino.Input.Custom.OptionDouble( default_bridge_border, 0.2, 1000) opt_by_num = Rhino.Input.Custom.OptionToggle(default_bynum_bool, "ByLength", "ByNumber") go.SetCommandPrompt("Select Curves for Bridging") go.AddOptionDouble("BridgeSize", opt_bridge_size) go.AddOptionDouble("BridgeBorder", opt_bridge_border) out_mode = go.AddOptionToggle("Mode", opt_by_num) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1, 0) #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: # print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break CUT_LENGTH = opt_bridge_size.CurrentValue CUT_TOL = opt_bridge_border.CurrentValue BY_NUM = opt_by_num.CurrentValue #get properties of objects crv_max_length = 0 crv_obj_list = [] for i in xrange(go.ObjectCount): c_obj = go.Object(i).Object() crv_obj_list.append(c_obj) if i == 0: crv_max_length = c_obj.CurveGeometry.Domain.Mid else: crv_max_length = min(crv_max_length, c_obj.CurveGeometry.Domain.Mid) #add bridges by length or by number. if BY_NUM == True: default_segmentCount = sticky["defaultSegmentCount"] if sticky.has_key( "defaultSegmentCount") else 2 rc, segment_count = Rhino.Input.RhinoGet.GetInteger( "Divide curves into how many segments?", True, default_segmentCount, 2, 500) if rc != Rhino.Commands.Result.Success: return rc m_addBridges(crv_obj_list, segment_count) sticky["defaultSegmentCount"] = segment_count else: default_segmentLength = sticky["defaultSegLength"] if ( sticky.has_key("defaultSegLength") and sticky["defaultSegLength"] < crv_max_length ) else crv_max_length / 2 s = "What approximate length would you like to target? The maximum for these curves is {0:.2f}".format( crv_max_length) rc, segment_length = Rhino.Input.RhinoGet.GetNumber( s, False, default_segmentLength, 0, crv_max_length) if rc != Rhino.Commands.Result.Success: return rc m_addBridges(crv_obj_list, segment_length, False) sticky["defaultSegLen"] = segment_length #display the bridges and request options. go = Rhino.Input.Custom.GetOption() opt_bridge_size = Rhino.Input.Custom.OptionDouble(CUT_LENGTH, 0.2, 1000) opt_bridge_border = Rhino.Input.Custom.OptionDouble(CUT_TOL, 0.2, 1000) go.SetCommandPrompt("Adjust Options. Enter to Continue.") go.AddOptionDouble("BridgeSize", opt_bridge_size) go.AddOptionDouble("BridgeBorder", opt_bridge_border) go.AcceptEnterWhenDone(True) go.AcceptNothing(True) #draw the preview. buffer_distance = CUT_LENGTH + CUT_TOL m_manage_discons(crv_obj_list, buffer_distance) preview_layers = m_showBridges(crv_obj_list, CUT_LENGTH, CUT_TOL) rs.Redraw() while True: res = go.Get() #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: for layer_ind in preview_layers: Rhino.DocObjects.Tables.LayerTable.Purge( doc.ActiveDoc.Layers, layer_ind, True) CUT_LENGTH = opt_bridge_size.CurrentValue CUT_TOL = opt_bridge_border.CurrentValue buffer_distance = CUT_LENGTH + CUT_TOL m_manage_discons(crv_obj_list, buffer_distance) preview_layers = m_showBridges(crv_obj_list, CUT_LENGTH, CUT_TOL) rs.Redraw() continue #If not correct elif res == Rhino.Input.GetResult.Nothing: for layer_ind in preview_layers: doc.ActiveDoc.Layers Rhino.DocObjects.Tables.LayerTable.Purge( doc.ActiveDoc.Layers, layer_ind, True) break for layer_ind in preview_layers: doc.ActiveDoc.Layers Rhino.DocObjects.Tables.LayerTable.Purge(doc.ActiveDoc.Layers, layer_ind, True) return Rhino.Commands.Result.Failure break CUT_LENGTH = opt_bridge_size.CurrentValue CUT_TOL = opt_bridge_border.CurrentValue #Request output options. m_makeBridgeLines(crv_obj_list, CUT_LENGTH) sticky["defaultSize"] = CUT_LENGTH sticky["defaultBorder"] = CUT_TOL sticky["defaultByNum"] = BY_NUM return Rhino.Commands.Result.Success
def outline_region(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve default_length = sc.sticky["length"] if sc.sticky.has_key("length") else 100 default_delete = sc.sticky["delete"] if sc.sticky.has_key("delete") else True opt_delete = Rhino.Input.Custom.OptionToggle(default_delete,"No","Yes") go.SetCommandPrompt("Select Curves") go.AddOptionToggle("DeleteInput", opt_delete) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1,0) if res == Rhino.Input.GetResult.Option: #print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: print "No curves selected!" return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break input_curves = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() input_curves.append(b_obj.Id) #Get length extension_length = rs.GetInteger(message="Enter Extension Length",number=default_length) if not extension_length: rs.EnableRedraw(True) print "No Extension Length entered." return False arr_preview_geom = get_preview_geometry(input_curves) for indCrv in arr_preview_geom: rs.ExtendCurveLength(indCrv,0,2,extension_length) rs.EnableRedraw(False) #Get curveboolean and display it region_was_created = True rs.UnselectAllObjects() rs.SelectObjects(arr_preview_geom) rs.Command("_-CurveBoolean _AllRegions _Enter") pcurve_outline = rs.LastCreatedObjects() if isinstance(pcurve_outline,list): preview_srf = rs.AddPlanarSrf(pcurve_outline) rs.LockObjects(arr_preview_geom) rs.LockObjects(preview_srf) else: region_was_created = False rs.LockObjects(arr_preview_geom) preview_srf = [] rs.EnableRedraw(True) rs.Redraw() #Set up input object go = Rhino.Input.Custom.GetOption() optint = Rhino.Input.Custom.OptionDouble(extension_length) prompt = "Press Enter to accept" warning = "Insufficient overlap length. " s = prompt if region_was_created else warning+prompt go.SetCommandPrompt(s) go.AddOptionDouble("ExtensionLength", optint) go.AddOptionToggle("DeleteInput", opt_delete) go.AcceptEnterWhenDone(True) go.AcceptNothing(True) #control flow: can distinguish between inserting an option, cancelling, and pressing enter res = None while True: res = go.Get() rs.EnableRedraw(False) region_was_created = True #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: #Delete old preview rs.UnlockObjects(preview_srf+arr_preview_geom) rs.DeleteObjects(preview_srf+arr_preview_geom) if isinstance(pcurve_outline,list): rs.DeleteObjects(pcurve_outline) rs.SelectObjects(input_curves) #Draw new preview arr_preview_geom = get_preview_geometry(input_curves) if not extension_length: return False for indCrv in arr_preview_geom: rs.ExtendCurveLength(indCrv,0,2,optint.CurrentValue) rs.UnselectAllObjects() rs.SelectObjects(arr_preview_geom) rs.Command("_-CurveBoolean _AllRegions _Enter") pcurve_outline = rs.LastCreatedObjects() if isinstance(pcurve_outline,list): preview_srf = rs.AddPlanarSrf(pcurve_outline) rs.LockObjects(arr_preview_geom) rs.LockObjects(preview_srf) else: rs.LockObjects(arr_preview_geom) preview_srf = [] region_was_created = False rs.EnableRedraw(True) s = prompt if region_was_created else warning+prompt go.SetCommandPrompt(s) continue #If accepted, leave loop elif res == Rhino.Input.GetResult.Nothing: break #If cancelled, delete working geometry elif res != Rhino.Input.GetResult.Option: rs.UnlockObjects(preview_srf) rs.UnlockObjects(arr_preview_geom) rs.DeleteObjects(preview_srf) rs.DeleteObjects(arr_preview_geom) rs.DeleteObjects(pcurve_outline) rs.EnableRedraw(True) return Rhino.Commands.Result.Cancel #Clean up if successful if opt_delete.CurrentValue == True: rs.DeleteObjects(input_curves) rs.UnlockObjects(preview_srf) rs.UnlockObjects(arr_preview_geom) rs.DeleteObjects(preview_srf) rs.DeleteObjects(arr_preview_geom) if isinstance(pcurve_outline,list): rs.SelectObjects(pcurve_outline) sc.sticky["length"] = optint.CurrentValue sc.sticky["delete"] = opt_delete.CurrentValue rs.EnableRedraw(True)
def rc_unroll_ortho(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_thickness = sticky["thickness"] if sticky.has_key("thickness") else 5.5 default_lid = sticky["lid"] if sticky.has_key("lid") else False opt_thickness = Rhino.Input.Custom.OptionDouble(default_thickness,0.2,1000) opt_lid = Rhino.Input.Custom.OptionToggle(default_lid,"No","Yes") go.SetCommandPrompt("Select breps to unroll. Breps must be orthogonal (faces at 90 degree angles)") go.AddOptionDouble("Thickness", opt_thickness) go.AddOptionToggle("Lids", opt_lid) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1,0) #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: #print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break rs.EnableRedraw(False) LID = opt_lid.CurrentValue global LCUT_INDICES, THICKNESS THICKNESS = opt_thickness.CurrentValue LCUT_INDICES = wla.get_lcut_layers() #Get geometry and object lists brep_obj_list = [] brep_geo_list = [] brep_ids_list = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() brep_obj_list.append(b_obj) #use world cplane current_cplane = sc.doc.Views.ActiveView.ActiveViewport.GetConstructionPlane() temp_cplane = current_cplane.Plane current_cplane.Plane = rs.WorldXYPlane() #get information for each piece to be output. #future implementation should use bounding dims and curves rather than dimension-based system. unrolled_brep_info = [] lid_info = [] SELECT_GUIDS = [] #convert to breps input_brep_geo = [] for i,obj in enumerate(brep_obj_list): #geometry prep: convert extrusions to breps if str(obj.ObjectType) != "Brep": new_brep = wru.extrusion_to_brep(obj.Geometry) else: new_brep = obj.Geometry input_brep_geo.append(new_brep) for geo in input_brep_geo: unroll_brep_with_thickness(geo) sticky["thickness"] = THICKNESS sticky["lid"] = LID current_cplane.Plane = temp_cplane rs.UnselectAllObjects() rs.SelectObjects(SELECT_GUIDS) rs.Redraw() rs.EnableRedraw(True)
def transonic_airliner( Propulsion=1, # 1 - twin, 2 - quad EngineDia=2.9, # Diameter of engine intake highlight FuselageScaling=[55.902, 55.902, 55.902], # [x,y,z] scale factors NoseLengthRatio=0.182, # Proportion of forward tapering section of the fuselage TailLengthRatio=0.293, # Proportion of aft tapering section of the fuselage WingScaleFactor=44.56, WingChordFactor=1.0, Topology=1, # Topology = 2 will yield a box wing airliner - use with caution, this is just for demo purposes. SpanStation1=0.31, # Inboard engine at this span station SpanStation2=0.625, # Outboard engine at this span station (ignored if Propulsion=1) EngineCtrBelowLE=0.3558, # Engine below leading edge, normalised by the length of the nacelle - range: [0.35,0.5] EngineCtrFwdOfLE=0.9837, # Engine forward of leading edge, normalised by the length of the nacelle - range: [0.85,1.5] Scarf_deg=3): # Engine scarf angle # Build fuselage geometry rs.EnableRedraw(False) try: FuselageOMLSurf, SternPoint = fuselage_oml.FuselageOML( NoseLengthRatio, TailLengthRatio, Scaling=FuselageScaling, NoseCoordinates=[0, 0, 0], CylindricalMidSection=False, SimplificationReqd=False) except: print "Fuselage fitting failed - stopping." return FuselageHeight = FuselageScaling[2] * 0.105 FuselageLength = FuselageScaling[0] FuselageWidth = FuselageScaling[1] * 0.106 rs.Redraw() if FuselageOMLSurf is None: print "Failed to fit fuselage surface, stopping." return FSurf = rs.CopyObject(FuselageOMLSurf) # Position of the apex of the wing if FuselageHeight < 8.0: WingApex = [0.1748 * FuselageLength, 0, -0.0523 * FuselageHeight] #787:[9.77,0,-0.307] else: WingApex = [0.1748 * FuselageLength, 0, -0.1 * FuselageHeight] #787:[9.77,0,-0.307] # Set up the wing object, including the list of user-defined functions that # describe the spanwise variations of sweep, dihedral, etc. LooseSurf = 1 if Topology == 1: SegmentNo = 10 Wing = liftingsurface.LiftingSurface(WingApex, ta.mySweepAngleFunctionAirliner, ta.myDihedralFunctionAirliner, ta.myTwistFunctionAirliner, ta.myChordFunctionAirliner, ta.myAirfoilFunctionAirliner, LooseSurf, SegmentNo, TipRequired=True) elif Topology == 2: SegmentNo = 101 Wing = liftingsurface.LiftingSurface(WingApex, ta.mySweepAngleFunctionAirliner, bw.myDihedralFunctionBoxWing, ta.myTwistFunctionAirliner, ta.myChordFunctionAirliner, ta.myAirfoilFunctionAirliner, LooseSurf, SegmentNo, TipRequired=True) # Instantiate the wing object and add it to the document rs.EnableRedraw(False) WingSurf, ActualSemiSpan, LSP_area, RootChord, AR, WingTip = Wing.GenerateLiftingSurface( WingChordFactor, WingScaleFactor) rs.Redraw() if Topology == 1: # Add wing to body fairing WTBFXCentre = WingApex[ 0] + RootChord / 2.0 + RootChord * 0.1297 # 787: 23.8 if FuselageHeight < 8.0: WTBFZ = RootChord * 0.009 #787: 0.2 WTBFheight = 0.1212 * RootChord #787:2.7 WTBFwidth = 1.08 * FuselageWidth else: WTBFZ = WingApex[2] + 0.005 * RootChord WTBFheight = 0.09 * RootChord WTBFwidth = 1.15 * FuselageWidth WTBFlength = 1.167 * RootChord #787:26 WTBFXStern = WTBFXCentre + WTBFlength / 2.0 CommS = "_Ellipsoid %3.2f,0,%3.2f %3.2f,0,%3.2f %3.2f,%3.2f,%3.2f %3.2f,0,%3.2f " % ( WTBFXCentre, WTBFZ, WTBFXStern, WTBFZ, 0.5 * (WTBFXCentre + WTBFXStern), 0.5 * WTBFwidth, WTBFZ, 0.5 * (WTBFXCentre + WTBFXStern), WTBFheight) rs.EnableRedraw(False) rs.CurrentView("Perspective") rs.Command(CommS) LO = rs.LastCreatedObjects() WTBF = LO[0] rs.Redraw() # Trim wing inboard section CutCirc = rs.AddCircle3Pt((0, WTBFwidth / 4, -45), (0, WTBFwidth / 4, 45), (90, WTBFwidth / 4, 0)) CutCircDisk = rs.AddPlanarSrf(CutCirc) CutDisk = CutCircDisk[0] rs.ReverseSurface(CutDisk, 1) rs.TrimBrep(WingSurf, CutDisk) elif Topology == 2: # Overlapping wing tips CutCirc = rs.AddCircle3Pt((0, 0, -45), (0, 0, 45), (90, 0, 0)) CutCircDisk = rs.AddPlanarSrf(CutCirc) CutDisk = CutCircDisk[0] rs.ReverseSurface(CutDisk, 1) rs.TrimBrep(WingSurf, CutDisk) # Engine installation (nacelle and pylon) if Propulsion == 1: # Twin, wing mounted SpanStation = SpanStation1 NacelleLength = 1.95 * EngineDia rs.EnableRedraw(False) EngineSection, Chord = act.CutSect(WingSurf, SpanStation) CEP = rs.CurveEndPoint(Chord) EngineStbd, PylonStbd = engine.TurbofanNacelle( EngineSection, Chord, CentreLocation=[ CEP.X - EngineCtrFwdOfLE * NacelleLength, CEP.Y, CEP.Z - EngineCtrBelowLE * NacelleLength ], ScarfAngle=Scarf_deg, HighlightRadius=EngineDia / 2.0, MeanNacelleLength=NacelleLength) rs.Redraw() elif Propulsion == 2: # Quad, wing-mounted NacelleLength = 1.95 * EngineDia rs.EnableRedraw(False) EngineSection, Chord = act.CutSect(WingSurf, SpanStation1) CEP = rs.CurveEndPoint(Chord) EngineStbd1, PylonStbd1 = engine.TurbofanNacelle( EngineSection, Chord, CentreLocation=[ CEP.X - EngineCtrFwdOfLE * NacelleLength, CEP.Y, CEP.Z - EngineCtrBelowLE * NacelleLength ], ScarfAngle=Scarf_deg, HighlightRadius=EngineDia / 2.0, MeanNacelleLength=NacelleLength) rs.DeleteObjects([EngineSection, Chord]) EngineSection, Chord = act.CutSect(WingSurf, SpanStation2) CEP = rs.CurveEndPoint(Chord) EngineStbd2, PylonStbd2 = engine.TurbofanNacelle( EngineSection, Chord, CentreLocation=[ CEP.X - EngineCtrFwdOfLE * NacelleLength, CEP.Y, CEP.Z - EngineCtrBelowLE * NacelleLength ], ScarfAngle=Scarf_deg, HighlightRadius=EngineDia / 2.0, MeanNacelleLength=NacelleLength) rs.Redraw() # Script for generating and positioning the fin rs.EnableRedraw(False) # Position of the apex of the fin P = [0.6524 * FuselageLength, 0.003, FuselageHeight * 0.384] #P = [36.47,0.003,2.254]55.902 RotVec = rs.VectorCreate([1, 0, 0], [0, 0, 0]) LooseSurf = 1 SegmentNo = 200 Fin = liftingsurface.LiftingSurface(P, tail.mySweepAngleFunctionFin, tail.myDihedralFunctionFin, tail.myTwistFunctionFin, tail.myChordFunctionFin, tail.myAirfoilFunctionFin, LooseSurf, SegmentNo) ChordFactor = 1.01 #787:1.01 if Topology == 1: ScaleFactor = WingScaleFactor / 2.032 #787:21.93 elif Topology == 2: ScaleFactor = WingScaleFactor / 3.5 FinSurf, FinActualSemiSpan, FinArea, FinRootChord, FinAR, FinTip = Fin.GenerateLiftingSurface( ChordFactor, ScaleFactor) FinSurf = rs.RotateObject(FinSurf, P, 90, axis=RotVec) FinTip = rs.RotateObject(FinTip, P, 90, axis=RotVec) if Topology == 1: # Tailplane P = [0.7692 * FuselageLength, 0.000, FuselageHeight * 0.29] RotVec = rs.VectorCreate([1, 0, 0], [0, 0, 0]) LooseSurf = 1 SegmentNo = 100 TP = liftingsurface.LiftingSurface(P, tail.mySweepAngleFunctionTP, tail.myDihedralFunctionTP, tail.myTwistFunctionTP, tail.myChordFunctionTP, tail.myAirfoilFunctionTP, LooseSurf, SegmentNo) ChordFactor = 1.01 ScaleFactor = 0.388 * WingScaleFactor #787:17.3 TPSurf, TPActualSemiSpan, TPArea, TPRootChord, TPAR, TPTip = TP.GenerateLiftingSurface( ChordFactor, ScaleFactor) rs.EnableRedraw(True) rs.DeleteObjects([EngineSection, Chord]) try: rs.DeleteObjects([CutCirc]) except: pass try: rs.DeleteObjects([CutCircDisk]) except: pass # Windows # Cockpit windows: rs.EnableRedraw(False) CockpitWindowTop = 0.305 * FuselageHeight CWC1s, CWC2s, CWC3s, CWC4s = fuselage_oml.CockpitWindowContours( Height=CockpitWindowTop, Depth=6) FuselageOMLSurf, Win1 = rs.SplitBrep(FuselageOMLSurf, CWC1s, delete_input=True) FuselageOMLSurf, Win2 = rs.SplitBrep(FuselageOMLSurf, CWC2s, delete_input=True) FuselageOMLSurf, Win3 = rs.SplitBrep(FuselageOMLSurf, CWC3s, delete_input=True) FuselageOMLSurf, Win4 = rs.SplitBrep(FuselageOMLSurf, CWC4s, delete_input=True) rs.DeleteObjects([CWC1s, CWC2s, CWC3s, CWC4s]) (Xmin, Ymin, Zmin, Xmax, Ymax, Zmax) = act.ObjectsExtents([Win1, Win2, Win3, Win4]) CockpitBulkheadX = Xmax CockpitWallPlane = rs.PlaneFromPoints([CockpitBulkheadX, -15, -15], [CockpitBulkheadX, 15, -15], [CockpitBulkheadX, -15, 15]) CockpitWall = rs.AddPlaneSurface(CockpitWallPlane, 30, 30) if 'WTBF' in locals(): rs.TrimBrep(WTBF, CockpitWall) rs.DeleteObject(CockpitWall) # Window lines WIN = [1] NOWIN = [0] # A typical window pattern (including emergency exit windows) WinVec = WIN + 2 * NOWIN + 9 * WIN + 3 * NOWIN + WIN + NOWIN + 24 * WIN + 2 * NOWIN + WIN + NOWIN + 14 * WIN + 2 * NOWIN + WIN + 20 * WIN + 2 * NOWIN + WIN + NOWIN + 20 * WIN if FuselageHeight < 8.0: # Single deck WindowLineHeight = 0.3555 * FuselageHeight WinX = 0.1157 * FuselageLength WindowPitch = 0.609 WinInd = -1 while WinX < 0.75 * FuselageLength: WinInd = WinInd + 1 if WinVec[WinInd] == 1 and WinX > CockpitBulkheadX: WinStbd, WinPort, FuselageOMLSurf = fuselage_oml.MakeWindow( FuselageOMLSurf, WinX, WindowLineHeight) act.AssignMaterial(WinStbd, "Plexiglass") act.AssignMaterial(WinPort, "Plexiglass") WinX = WinX + WindowPitch else: # Fuselage big enough to accommodate two decks # Lower deck WindowLineHeight = 0.17 * FuselageHeight #0.166 WinX = 0.1 * FuselageLength #0.112 WindowPitch = 0.609 WinInd = 0 while WinX < 0.757 * FuselageLength: WinInd = WinInd + 1 if WinVec[WinInd] == 1 and WinX > CockpitBulkheadX: WinStbd, WinPort, FuselageOMLSurf = fuselage_oml.MakeWindow( FuselageOMLSurf, WinX, WindowLineHeight) act.AssignMaterial(WinStbd, "Plexiglass") act.AssignMaterial(WinPort, "Plexiglass") WinX = WinX + WindowPitch # Upper deck WindowLineHeight = 0.49 * FuselageHeight WinX = 0.174 * FuselageLength #0.184 WinInd = 0 while WinX < 0.757 * FuselageLength: WinInd = WinInd + 1 if WinVec[WinInd] == 1 and WinX > CockpitBulkheadX: WinStbd, WinPort, FuselageOMLSurf = fuselage_oml.MakeWindow( FuselageOMLSurf, WinX, WindowLineHeight) act.AssignMaterial(WinStbd, "Plexiglass") act.AssignMaterial(WinPort, "Plexiglass") WinX = WinX + WindowPitch rs.Redraw() act.AssignMaterial(FuselageOMLSurf, "White_composite_external") act.AssignMaterial(WingSurf, "White_composite_external") try: act.AssignMaterial(TPSurf, "ShinyBARedMetal") except: pass act.AssignMaterial(FinSurf, "ShinyBARedMetal") act.AssignMaterial(Win1, "Plexiglass") act.AssignMaterial(Win2, "Plexiglass") act.AssignMaterial(Win3, "Plexiglass") act.AssignMaterial(Win4, "Plexiglass") # Mirror the geometry as required act.MirrorObjectXZ(WingSurf) act.MirrorObjectXZ(WingTip) try: act.MirrorObjectXZ(TPSurf) act.MirrorObjectXZ(TPTip) except: pass if Propulsion == 1: for ObjId in EngineStbd: act.MirrorObjectXZ(ObjId) act.MirrorObjectXZ(PylonStbd) elif Propulsion == 2: for ObjId in EngineStbd1: act.MirrorObjectXZ(ObjId) act.MirrorObjectXZ(PylonStbd1) for ObjId in EngineStbd2: act.MirrorObjectXZ(ObjId) act.MirrorObjectXZ(PylonStbd2) rs.DeleteObject(FSurf) rs.Redraw()
def draw_mesh( mesh, layer=None, clear_layer=False, show_faces=True, show_vertices=False, show_edges=False, show_wireframe=False, vertexcolor=None, edgecolor=None, wireframecolor=None, facecolor=None, ): """ Draw a mesh object in Rhino. Parameters: mesh (compas.datastructures.mesh.Mesh): The mesh object. layer (str): Optional. The layer to draw in. Default is ``None``. clear_layer (bool): Optional. Clear the drawing layer. Default is ``True``. show_faces (bool): Optional. Show the faces. Default is ``True``. show_vertices (bool): Optional. Show the vertices. Default is ``True``. show_edges (bool): Optional. Show the edges. Default is ``True``. vertexcolor (str, tuple, list, dict): Optional. The vertex color specification. Default is ``None``. edgecolor (str, tuple, list, dict): Optional. The edge color specification. Default is ``None``. facecolor (str, tuple, list, dict): Optional. The face color specification. Default is ``None``. redraw (bool): Optional. Redraw instructions. Default is ``True``. Note: Colors can be specifiedin different ways: * str: A hexadecimal color that will be applied to all elements subject to the specification. * tuple, list: RGB color that will be applied to all elements subject to the specification. * dict: RGB or hex color dict with a specification for some or all of the related elements. Important: RGB colors should specify color values between 0 and 255. """ vertexcolor = color_to_colordict(vertexcolor, mesh.vertices(), default=mesh.attributes['color.vertex'], colorformat='rgb', normalize=False) edgecolor = color_to_colordict(edgecolor, mesh.edges(), default=mesh.attributes['color.edge'], colorformat='rgb', normalize=False) # facecolor = color_to_colordict(facecolor, # mesh.faces(), # default=mesh.attributes['color.face'], # colorformat='rgb', # normalize=False) 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) if show_faces: key_index = {key: index for index, key in enumerate(mesh.vertices())} xyz = [mesh.vertex_coordinates(key) for key in mesh.vertices()] faces = [] color = mesh.attributes['color.face'] for fkey in mesh.face: face = mesh.face_vertices(fkey, ordered=True) v = len(face) if v < 3: print('Degenerate face: {0} => {1}'.format(fkey, face)) elif v == 3: faces.append([key_index[k] for k in face + [face[-1]]]) elif v == 4: faces.append([key_index[k] for k in face]) else: c = len(xyz) xyz.append(mesh.face_center(fkey)) for i in range(-1, len(face) - 1): key = face[i] nbr = face[i + 1] vertices = [ c, key_index[key], key_index[nbr], key_index[nbr] ] faces.append(vertices) compas_rhino.xdraw_mesh(xyz, faces, color, '{0}.mesh'.format(mesh.attributes['name']), layer=layer, clear=False, redraw=False) if show_edges: lines = [] color = mesh.attributes['color.edge'] for u, v in mesh.edges(): lines.append({ 'start': mesh.vertex_coordinates(u), 'end': mesh.vertex_coordinates(v), 'name': '{0}.edge.{1}-{2}'.format(mesh.attributes['name'], repr(u), repr(v)), 'color': edgecolor.get((u, v), color), }) compas_rhino.xdraw_lines(lines, layer=layer, clear=False, redraw=False) if show_wireframe: lines = [] color = mesh.attributes['color.edge'] for u, v in mesh.wireframe(): lines.append({ 'start': mesh.vertex_coordinates(u), 'end': mesh.vertex_coordinates(v), 'name': '{0}.edge.{1}-{2}'.format(mesh.attributes['name'], repr(u), repr(v)), 'color': edgecolor.get((u, v), color), }) compas_rhino.xdraw_lines(lines, layer=layer, clear=False, redraw=False) if show_vertices: points = [] color = mesh.attributes['color.vertex'] for key in mesh.vertices(): points.append({ 'pos': mesh.vertex_coordinates(key), 'name': '{0}.vertex.{1}'.format(mesh.attributes['name'], repr(key)), 'color': vertexcolor.get(key, color), }) compas_rhino.xdraw_points(points, layer=layer, clear=False, redraw=False) rs.EnableRedraw() rs.Redraw()
def rc_plot_volumes(use_epsilon): #get sticky default_thickness = sticky["defaultThickness"] if sticky.has_key( "defaultThickness") else 5.5 go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep opt_thickness = Rhino.Input.Custom.OptionDouble(default_thickness, 0.2, 1000) opt_sections = Rhino.Input.Custom.OptionToggle(False, "No", "Yes") opt_inplace = Rhino.Input.Custom.OptionToggle(False, "No", "Yes") opt_heights = Rhino.Input.Custom.OptionToggle(False, "No", "Yes") go.SetCommandPrompt("Select breps to extract plan cuts") go.AddOptionDouble("Thickness", opt_thickness) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1, 0) #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: # print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break rs.EnableRedraw(False) global THICKNESS THICKNESS = opt_thickness.CurrentValue global LCUT_INDICES LCUT_INDICES = wla.get_lcut_layers() #Get brep representations of objects brep_geo_list = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() brep_geo_list.append(b_obj.Geometry) #...brep conversion may be necessary new_brep_list = [] for i, geo in enumerate(brep_geo_list): if geo.GetType() != Rhino.Geometry.Brep: new_brep_list.append(wru.extrusion_to_brep(geo)) else: new_brep_list.append(geo) #set base for output. xbase = 0 ybase = 0 #set the amount to move up from the bottom of the brep for cutting the lower outline. #this should be replaced by a projection of the bottom face of the brep. epsilon = D_TOL * 2 select_items = [] for i, brep in enumerate(new_brep_list): #get label prefix and bounding dims for this brep bdims = wge.get_bounding_dims(brep) baseplane = rs.MovePlane(rs.WorldXYPlane(), [xbase, ybase, 0]) label_letter = wut.number_to_letter(i) label_prefix = label_letter + "-" #prepare heights and labels for each section cut num_sections = 1 remaining_thickness = 0 cuts_at = [epsilon] if use_epsilon else [0] brep_label = label_letter section_labels = [label_letter] num_sections, remaining_thickness, cuts_at = get_section_division( bdims.Z, THICKNESS) if use_epsilon: cuts_at[0] = epsilon brep_label = label_letter + " r: " + str(round(remaining_thickness, 2)) section_labels = [label_prefix + str(i) for i in xrange(len(cuts_at))] #get section information for each cut section_planes = get_brep_section_planes(brep, cuts_at) #get lowest curve info section_curves, section_dims = [[], []] for i, plane in enumerate(section_planes): curve, dims = [0, 0] if (not use_epsilon) and (i == 0): curve, dims = get_lowest_curve_info(brep, D_TOL * 2) else: curve, dims = get_section_curve_info_multi_no_ortho( brep, plane) section_curves.append(curve) section_dims.append(dims) ##DO WORK HERE## drawing_planes = get_drawing_planes(section_dims, baseplane, GAP_SIZE) #place curves in drawing location for sp, dp, sc in zip(section_planes, drawing_planes, section_curves): t = Rhino.Geometry.Transform.ChangeBasis(dp, sp) for c in sc: c.Transform(t) #THIS IS STILL A MESS: LABEL ADDING #draw curves and add text dots top_label_pt = get_brep_label_pt(brep) brep_textdot = rs.AddTextDot(brep_label, top_label_pt) rs.ObjectLayer(brep_textdot, "XXX_LCUT_00-GUIDES") label_pts = [] for sc, label in zip(section_curves, section_labels): temp_area = 0 for i, c in enumerate(sc): crv = wru.add_curve_to_layer(c, LCUT_INDICES[1]) select_items.append(crv) if i == 0: label_pts.append(rs.CurveAreaCentroid(crv)[0]) temp_area = rs.CurveArea(crv) else: if rs.CurveArea(crv) > temp_area: label_pts[-1] = rs.CurveAreaCentroid(crv)[0] temp_area = rs.CurveArea(crv) fab_tags = wfa.add_fab_tags(label_pts, section_labels, TEXTSIZE) for tag in fab_tags: rs.ObjectLayer(tag, "XXX_LCUT_02-SCORE") group_name = rs.AddGroup() rs.AddObjectsToGroup(tag, group_name) ybase += max([s.Y for s in section_dims]) + GAP_SIZE * 1 for tag in fab_tags: select_items.extend(tag) #THIS IS STILL A MESS: LABEL ADDING sticky["defaultThickness"] = THICKNESS rs.UnselectAllObjects() rs.SelectObjects(select_items) rs.Redraw() rs.EnableRedraw(True)
def TurbofanNacelle(EngineSection, Chord, CentreLocation=[0, 0, 0], ScarfAngle=3, HighlightRadius=1.45, MeanNacelleLength=5.67): # The defaults yield a nacelle similar to that of an RR Trent 1000 / GEnx HighlightDepth = 0.12 * MeanNacelleLength SectionNo = 100 # Draw the nacelle with the centre of the intake highlight circle in 0,0,0 rs.EnableRedraw(False) Highlight = rs.AddCircle3Pt((0, 0, HighlightRadius), (0, -HighlightRadius, 0), (0, 0, -HighlightRadius)) HighlightCutterCircle = rs.AddCircle3Pt((0, 0, HighlightRadius * 1.5), (0, -HighlightRadius * 1.5, 0), (0, 0, -HighlightRadius * 1.5)) # Fan disk for CFD boundary conditions FanCircle = rs.CopyObject(Highlight, (MeanNacelleLength * 0.25, 0, 0)) FanDisk = rs.AddPlanarSrf(FanCircle) # Aft outflow for CFD boundary conditions BypassCircle = rs.CopyObject(Highlight, (MeanNacelleLength * 0.85, 0, 0)) BypassDisk = rs.AddPlanarSrf(BypassCircle) rs.DeleteObjects([FanCircle, BypassCircle]) # Outflow cone TailConeBasePoint = [MeanNacelleLength * 0.84, 0, 0] TailConeApex = [MeanNacelleLength * 1.35, 0, 0] TailConeRadius = HighlightRadius * 0.782 TailCone = rs.AddCone(TailConeBasePoint, TailConeApex, TailConeRadius) # Spinner cone SpinnerConeBasePoint = [MeanNacelleLength * 0.26, 0, 0] SpinnerConeApex = [MeanNacelleLength * 0.08, 0, 0] SpinnerConeRadius = MeanNacelleLength * 0.09 Spinner = rs.AddCone(SpinnerConeBasePoint, SpinnerConeApex, SpinnerConeRadius) # Tilt the intake RotVec = rs.VectorCreate((0, 0, 0), (0, 1, 0)) Highlight = rs.RotateObject(Highlight, (0, 0, 0), ScarfAngle, axis=RotVec) # Set up the disk for separating the intake lip later HighlightCutterCircle = rs.RotateObject(HighlightCutterCircle, (0, 0, 0), ScarfAngle, axis=RotVec) HighlightCutterDisk = rs.AddPlanarSrf(HighlightCutterCircle) rs.DeleteObject(HighlightCutterCircle) rs.MoveObject(HighlightCutterDisk, (HighlightDepth, 0, 0)) # Build the actual airfoil sections to define the nacelle HighlightPointVector = rs.DivideCurve(Highlight, SectionNo) Sections = [] TailPoints = [] Rotation = 0 Twist = 0 AirfoilSeligName = 'goe613' SmoothingPasses = 1 for HighlightPoint in HighlightPointVector: ChordLength = MeanNacelleLength - HighlightPoint.X Af = primitives.Airfoil(HighlightPoint, ChordLength, Rotation, Twist, airconics_setup.SeligPath) AfCurve, Chrd = primitives.Airfoil.AddAirfoilFromSeligFile( Af, AirfoilSeligName, SmoothingPasses) rs.DeleteObject(Chrd) P = rs.CurveEndPoint(AfCurve) list.append(TailPoints, P) AfCurve = act.AddTEtoOpenAirfoil(AfCurve) list.append(Sections, AfCurve) Rotation = Rotation + 360.0 / SectionNo list.append(TailPoints, TailPoints[0]) # Build the actual nacelle OML surface EndCircle = rs.AddInterpCurve(TailPoints) Nacelle = rs.AddSweep2([Highlight, EndCircle], Sections, closed=True) # Separate the lip Cowling, HighlightSection = rs.SplitBrep(Nacelle, HighlightCutterDisk, True) # Now build the pylon between the engine and the specified chord on the wing CP1 = [ MeanNacelleLength * 0.26 + CentreLocation[0], CentreLocation[1], CentreLocation[2] + HighlightRadius * 0.1 ] CP2 = [ MeanNacelleLength * 0.4 + CentreLocation[0], CentreLocation[1], HighlightRadius * 1.45 + CentreLocation[2] ] CP3 = rs.CurveEndPoint(Chord) rs.ReverseCurve(Chord) CP4 = rs.CurveEndPoint(Chord) # Move the engine into its actual place on the wing rs.MoveObjects( [HighlightSection, Cowling, FanDisk, BypassDisk, TailCone, Spinner], CentreLocation) # Pylon wireframe PylonTop = rs.AddInterpCurve([CP1, CP2, CP3, CP4]) PylonAf = primitives.Airfoil(CP1, MeanNacelleLength * 1.35, 90, 0, airconics_setup.SeligPath) PylonAfCurve, PylonChord = primitives.Airfoil.AddNACA4( PylonAf, 0, 0, 12, 3) LowerTE = rs.CurveEndPoint(PylonChord) PylonTE = rs.AddLine(LowerTE, CP4) # Create the actual pylon surface PylonLeft = rs.AddNetworkSrf([PylonTop, PylonAfCurve, PylonTE]) rs.MoveObject(PylonLeft, (0, -CentreLocation[1], 0)) PylonRight = act.MirrorObjectXZ(PylonLeft) rs.MoveObject(PylonLeft, (0, CentreLocation[1], 0)) rs.MoveObject(PylonRight, (0, CentreLocation[1], 0)) PylonAfCurve = act.AddTEtoOpenAirfoil(PylonAfCurve) PylonAfSrf = rs.AddPlanarSrf(PylonAfCurve) # Assigning basic surface properties act.AssignMaterial(Cowling, "ShinyBABlueMetal") act.AssignMaterial(HighlightSection, "UnpaintedMetal") act.AssignMaterial(TailCone, "UnpaintedMetal") act.AssignMaterial(FanDisk, "FanDisk") act.AssignMaterial(Spinner, "ShinyBlack") act.AssignMaterial(BypassDisk, "FanDisk") act.AssignMaterial(PylonLeft, "White_composite_external") act.AssignMaterial(PylonRight, "White_composite_external") # Clean-up rs.DeleteObject(HighlightCutterDisk) rs.DeleteObjects(Sections) rs.DeleteObject(EndCircle) rs.DeleteObject(Highlight) rs.DeleteObjects([PylonTop, PylonAfCurve, PylonChord, PylonTE]) rs.Redraw() TFEngine = [ Cowling, HighlightSection, TailCone, FanDisk, Spinner, BypassDisk ] TFPylon = [PylonLeft, PylonRight, PylonAfSrf] return TFEngine, TFPylon
#Python Workshop Lesson:06 #http://designalyze.com/int2pythonscripting06_nestedloops-functions #Nested For Loops #color points import rhinoscriptsyntax as rs def createColoredPoint(x, y, z, r, g, b): currentColor = [r, g, b] pt = rs.AddPoint(x, y, z) rs.ObjectColor(pt, currentColor) rs.EnableRedraw(False) step = 10 for x in range(0, 256, step): for y in range(0, 256, step): for z in range(0, 256, step): createColoredPoint(x, y, z, x, y, z) rs.Redraw()
def rc_unroll_ortho(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_thickness = sticky["thickness"] if sticky.has_key( "thickness") else 5.5 default_lid = sticky["lid"] if sticky.has_key("lid") else False opt_thickness = Rhino.Input.Custom.OptionDouble(default_thickness, 0.2, 1000) opt_lid = Rhino.Input.Custom.OptionToggle(default_lid, "No", "Yes") go.SetCommandPrompt( "Select breps to unroll. Breps must be orthogonal (faces at 90 degree angles)" ) go.AddOptionDouble("Thickness", opt_thickness) go.AddOptionToggle("Lids", opt_lid) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1, 0) #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: #print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break rs.EnableRedraw(False) LID = opt_lid.CurrentValue THICKNESS = opt_thickness.CurrentValue global LCUT_INDICES LCUT_INDICES = wla.get_lcut_layers() #Get geometry and object lists brep_obj_list = [] brep_geo_list = [] brep_ids_list = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() brep_obj_list.append(b_obj) #For Debug and reference... #brep_geo_list.append(b_obj.Geometry) #brep_ids_list.append(b_obj.Id) #get information for each piece to be output. #future implementation should use bounding dims and curves rather than dimension-based system. unrolled_brep_info = [] lid_info = [] SELECT_GUIDS = [] for i, obj in enumerate(brep_obj_list): #geometry prep: convert extrusions to breps if str(obj.ObjectType) != "Brep": new_brep = wru.extrusion_to_brep(obj.Geometry) else: new_brep = obj.Geometry #pull the brep sides info for this solid this_brep_side_info = get_brep_sides_info(new_brep, THICKNESS) unrolled_brep_info.append(this_brep_side_info) num_sides = len(this_brep_side_info.dims) #pull the lid info for this solid if LID == True: this_brep_lid_info = get_brep_lid_info(new_brep, num_sides, THICKNESS) lid_info.append(this_brep_lid_info) #get dims needed to place this solid's outline curves brep_output_bounding_heights = [] for i, brep_side_info in enumerate(unrolled_brep_info): if LID == True: brep_output_bounding_heights.append( max(brep_side_info.boundingDims.y, lid_info[i].dims.y) ) #lid info needs to become a named tuple as well. else: brep_output_bounding_heights.append(brep_side_info.boundingDims.y) ybase = 0 #each solid for i, brep_side_info in enumerate(unrolled_brep_info): top_label_text = wut.number_to_letter(i) prefix = top_label_text + "-" xbase = 0 #each piece for j, piecedims in enumerate(brep_side_info.dims): face_label = prefix + str(brep_side_info.labelNums[j]) rect = rs.AddRectangle([xbase, ybase, 0], piecedims.x, piecedims.y) dot = rs.AddTextDot(face_label, rs.CurveAreaCentroid(rect)[0]) rs.ObjectLayer(dot, "XXX_LCUT_00-GUIDES") rs.ObjectLayer(rect, "XXX_LCUT_01-CUT") SELECT_GUIDS.extend([rect, dot]) xbase += piecedims[0] + GAP_SIZE #add the lids if LID == True: #transform the lid curve to the basepoint lid_curve = lid_info[i].outline p1 = rs.WorldXYPlane() p2 = rs.PlaneFromNormal([xbase, ybase, 0], [0, 0, 1], [1, 0, 0]) orient = Rhino.Geometry.Transform.ChangeBasis( rs.coerceplane(p2), rs.coerceplane(p1)) lid_curve.Transform(orient) #add the curve to the document crv_1 = wru.add_curve_to_layer(lid_curve, LCUT_INDICES[1]) crv_2 = rs.CopyObject( crv_1, [lid_info[i].dims.x + GAP_SIZE, 0, 0 ]) #change this to use a transform; it's nasty. #add text dot face_label_1 = prefix + str(len(brep_side_info.dims)) face_label_2 = prefix + str(len(brep_side_info.dims) + 1) dot_1 = rs.AddTextDot(face_label_1, rs.CurveAreaCentroid(crv_1)[0]) dot_2 = rs.AddTextDot(face_label_2, rs.CurveAreaCentroid(crv_2)[0]) rs.ObjectLayer([dot_1, dot_2], "XXX_LCUT_00-GUIDES") SELECT_GUIDS.extend([crv_1, crv_2, dot_1, dot_2]) top_label = rs.AddTextDot(top_label_text, brep_side_info.topLabelPt) rs.ObjectLayer(top_label, "XXX_LCUT_00-GUIDES") ybase += brep_output_bounding_heights[i] + GAP_SIZE * 4 sticky["thickness"] = THICKNESS sticky["lid"] = LID rs.UnselectAllObjects() rs.SelectObjects(SELECT_GUIDS) rs.Redraw() rs.EnableRedraw(True)
def redraw(): rs.EnableRedraw(True) rs.Redraw()
def redraw(self, timeout=None): """Redraw the Rhino view.""" if timeout: time.sleep(timeout) rs.EnableRedraw(True) rs.Redraw()
def rc_plot_volumes(use_epsilon): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep default_inplaceBool = sticky["inplaceBool"] if sticky.has_key( "inplaceBool") else False default_heightsBool = sticky["heightsBool"] if sticky.has_key( "heightsBool") else False opt_inplace = Rhino.Input.Custom.OptionToggle(default_inplaceBool, "No", "Yes") opt_heights = Rhino.Input.Custom.OptionToggle(default_heightsBool, "No", "Yes") go.SetCommandPrompt("Select breps to extract plan cuts") go.AddOptionToggle("InPlace", opt_inplace) go.AddOptionToggle("PrintPieceHeights", opt_heights) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.EnableUnselectObjectsOnExit(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1, 0) #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: # print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break rs.EnableRedraw(False) DIRPT1 = rs.coerce3dpoint([0, 0, 0]) DIRPT2 = rs.coerce3dpoint([1, 0.001, 0]) global BOOL_HEIGHTS global LCUT_INDICES global SORTDIR BOOL_HEIGHTS = opt_heights.CurrentValue LCUT_INDICES = wla.get_lcut_layers() SORTDIR = DIRPT2 - DIRPT1 #Get boolean for "inplace" INPLACE = opt_inplace.CurrentValue #Get brep representations of objects brep_geo_list = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() brep_geo_list.append(b_obj.Geometry) #...brep conversion may be necessary new_brep_list = [] for i, geo in enumerate(brep_geo_list): if geo.GetType() != Rhino.Geometry.Brep: new_brep_list.append(wru.extrusion_to_brep(geo)) else: new_brep_list.append(geo) #set base for output. xbase = 0 ybase = 0 #set the amount to move up from the bottom of the brep for cutting the lower outline. #this should be replaced by a projection of the bottom face of the brep. epsilon = D_TOL * 2 select_items = [] centroids = [ c.GetBoundingBox(rs.WorldXYPlane()).Center for c in new_brep_list ] brep_collection = zip(centroids, new_brep_list) brep_collection = sorted(brep_collection, sortcompare) _, new_brep_list = zip(*brep_collection) for i, brep in enumerate(new_brep_list): #get lowest curve info #get label prefix and bounding dims for this brep bdims = wge.get_bounding_dims(brep) baseplane = rs.MovePlane(rs.WorldXYPlane(), [xbase, ybase, 0]) label_letter = wut.number_to_letter(i) #prepare heights and labels for each section cut num_sections = 1 remaining_thickness = 0 cuts_at = [epsilon] if use_epsilon else [0] brep_label = label_letter section_labels = [label_letter] if BOOL_HEIGHTS == True: section_labels = [ label + "\n" + str(round(bdims.Z, 1)) for label in section_labels ] #get section information for each cut section_planes = get_brep_section_planes(brep, cuts_at) section_curves, section_dims = [[], []] for i, plane in enumerate(section_planes): curve, dims = [0, 0] if (not use_epsilon) and (i == 0): curve, dims = get_lowest_curve_info(brep, D_TOL * 2) else: curve, dims = get_section_curve_info_multi_no_ortho( brep, plane) section_curves.append(curve) section_dims.append(dims) ##DO WORK HERE## drawing_planes = get_drawing_planes(section_dims, baseplane, GAP_SIZE) #place curves in drawing location for sp, dp, sc in zip(section_planes, drawing_planes, section_curves): if INPLACE == True: t = Rhino.Geometry.Transform.Translation(0, 0, 0) else: t = Rhino.Geometry.Transform.ChangeBasis(dp, sp) for c in sc: c.Transform(t) #THIS IS STILL A MESS: LABEL ADDING #draw curves and add text dots top_label_pt = get_brep_label_pt(brep) brep_textdot = rs.AddTextDot(brep_label, top_label_pt) rs.ObjectLayer(brep_textdot, "XXX_LCUT_00-GUIDES") label_pts = [] for sc, label in zip(section_curves, section_labels): for i, c in enumerate(sc): crv = wru.add_curve_to_layer(c, LCUT_INDICES[1]) select_items.append(crv) if i == 0: label_pts.append(rs.CurveAreaCentroid(crv)[0]) fab_tags = wfa.add_fab_tags(label_pts, section_labels, TEXTSIZE) for tag in fab_tags: rs.ObjectLayer(tag, "XXX_LCUT_02-SCORE") group_name = rs.AddGroup() rs.AddObjectsToGroup(tag, group_name) ybase += max([s.Y for s in section_dims]) + GAP_SIZE * 1 for tag in fab_tags: select_items.extend(tag) sticky["inplaceBool"] = INPLACE sticky["heightsBool"] = BOOL_HEIGHTS rs.UnselectAllObjects() rs.SelectObjects(select_items) rs.Redraw() rs.EnableRedraw(True)