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
