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
