def show_only(layer): rs.LayerVisible("Default", True) rs.CurrentLayer("Default") for sub in rs.LayerNames(): if sub == "Default": continue if sub in conf['blocks']: rs.LayerVisible(sub, True) continue rs.LayerVisible(sub, False) for block in conf['blocks']: for blockchild in rs.LayerChildren(block): rs.LayerVisible(blockchild, True) # show parent layers, if nested (two up, max) p_layer = rs.ParentLayer(layer) if p_layer: pp_layer = rs.ParentLayer(p_layer) if pp_layer: rs.LayerVisible(pp_layer, True) rs.LayerVisible(p_layer, True) # show the target layer rs.LayerVisible(layer, True) rs.CurrentLayer(layer) rs.LayerVisible("Default", False)
def isolateLayer(self, layerName): names = rs.LayerNames() for n in names: if n == layerName: layers = rs.LayerVisible(layerName, True) else: rs.LayerVisible(n, False)
def pre_process(): # delete all previous user text all_objs = rs.AllObjects() for obj in all_objs: rh_obj = rs.coercerhinoobject(obj) rh_obj.Attributes.DeleteAllUserStrings() # remove all blocks for block in rs.BlockNames(): rs.DeleteBlock(block) # set current layer rs.CurrentLayer(relevant_layers_dict["buildings"]) # remove redundant layers for layer_name in rs.LayerNames(): if layer_name not in relevant_layers_dict.values(): rs.PurgeLayer(layer_name) # get all objects in building layer building_objs = rs.ObjectsByLayer(relevant_layers_dict["buildings"]) for building_obj in building_objs: if rs.IsCurve(building_obj) and rs.IsCurveClosed(building_obj): # flatten curve to XY plane matrix = rs.XformPlanarProjection(rg.Plane.WorldXY) rs.TransformObject(building_obj, matrix, copy=False) # delete all object with a surface grater or smaller from MIN_BUILDING_AREA_SQ by TOLERANCE or just smaller than MIN_BUILDING_AREA_SQ TOLERANCE = 2 if rs.CurveArea(building_obj)[0] < MIN_BUILDING_AREA_SQM or abs( rs.CurveArea(building_obj)[0] - MIN_BUILDING_AREA_SQM) < TOLERANCE: rs.DeleteObject(building_obj)
def CopyObjectsToLayer(): "Copy selected objects to a different layer" # Get the objects to copy objectIds = rs.GetObjects("Select objects") # Get all layer names layerNames = rs.LayerNames() if (objectIds == None or layerNames == None): return # Make sure select objects are unselected rs.UnselectObjects(objectIds) layerNames.sort() # Get the destination layer layer = rs.ComboListBox(layerNames, "Destination Layer <" + rs.CurrentLayer() + ">") if layer: # Add the new layer if necessary if (not rs.IsLayer(layer)): rs.AddLayer(layer) # Copy the objects newObjectIds = rs.CopyObjects(objectIds) # Set the layer of the copied objects [rs.ObjectLayer(id, layer) for id in newObjectIds] # Select the newly copied objects rs.SelectObjects(newObjectIds)
def Export(): count = 0 folder = ChooseFolderPath() layer_names = rs.LayerNames() newDefaultLayer = 'NewDefault' rs.AddLayer(newDefaultLayer) rs.CurrentLayer(newDefaultLayer) for l in layer_names: if l != newDefaultLayer: for t in layer_names: if rs.IsLayer(l): if l != newDefaultLayer: rs.LayerVisible(t, False) else: print "The layer does not exist." rs.LayerVisible(l, True) if rs.CurrentLayer() == l: break """answer = rs.MessageBox("Continue?", 1 | 32) if answer is 2: break rs.Sleep(1000)""" Render(folder, count) count += 1 rs.LayerVisible(l, False) for l in layer_names: if l != newDefaultLayer: rs.LayerVisible(l, False) rs.CurrentLayer(l) rs.DeleteLayer(newDefaultLayer)
def isolateLayer(layerName): names=rs.LayerNames() rs.CurrentLayer('Default') for n in names: if n=='Default':continue if n==layerName: layers=rs.LayerVisible(layerName,True) else:rs.LayerVisible(n,False)
def getLayers(include=False, exclude=False): """ Help on function getLayers in module getLayerList: getLayers(include, exclude) Get list of layers that begin with regex L/d. Parameters: include = List of layers to linclude that do not begin with regex L/d exclude = List of layers to exclude from children search Returns: list of layers """ docLayers = list( filter(lambda x: not rs.IsLayerReference(x), rs.LayerNames())) layerSplit = [d.split("::") for d in docLayers] returnList = [] nestWarning = 0 # dummy patterns includePattern = re.compile(r"SECTION$") excludePattern = re.compile(r"______________") if include: includePattern = re.compile(r"|".join(include)) if exclude: excludePattern = re.compile(r"|".join(exclude)) for entry in layerSplit: l_i = [ i for i, item in enumerate(entry) if (re.search("^L\d", item) or re.search("^P\d", item) or includePattern.search(item)) ] # Apply exclude pattern exclude = 0 for item in entry: if excludePattern.search(item): exclude = 1 # if the position of the match is at the end of the list, then include it in the return list if (len(l_i) > 1) and nestWarning == 0: print( "Nested L# layers detected. Script will only return layer highest in the heirarchy." ) nestWarning = 1 try: if not exclude and (l_i[0] + 1) == len(entry): returnList.append("::".join(entry)) except: pass return (returnList)
def RunCommand( is_interactive ): rs.AddLayer("_t") rs.CurrentLayer("_t") layers = rs.LayerNames() for layer in layers: if not rs.IsLayerVisible(layer): rs.LayerVisible(layer,True) return 0
def isolateLayer(self, layerName): names = rs.LayerNames() rs.CurrentLayer('Default') for n in names: if n == 'Default': continue if n == get_layer_name('LOCKEDLAYERS'): rs.LayerVisible(layerName, True) continue if n == layerName: layers = rs.LayerVisible(layerName, True) else: rs.LayerVisible(n, False)
def get_sisu_layers(config, derived_only=False): rhino_layer_names = rs.LayerNames() if not isinstance(config, SisuConfig): config = SisuConfig(config) layers = config.get_layers(derived_only) names = [] for layer in layers: if layer in rhino_layer_names: names.append(layer) return names
def RunCommand(is_interactive): # this script can turn off layers of your selected object rs.AddLayer("_t") rs.CurrentLayer("_t") layers = rs.LayerNames() for layer in layers: if rs.IsLayerLocked(layer): rs.LayerLocked(layer, False) return 0
def meshing(meshValue, directory): #meshValue = '0.5 ' os.chdir(directory) #meshcommands angle = ' _angle=0' aspectratio = ' _aspectratio=0' distance = ' _distance=0' grid = ' _grid=0' maxedgelength = ' _maxedgelength=' + meshValue maxedgelengthstr = maxedgelength minedgelength = ' _minedgelength=' + meshValue minedgelengthstr = minedgelength advOptions = angle + aspectratio + distance + grid + maxedgelengthstr + minedgelengthstr #gsurfcommands mode = '_mode=tri' minedgelength = '_minedgelength=' + meshValue maxedgelength = '_maxedgelength=' + meshValue ridgeangle = '_ridgeangle=20' maxgradation = '_maxgradation=1' deleteinput = '_deleteinput=Yes' gsurfOptions = mode + minedgelength + maxedgelength + ridgeangle + maxgradation + deleteinput #gvol options gvol_mode = '_mode=tet ' outputformat = '_outputformat=3DEC ' gvolOptions = gvol_mode + outputformat rs.Command("-_SelNone ") layers = rs.LayerNames() for layer in layers: if layer == 'concrete': rs.Command("-_SelLayer " + layer) #rs.Command("_Enter") rs.Command("Invert ") rs.Command("Hide Enter") rs.Command("-_SelLayer " + layer) rs.Command("-_Mesh _DetailedOptions _AdvancedOptions " + advOptions + '_Enter _Enter') rs.Command("-_SelNone ") rs.Command("-_SelMesh ") rs.Command("-_Gsurf " + gsurfOptions + '_Enter _Enter') rs.Command("-_SelMesh") rs.Command("-_Gvol " + gvolOptions + '_Enter _Enter') return True
def _clear_layers(cls): ## clear only user layers """Deletes all layers. Leaves Default layer """ default_layer_name = s.Settings.default_layer_name layer_names = rs.LayerNames() if not default_layer_name in layer_names: rs.AddLayer(default_layer_name) rs.CurrentLayer(default_layer_name) for layer_name in layer_names: if not layer_name == default_layer_name: value = rs.DeleteLayer(layer_name) print('Cleared layer %s: %s' % (layer_name, value))
def layerNames(): layersL = rs.LayerNames() parentLayers = [] subLayers1 = [] subLayers2 = [] for layer in layersL: if layer.count("::") == 0: parentLayers.append(layer) elif layer.count("::") == 1: subLayers1.append(layer.split("::")[-1]) elif layer.count("::") == 2: subLayers2.append(layer.split("::")[-1]) return [parentLayers, subLayers1, subLayers2]
def RemoveMasterRootLayer(masterRoot): rs.EnableRedraw(False) subRoots = [] allLayers = rs.LayerNames() for each in allLayers: if rs.ParentLayer(each) == masterRoot: subRoots.append(each) for eachLayer in subRoots: rs.ParentLayer(eachLayer, '') rs.DeleteLayer(masterRoot) rs.EnableRedraw(True)
def ExportLayersStructure(): """Save layers settings to a json file.""" file_name = rs.SaveFileName( "Save", "Text Files (*.json)|*.json|All Files (*.*)|*.*||") if not file_name: return layers_properties = { rs.LayerName(l): get_layer_properties(l) for l in rs.LayerNames() } with open(file_name, "w+") as f: f.write(json.dumps(layers_properties, sort_keys=True, indent=4))
def main(): rs.EnableRedraw(enable=False) notes = sc.doc.Notes if notes: variables = notes.split("\r") vardict = {} for variable in variables: var = variable.split("=") var = list([x.strip() for x in var]) vardict[var[0]] = var[1] allLayers = rs.LayerNames() topList = [] for layer in allLayers: if rs.LayerChildCount(layer) > 0: if re.search("::", layer): layer = layer.split("::")[0] if re.search("^L\d", layer) or re.search( "^R\d", layer) or re.search("^M\d", layer) or re.search( "^P\d", layer) or re.search("^SECTION ", layer) or re.search( "^ROOFPLAN", layer) or re.search("^SOLIDS", layer): topList.append(layer) topList = sorted(list(set(topList))) thisLayer = rs.CurrentLayer() topList.append("TURN ALL ON") destinationLayer = rs.ListBox(topList, "Layer To Activate") if not destinationLayer: print("No Layer Selected") return None elif destinationLayer == "TURN ALL ON": topList.remove(destinationLayer) for layer in topList: sc.doc = Rhino.RhinoDoc.ActiveDoc rs.LayerVisible(layer, True) rs.ExpandLayer(layer, False) else: topList.remove("TURN ALL ON") topList.remove(destinationLayer) rs.CurrentLayer(layer=destinationLayer) rs.ExpandLayer(destinationLayer, True) for layer in topList: sc.doc = Rhino.RhinoDoc.ActiveDoc rs.LayerVisible(layer, False) rs.ExpandLayer(layer, False) print(destinationLayer) rs.EnableRedraw(enable=True)
def get_all(self): """Returns a list of all layers as GiraffeLayer objects.""" layer_names = rs.LayerNames() layers = [] for layer_name in layer_names: layer = GiraffeLayer(layer_name) layers.append(layer) return layers
def _get_element_layers(cls): ## done 08-07 """Returns: initial_shapes [str, ...]. A list of the names of layers containing one frame instance rules [str, ...]. A list of the names of layers containing two frame instances """ initial_shapes, rules = [], [] layer_names = rs.LayerNames() for name in layer_names: if l.Layer.contains_initial_shape(name): initial_shapes.append(name) elif l.Layer.contains_rule(name): rules.append(name) return (initial_shapes, rules)
def removeTempLayer(_tmpLayerName): sc.doc = Rhino.RhinoDoc.ActiveDoc # Be sure the temp layer exists? if _tmpLayerName in rs.LayerNames(): print "Removing Layer: '{}'".format(_tmpLayerName) tmpLayer = sc.doc.Layers.FindName(_tmpLayerName) sc.doc.Layers.Delete(tmpLayer) sc.doc = ghdoc
def PurgeAll(): ''' Delete all objects within document ''' rs.CurrentLayer('Default') for layer in rs.LayerNames(): if rs.IsLayer(layer) and layer != 'Default': rs.PurgeLayer(layer) objs = [] objTable = doc.Objects for obj in objTable.GetObjectList(Rhino.DocObjects.ObjectType.AnyObject): objs.append(obj.Id) for guid in objs: objTable.Delete(guid, True)
def NewPart(): """Create a 'New Part' layer as a sublayer of '30_3D'.""" input_obj = rs.SelectedObjects() layers = rs.LayerNames() if "30_3D" not in layers: rs.AddLayer("30_3D") for i in range(1, 30): new_layer = "30_3D::3{}_Part".format(i) if new_layer not in layers: rs.AddLayer("3{}_Part".format(i), parent="30_3D") if input_obj: rs.ObjectLayer(input_obj, new_layer) return
def get_labeled_shape_names(cls): """The grammar is guaranteed to be well-formed. Returns: labeled_shape_names [str, ...]. A list of the names of the labeled shapes in initial shapes or rules, i.e., name, name_L, or name_R """ labeled_shape_names = [] layer_names = rs.LayerNames() for layer_name in layer_names: if l.Layer.contains_initial_shape(layer_name): labeled_shape_names.append(layer_name) elif l.Layer.contains_rule(layer_name): left_name = "%s_L" % layer_name right_name = "%s_R" % layer_name labeled_shape_names.extend([left_name, right_name]) return labeled_shape_names
def setOutputLayerVis(_detailViewLayers=[], _udLayersOn=[]): # Turn all Layer Visibilities 'Off' except for the designeted layers sc.doc = Rhino.RhinoDoc.ActiveDoc layers = rs.LayerNames() allLayersOn = _detailViewLayers + _udLayersOn # All the Page's DetailView Layers, as well we as the User Determined 'On' allLayersOn.append(str(Rhino.RhinoDoc.ActiveDoc.Layers.CurrentLayer) ) # Add in the Current Active Layer print 'Turning on layers: {}'.format(allLayersOn) print '----' # Record the Starting State layerVisibilites = [] # True/False record (for resetting when done) for layer in layers: layerVisibilites.append(rs.LayerVisible(layer)) # Set layers 'off' if they aren't on the list to stay on for layer in layers: #if list(layer.Split(":"))[-1] not in allLayersOn: if layer in allLayersOn: rs.LayerVisible(layer, True) else: rs.LayerVisible(layer, False) Rhino.RhinoDoc.ActiveDoc.Views.RedrawEnabled = True Rhino.RhinoDoc.ActiveDoc.Views.Redraw() sc.doc = ghdoc return layerVisibilites
def exportLayers(directory, filename, filetype): success = True # adds slashes to directory if directory[-1] != "\\": directory += "\\" # iterates through layers layers = rs.LayerNames() for layer in layers: #if layer != 'concrete': # select layer rs.Command("-_SelLayer " + layer) #mesh so that you can have only simple planes rs.Command("-_Mesh DetailedOptions SimplePlane=Yes Enter") # make cmdstr, include layer if there are multiple layers if len(layers) > 1: path = "\"" + directory + filename + "_" + layer + filetype + "\"" else: path = "\"" + directory + filename + filetype + "\"" rs.Command("-_SelNone ") rs.Command("-_SelLayer " + layer) rs.Command("-_Invert ") rs.Command("Hide Enter") rs.Command("-_SelMesh ") cmdstr = "-_Export " + path if filetype == ".wrl": cmdstr += " Enter Enter" # execute command cmd = rs.Command(cmdstr) if not (cmd): success = False rs.Command("-_SelNone") rs.Command("Show ") return success
def IsolateLayers(): """Isolate layers by hiding layers.""" file_name = rs.DocumentName() file_path = rs.DocumentPath() # Select objects input_obj = rs.SelectedObjects() if not input_obj: input_obj = rs.GetObjects("Select objects on layers to isolate") if not input_obj: return # Get all layers names proj_layers = rs.LayerNames() layers_history = {rs.LayerId(l): rs.LayerVisible(l) for l in proj_layers} # Save temp if file_name is None: temp_file_name = "IsolateLayers_temp.json" else: temp_file_name = file_path + 'IsolateLayers_temp_' + file_name.strip( '.3dm') + '.json' with open(temp_file_name, "w+") as f: f.write(json.dumps(layers_history, sort_keys=True, indent=4)) # Get objects layers obj_layers = [rs.ObjectLayer(o) for o in input_obj] layers = [] for l in obj_layers: s = l.split('::') a = 0 while len(s) > a: layers.append("::".join(s[:a + 1])) a += 1 # Set current layer rs.CurrentLayer(layers[0]) # Hide layers layers_to_hide = list(set(proj_layers) - set(layers)) for l in layers_to_hide: rs.LayerVisible(l, False)
def get_all_structural(self): """Returns a list of all layers containing structural geometry GiraffeLayer objects.""" layer_names = rs.LayerNames() layers = [] for layer_name in layer_names: layer = GiraffeLayer(layer_name) if layer.is_structural(): layers.append(layer) # sort layers to make sure numbered nodes are added first and to maintain regular order layers.sort(key=lambda x: x.to_int()) return layers
def RunCommand(is_interactive): # this script can turn off layers of your selected object rs.AddLayer("_t") rs.CurrentLayer("_t") layers = rs.LayerNames() CurObjLayNames = [] CurObjs = rs.GetObjects("select objects to turn layers off") for CurObj in CurObjs: CurObjLayId = rs.ObjectLayer(CurObj) CurObjLayName = rs.LayerName(CurObjLayId, fullpath=True) CurObjLayNames.extend([CurObjLayName]) for layer in layers: if layer in CurObjLayNames and layer != "_t": rs.LayerVisible(layer, False) return 0
def get_objects(corePath): try: rs.UnselectAllObjects() # make 3D Printer layer invisible layerNames = rs.LayerNames() for layerName in layerNames: if layerName.find('MW 3D Printer') != -1: rs.LayerVisible(layerName, visible=False) objIds = rs.GetObjects(message='Please select Objects: ', select=True) run_saver(corePath) # save Object as STL except: print 'Could not select Objects' objIds = None return objIds
def RunCommand(is_interactive): load_system_hatch_patterns() config = get_sisufile() if not config: print('Sisufile not configured') return Rhino.Commands.Result.Failure codes = config['data'] mode_full = 'Full' mode_existing = 'Existing' mode_current = 'Current' modes = (mode_existing, mode_current, mode_full) user_options, status = get_sync_options(modes) if status != Rhino.Commands.Result.Success: return status add_layer_enabled = user_options['mode'] == mode_full layer_scope = [] if user_options['mode'] == mode_current: layer_scope = [rs.CurrentLayer()] else: layer_scope = rs.LayerNames() options = {} rs.EnableRedraw(False) for code in codes: layer_name, layer_options = code['layer'] layer_exists = rs.IsLayer(layer_name) valid_layer = (layer_name in layer_scope) or (not layer_exists and add_layer_enabled) if not valid_layer: continue try: sync_code(code, options) except Exception as e: print('failed to sync %s: %s' % (code['code'], e)) rs.EnableRedraw(True) sc.doc.Views.Redraw() return Rhino.Commands.Result.Success