def ImportObject(self, file): rs.Command("_-Insert _File=_Yes " + self.root + file + ".3dm B 0,0,0 1 0 _Enter") object = rs.SelectedObjects()[0] rs.UnselectAllObjects() object = rs.ExplodeBlockInstance(object)[0] return object
def explode(objs, li): for obj in objs: if rs.IsBlockInstance(obj): temp_objs = rs.ExplodeBlockInstance(obj) explode(temp_objs, li) else: li.append(obj) return li
def splitModel(objs, cutLevel): point = Rhino.Geometry.Point3d(0,0,cutLevel) belowDir = rs.AddLine(point, [0,0,-9999]) aboveDir = rs.AddLine(point, [0,0,9999]) circle = rs.AddCircle(point, 9999) circleSrf = rs.AddPlanarSrf(circle) aboveGroup = rs.AddGroup("Above") belowGroup = rs.AddGroup("Below") for obj in objs: ptBtm = rs.BoundingBox(obj)[0] ptTop = rs.BoundingBox(obj)[6] if ptBtm[2]>cutLevel: intersecting = False rs.AddObjectToGroup(obj, "Above") #print "Object Above" elif ptTop[2]<cutLevel: intersecting = False rs.AddObjectToGroup(obj, "Below") #print "Object Below" else: intersecting = True if intersecting: if rs.IsBrep(obj): closed = False if rs.IsPolysurfaceClosed(obj): closed = True try: copy = rs.CopyObject(obj) splitSrfs = rs.SplitBrep(obj, circleSrf, True) for splitSrf in splitSrfs: #print "looping" if closed: rs.CapPlanarHoles(splitSrf) rs.MatchObjectAttributes(splitSrf, copy) ptBtm = rs.BoundingBox(splitSrf)[0] ptTop = rs.BoundingBox(splitSrf)[6] mdPtZ = (ptBtm[2] + ptTop[2]) / 2 if mdPtZ>cutLevel: rs.AddObjectToGroup(splitSrf, "Above") else: rs.AddObjectToGroup(splitSrf, "Below") rs.DeleteObject(copy) rs.DeleteObject(obj) except: None if rs.IsBlockInstance(obj): contents = rs.ExplodeBlockInstance(obj) for content in contents: objs.append(content) rs.DeleteObject(belowDir) rs.DeleteObject(aboveDir) rs.DeleteObject(circle) rs.DeleteObject(circleSrf)
def SuperExplodeBlock(): try: blocks = rs.GetObjects("Select blocks to explode", rs.filter.instance, preselect=True) if blocks is None: return objs = [] for block in blocks: objs.append(rs.ExplodeBlockInstance(block, True)) return objs except: return None
def main(): for name in rs.BlockNames(): block = rs.InsertBlock(name, (0,0,0)) rs.UnselectAllObjects() # explodblock uids = rs.ExplodeBlockInstance(block) rs.SelectObjects(uids) rs.Command('! _-Export _Pause "E:\\TNM\\template\\tools\\' + name + '.3dm" _Enter')
def MakeBlockUnique(block, newName): """ Explodes a block and makes a new one with 'newName' """ xform = rs.BlockInstanceXform(block) insertPt = rs.BlockInstanceInsertPoint(block) objs = rs.ExplodeBlockInstance(block, False) rs.TransformObjects(objs, rs.XformInverse(xform)) pt = rs.TransformObject(insertPt, rs.XformInverse(xform)) rs.AddBlock(objs, insertPt, newName, True) newBlock = rs.InsertBlock2(newName, xform) rs.DeleteObject(pt) return newBlock
def main(): for name in rs.BlockNames(): block = rs.InsertBlock(name, (0, 0, 0)) rs.UnselectAllObjects() # explodblock uids = rs.ExplodeBlockInstance(block) rs.SelectObjects(uids) rs.Command( "_-Insert File=Yes LinkMode=Link E:\\TNM\\template\\tools\\" + name + ".3dm Block 0,0,0 1.0 0.0")
def addResultToBlock(obj, result): name = rs.BlockInstanceName(obj) i_point = rs.BlockInstanceInsertPoint(obj) xform = rs.BlockInstanceXform(obj) block_content = rs.ExplodeBlockInstance(obj) bc=[] for c in block_content: bc.append(c) bc.append(result) rs.AddBlock(bc, i_point, name, True) rs.InsertBlock2(name, xform)
def redefineBlockScale(block): block_name = rs.BlockInstanceName(block) # rs.RenameBlock (block_name, "{}-old".format(block_name)) blockXform = rs.BlockInstanceXform(block) plane = rs.PlaneTransform(rs.WorldXYPlane(), blockXform) cob = rs.XformChangeBasis(plane, rs.WorldXYPlane()) cob_inverse = rs.XformChangeBasis(rs.WorldXYPlane(), plane) refBlock = rs.TransformObjects(block, cob_inverse, True) exploded = rs.ExplodeBlockInstance(refBlock) rs.AddBlock(exploded, rs.WorldXYPlane().Origin, block_name, True) newBlock = rs.InsertBlock2(block_name, cob) copySourceLayer(newBlock, block) try: copySourceData(newBlock, block) except: pass rs.DeleteObjects(block)
def explode(objs, li): for obj in objs: if rs.IsBlockInstance(obj): # DIRTY FIX FOR RHINO 5-SR14 522.8390 (5-22-2017) temp_objs = rs.ExplodeBlockInstance(obj) # rs.UnselectAllObjects() # rs.SelectObject(obj) # rs.Command("Explode" , False) # temp_objs = rs.LastCreatedObjects() explode(temp_objs, li) else: li.append(obj) return li
def ReplicateBlock(blockObj): #Copy block copiedBlock = rs.CopyObject(blockObj) #Get new block name origName = rs.BlockInstanceName(blockObj) defaultName = origName for i in range(100): defaultName = utils.UpdateString(defaultName) if origName == defaultName: break if rs.IsBlock(defaultName) == False: break looping = True while looping: newBlockName = rs.StringBox("Enter new block name", default_value=defaultName, title='Iterate Design Option') if newBlockName is None: rs.DeleteObject(copiedBlock) return if rs.IsBlock(newBlockName): print "Block name already exists" elif len(newBlockName) == 0: print "Must specify a name" else: looping = False if newBlockName is None: rs.DeleteObject(copiedBlock) return #Get previous base point xform = rs.BlockInstanceXform(copiedBlock) basePoint = rs.BlockInstanceInsertPoint(copiedBlock) #Explode block objsInside = rs.ExplodeBlockInstance(copiedBlock) rs.AddBlock(objsInside, basePoint, newBlockName, True) #Create new block instance = rs.InsertBlock2(newBlockName, xform) return instance
def main(): objs = rs.GetObjects("select block", 0, True, True) print len(objs) for obj in objs: if rs.ObjectType(obj) == 4096: name = rs.BlockInstanceName(obj) print rs.BlockDescription(name) children = rs.ExplodeBlockInstance(obj) text = rs.AddText(name, [0, 0, 0], height=1.0, font="Arial", font_style=0, justification=None) print type(children) children.Append(text) print children[0]
def makeBlockUnique(obj): oldBase = rs.BlockInstanceInsertPoint(obj) if oldBase is None: return newName = rs.GetString("New Block Name") if newName is None: return newOrigin = rs.GetPoint("Select New Block Base point", base_point=oldBase) if newOrigin is None: return blockObjs = rs.ExplodeBlockInstance(obj) if blockObjs is None: return origObjs = [] for a in blockObjs: origObjs.append(a) rs.AddBlock(origObjs, newOrigin, newName, True) rs.InsertBlock(newName, newOrigin) return
def RunCommand(is_interactive): if sc.escape_test(False): print "script cancelled" #do something print "Making unique..." #******* Get blocks ***************** #************************************ objectIds = rs.GetObjects("Pick some blocks", 4096, preselect=True) if not objectIds: print "No objects" return False #pause viewport redraw rs.EnableRedraw(False) #******* Sort blocks by type ******** #************************************ blockTypes = {} for id in objectIds: blockName = rs.BlockInstanceName(id) if blockName not in blockTypes: blockTypes[blockName] = [] blockTypes[blockName].append(id) #***** Define new block and add ***** #************************************ #Get block names blockNames = rs.BlockNames() #gather all new objects when done finalObjs = [] for blockType in blockTypes: for id in blockTypes[blockType]: #Get the block transformation matrix and name blockXForm = rs.BlockInstanceXform(id) blockName = rs.BlockInstanceName(id) #Insert new block in 0,0,0 newBlock = rs.InsertBlock(blockName, [0, 0, 0]) #Explode the block exObjs = rs.ExplodeBlockInstance(newBlock) #create new block name # if the string ends in digits m will be a Match object, or None otherwise. strippedName = re.sub(r'#[0-9]+$', '', blockName) #test if block name exist and add to the end number if true. x = 0 tryAgain = True while tryAgain: x += 1 newerBlockName = strippedName + "#" + str(x) if newerBlockName not in blockNames: tryAgain = False break #insert exObjs as new block rs.AddBlock(exObjs, [0, 0, 0], newerBlockName, delete_input=True) newerBlock = rs.InsertBlock(newerBlockName, [0, 0, 0]) #match properties from original rs.MatchObjectAttributes(newerBlock, id) #transform new block rs.TransformObject(newerBlock, blockXForm) #append for final selection finalObjs.append(newerBlock) #add name to list of used blocknames. blockNames.append(newerBlockName) #Delete original block rs.DeleteObjects(objectIds) #Select all new objects rs.SelectObjects(finalObjs) rs.EnableRedraw(True) print "...aaand its done." #End RunCommand() #end sane return 0
def sweepVolume(crv, tool_id, z_pos): tangent = rs.CurveTangent(crv, rs.CurveParameter(crv, 0)) origin = rs.CurveStartPoint(crv) block = rs.InsertBlock( tool_id, (0,0,0), scale=(1,1,1) ) # rs.DeleteObjects(objs) # pt2 = [origin.X, origin.Y + perp.XAxis[1], origin.Z] pt2 = [origin.X, origin.Y , origin.Z + 1] pt3 = [origin.X + tangent.X, origin.Y + tangent.Y , origin.Z + tangent.Z] ref = [(0,0,0),(0,1,0),(0,0,1)] target = [origin, pt2 ,pt3] block = rs.OrientObject(block, ref, target) objs = rs.ExplodeBlockInstance(block) profile = None for item in objs: if rs.ObjectLayer(item) == 'HULP::C_Toolcontours' or rs.ObjectLayer(item) == 'Hulp::C_Toolcontours': profile = rs.CopyObject(item) rs.DeleteObjects(objs) if not profile: rs.MessageBox('there is no layer named "C_Toolcontours" in block %s' % rs.BlockInstanceName(block)) return False profile = rs.OffsetCurve(profile, rs.CurveAreaCentroid(profile)[0], 0.001, style=1) # rs.MoveObject(profile, (0,0,z_pos)) # rail = obj # rail_crv = rs.coercecurve(rail) # if not rail_crv: return # # cross_sections = [profile] # if not cross_sections: return # cross_sections = [rs.coercecurve(crv) for crv in cross_sections] # # sweep = Rhino.Geometry.SweepOneRail() # sweep.AngleToleranceRadians = scriptcontext.doc.ModelAngleToleranceRadians # sweep.ClosedSweep = True # # sweep.MiterType = 2 # sweep.SweepTolerance = scriptcontext.doc.ModelAbsoluteTolerance # sweep.SetToRoadlikeTop() # breps = sweep.PerformSweep(rail_crv, cross_sections) # for brep in breps: scriptcontext.doc.Objects.AddBrep(brep) # scriptcontext.doc.Views.Redraw() # # # surface_id = rs.LastCreatedObjects() # METHOD1 surface_id = rs.AddSweep1( crv, profile, True ) rs.CapPlanarHoles(surface_id) pt = rs.CurveAreaCentroid(profile)[0] pt2 = (pt.X, pt.Y, pt.Z+1) rev = rs.AddRevSrf( profile, (pt, pt2) ) rs.MoveObject(surface_id, (0,0,z_pos)) rs.MoveObject(rev, (0,0,z_pos)) return [surface_id, rev] rs.UnselectAllObjects() rs.SelectObjects([crv, profile]) result = rs.Command("_-Sweep1 _Enter Style=RoadlikeTop _Enter", False) if result: rs.DeleteObject(profile) surface_id = rs.LastCreatedObjects() rs.CapPlanarHoles(surface_id) rs.DeleteObjects(objs) rs.MoveObject(surface_id, (0,0,z_pos)) return surface_id
def ExportSelected(scale, path, name): #ShowStep("Scene or block export") # Include lights, exclude grips in selected selected = SelectedObjects() rs.UnselectAllObjects() export_exists = False # Export lights # NOTE: Lights must be exported separately so that # placeholder meshes can be imported without modification. placeholders = [] for object in selected: if rs.ObjectType(object) & lights_export: rs.SelectObject(object) lightLocation = LightLocation(object, scale) placeholders.append(lightLocation) rs.SelectObject(lightLocation) if len(SelectedObjects()) > 0: #ShowStep("Light export") ExportModel(path, name + ".lights") rs.DeleteObjects(placeholders) export_exists = True rs.UnselectAllObjects() # Export meshes for object in selected: if rs.ObjectType(object) & meshes_export: rs.SelectObject(object) if len(SelectedObjects()) > 0: #ShowStep("Mesh objects export") ExportModel(path, name + ".meshes") export_exists = True rs.UnselectAllObjects() # Export detail for object in selected: if rs.ObjectType(object) & detail_export: rs.SelectObject(object) if len(SelectedObjects()) > 0: #ShowStep("Parametric objects export") ExportModel(path, name + ".meshes0", 0) ExportModel(path, name + ".meshes1", 1) ExportModel(path, name + ".meshes2", 2) export_exists = True rs.UnselectAllObjects() # Export blocks # NOTE: Block placeholders must be exported separately # so that meshes can be imported with modification. placeholders = [] for object in selected: if rs.ObjectType(object) & blocks_export: # Export block constituents into subdirectory # On import contents of block will be merged, # and will then replace placeholders in scene and other blocks block = rs.BlockInstanceName(object) block_name = SafeObjectName(block) block_path = os.path.join(path, block_name) block_done = False try: os.mkdir(block_path) except OSError: # Directory exists so block has already been exported block_done = True if not block_done: # Export block instantiation instance = rs.InsertBlock(block, [0, 0, 0]) # IMPORTANT: Nested instances are not exploded, # so that constituent blocks will be exported. instance_parts = rs.ExplodeBlockInstance(instance) rs.SelectObjects(instance_parts) block_name_map = {} UniqueRename(block_name_map) #ShowStep("Block " + block + " export") # IMPORTANT: block subdirectory is prepended to name # so that constituent blocks will be discovered or exported # in adjacent directories. # This prevents repeated exporting in nested directories. block_pathname = os.path.join(block_name, block_name) block_done = ExportSelected(scale, path, block_pathname) rs.DeleteObjects(instance_parts) if block_done: # Create a placeholder placeholders.append(BlockLocation(object, scale)) else: # Remove empty directory os.rmdir(block_path) if len(placeholders) > 0: rs.SelectObjects(placeholders) #ShowStep("Block placeholder export") ExportModel(path, name + ".places") rs.DeleteObjects(placeholders) export_exists = True # Restore selection rs.SelectObjects(selected) return export_exists
def importCAD(filePath, scaleDWG = False): explodeBlockBoo = True #setup the layers importLayerNumber = 6000 importLayerObj = layers.AddLayerByNumber(importLayerNumber, False) importLayerName = layers.GetLayerNameByNumber(importLayerNumber) #Shorten cad file name fileNameExt = os.path.basename(filePath) fileName = os.path.splitext(fileNameExt)[0] #create layer name time = utils.GetDatePrefix() iter = "01" layerName = time+"_"+fileName+"_"+iter #Check if this layer already exists while rs.IsLayer(importLayerName + "::" + time + "_" + fileName + "_" + iter): iterInt = int(iter)+1 if len(str(iterInt))<2: iter = "0" + str(iterInt) else: iter = str(iterInt) elementLayerName = importLayerName + "::" + time + "_" + fileName + "_" + iter elementLayer = rs.AddLayer(elementLayerName) rs.CurrentLayer(elementLayer) #get intial list of all layers in the file currentLayers = rs.LayerNames() rs.Command('_-Import "' + filePath + '" _IgnoreThickness=Yes _ModelUnits=Inches _Enter', False) #get new layers added endLayersNames = rs.LayerNames() newLayers = diff(endLayersNames, currentLayers) for layer in newLayers: rs.ParentLayer(layer, elementLayer) objects = rs.ObjectsByLayer(layer) if rs.IsLayerEmpty(layer): rs.DeleteLayer(layer) else: for obj in objects: if rs.IsDimension(obj): rs.DeleteObject(obj) elif rs.IsHatch(obj): rs.DeleteObject(obj) #Get all the imported geometry allObjects = [] finalLayers = rs.LayerChildren(rs.CurrentLayer()) blockNames = [] for finalLayer in finalLayers: layerObjects = rs.ObjectsByLayer(finalLayer) for layerObject in layerObjects: if rs.IsBlockInstance(layerObject): blockNames.append(rs.BlockInstanceName(layerObject)) allObjects.append(rs.ExplodeBlockInstance(layerObject, True)) else: allObjects.append(layerObject) finalAllObjects = list(flatten(allObjects)) for eachBlock in blockNames: try: rs.DeleteBlock(eachBlock) except: pass #Scale objects if scaleDWG: rs.ScaleObjects(finalAllObjects, [0,0,0], [.001, .001, .001]) #Collapse layers try: rootLay = sc.doc.Layers.FindId(rs.coerceguid(rs.LayerId(elementLayerName))) rootLay.IsExpanded = False except: pass print "Import Successful" return finalAllObjects
def exportToRenderSKP(): #try: #Get Objects objs = rs.GetObjects("Select objects to export", preselect = True) if objs is None: return #Default Name if 'exportToRenderSKP-prevName' in sc.sticky: prevName = sc.sticky['exportToRenderSKP-prevName'] defaultFilename = utils.UpdateString(prevName) else: defaultFilename = utils.GetDatePrefix() + '_OPTION_01' #Default Folder if 'exportToRenderSKP-path' in sc.sticky: defaultFolder = sc.sticky['exportToRenderSKP-path'] elif utils.IsSavedInProjectFolder(): origPath = rs.DocumentPath() path = os.path.normpath(origPath) pathParts = path.split(os.sep) projectFolder = os.path.join(pathParts[0],'\\' ,pathParts[1]) referenceFolder = os.path.join(projectFolder, r'03 DRAWINGS\02 RENDERING\0_copy 3d folder structure\Reference') if os.path.isdir(referenceFolder): print "Reference folder exists" defaultFolder = referenceFolder else: print "Reference folder not found" defaultFolder = rs.DocumentPath() else: defaultFolder = rs.DocumentPath() fileName = rs.SaveFileName("Export to render", "Sketchup 2015 (*.skp)|*.skp||", folder = defaultFolder, filename = defaultFilename) if fileName is None: return sc.sticky['exportToRenderSKP-prevName'] = os.path.splitext(fileName)[0] sc.sticky['exportToRenderSKP-path'] = os.path.dirname(fileName) tempLayers = [] copiedObjs = [] seperator = ' > ' baseName = os.path.splitext(os.path.basename(fileName))[0] #Copy all objects to export rs.StatusBarProgressMeterShow('Exporting to SKP', 0, len(objs)) for i, obj in enumerate(objs): tempCopy = rs.CopyObject(obj) if rs.IsBlockInstance(tempCopy): explodedObjs = list(rs.ExplodeBlockInstance(obj, True)) copiedObjs += explodedObjs else: copiedObjs.append(tempCopy) rs.StatusBarProgressMeterUpdate(i) #Move all copies to a different layer for i, obj in enumerate(copiedObjs): layerFullName = rs.ObjectLayer(obj) shortName = layerFullName.replace('::', seperator) layerName = baseName + seperator + shortName if rs.IsLayer(layerName): rs.ObjectLayer(obj, layerName) else: matIndex = rs.LayerMaterialIndex(rs.ObjectLayer(obj)) newLayer = rs.AddLayer(layerName, rs.LayerColor(rs.ObjectLayer(obj))) rs.LayerMaterialIndex(newLayer, matIndex) tempLayers.append(newLayer) rs.ObjectLayer(obj, newLayer) rs.StatusBarProgressMeterHide() try: rs.SelectObjects(copiedObjs) rs.Command('-_Export ' + '"' + fileName + '"' + ' s SketchUp2015 Enter ', False) #CLEANUP rs.UnselectAllObjects() try: rs.DeleteObjects(copiedObjs) except: rs.DeleteObject(copiedObjs) for layer in tempLayers: rs.DeleteLayer(layer) except: print "export failed" result = True #except: # result = False try: pass #utils.SaveFunctionData('IO-Export to Render[SKP]', [fileName, baseName, os.path.getsize(fileName),len(objs), result]) except: print "Failed to save function data" return result
def processObject(object, parentInstances): global g_instances global g_instancesByName global g_parts global g_materials name = rs.ObjectName(object) if not name: name = "Unnamed" type = rs.ObjectType(object) layer = rs.ObjectLayer(object) if type == rs.filter.instance: type = rs.BlockInstanceName(object) xform = rs.BlockInstanceXform(object) # Seems like transforms are in global frame already # --> Probably due to exploding the block hierarchies... #for parent in reversed(parentInstances[1:]) : # xform = parent["xform"] * xform subObjects = rs.ExplodeBlockInstance(object) fullName = name if len(parentInstances) > 1: for parent in parentInstances[1:]: fullName = parent["name"] + "." + fullName originalFullName = fullName appendixCtr = 1 while fullName in g_instancesByName: fullName = format("%s+%d" % (originalFullName, appendixCtr)) appendixCtr += 1 if fullName != originalFullName: print("WARNING: Renamed %s => %s" % (originalFullName, fullName)) instance = \ { "name" : name, "fullName" : fullName, "type" : type, "xform" : xform, "parents" : list(parentInstances), "parts" : [], "touched" : False, } g_instances.append(instance) g_instancesByName[fullName] = instance for subObject in subObjects: processObject(subObject, parentInstances + [instance]) return skipReason = None if rs.LayerLocked(layer): skipReason = "layer locked" elif not rs.LayerVisible(layer): skipReason = "layer hidden" elif type != rs.filter.polysurface and type != rs.filter.surface: skipReason = "bad type - " + typeStr[type] if skipReason: # make sure we can delete object by moving to current layer rs.ObjectLayer(object, rs.CurrentLayer()) print("Skipping %s (%s)" % (str(object), skipReason)) else: brep = rs.coercebrep(object) meshes = rc.Geometry.Mesh.CreateFromBrep(brep, g_meshParams) joinedMesh = rc.Geometry.Mesh() for mesh in meshes: joinedMesh.Append(mesh) joinedMesh.Reduce(0, False, 10, False) if not joinedMesh.Faces.ConvertQuadsToTriangles(): print("WARNING: Failed to convert quads to tris for %s" % (str(object))) if not joinedMesh.Compact(): print("WARNING: Failed to compact %s" % (str(object))) materialSrc = rs.ObjectMaterialSource(object) if materialSrc == 0: materialIdx = rs.LayerMaterialIndex(rs.ObjectLayer(object)) else: materialIdx = rs.ObjectMaterialIndex(object) material = rs.MaterialName(materialIdx) if not material: material = "None" g_materials[material] = materialIdx joinedMeshGuid = sc.doc.Objects.AddMesh(joinedMesh) rs.ObjectName(joinedMeshGuid, name) rs.ObjectMaterialSource(joinedMeshGuid, 1) rs.ObjectMaterialIndex(joinedMeshGuid, materialIdx) part = \ { "name" : name, "mesh" : joinedMesh, "instance" : parentInstances[-1], "material" : material, } parentInstances[-1]["parts"].append(part) if not parentInstances[-1]["touched"]: for parentInstance in parentInstances: parentInstance["touched"] = True g_parts.append(part) rs.DeleteObject(object)
"BlockInstances") panelBlockList = panelBlockList[0:-1:int( stepNumber)] #Nth panel filtering #--Collect current objects in key layers before exploding targeted blocks initDocGlassSet = set(rs.ObjectsByLayer("_P_Glass")) initDocMullionSet = set(rs.ObjectsByLayer("_P_Mullions")) initDocShadingSet = set(rs.ObjectsByLayer("_P_Shading")) initDocWallSet = set(rs.ObjectsByLayer("_P_Wall")) #Explode blocks of seleted panels tmpPanelElements = [] tmpPanelBlockList = rs.CopyObjects(panelBlockList) for tmpPanelBlock in tmpPanelBlockList: tmpPanelElements += rs.ExplodeBlockInstance(tmpPanelBlock) #--Collect new objects in key layers newDocGlassSet = set(rs.ObjectsByLayer("_P_Glass")) newDocMullionSet = set(rs.ObjectsByLayer("_P_Mullions")) newDocShadingSet = set(rs.ObjectsByLayer("_P_Shading")) newDocWallSet = set(rs.ObjectsByLayer("_P_Wall")) #Store Ladybug elements and delete leftovers lbGlassSet = set() lbMullionSet = set() lbShadingSet = set() lbWallSet = set() lbGlassSet = newDocGlassSet - initDocGlassSet lbMullionSet = newDocMullionSet - initDocMullionSet lbShadingSet = newDocShadingSet - initDocShadingSet