def RenameBlockButton():
try:
block = rs.GetObject("Select block to rename",
filter=4096,
preselect=True)
#Default Name
try:
number = int(rs.BlockInstanceName(block).split('_')[-1])
number += 1
if len(str(number)) < 2:
numString = '0' + str(number)
else:
numString = str(number)
except:
numString = '01A'
defaultName = GetDatePrefix() + "_OPTION_" + numString
looping = True
while looping:
newName = rs.StringBox("Enter new block name",
default_value=defaultName,
title='Rename Block')
if newName is None: return
if rs.IsBlock(newName):
print "Block name already exists"
elif len(newName) == 0:
print "Must specify a name"
pass
else:
looping = False
return rs.RenameBlock(rs.BlockInstanceName(block), newName)
except:
return None
def main():
print 'test'
objs = rs.GetObjects()
vec_x = [10,0,0]
# restore viewport Cplane
p1 = rs.WorldXYPlane()
rs.ViewCPlane(None, p1)
for obj in objs:
if rs.IsBlockInstance(obj) and rs.BlockInstanceName(strObject):
xform1 = rs.BlockInstanceXform(obj)
crv = rs.AddCurve([ [0,0,0], [0,300,0] ])
xfrom1_inv = rs.TransformObject( crv, (xform1) )
rs.SelectObject(crv)
vec1 = rs.CurveEndPoint(crv) - rs.CurveStartPoint(crv)
print vec1, math.degrees(calcAngle(vec1, vec_x))
if __name__ == "__main__":
main();
def BlockLocation(object, scale):
# WARNING: The basis describes a transformation of the Rhino basis
# with respect to the Rhino basis, which might not match the
# import environment world basis.
x = rs.BlockInstanceXform(object)
p0 = [x.M00, x.M10, x.M20] # X Basis direction
p1 = [x.M01, x.M11, x.M21] # Y Basis direction
p2 = [x.M02, x.M12, x.M22] # Z Basis direction
p3 = [x.M03, x.M13, x.M23] # Origin position
# Rescale transform units
for i in range(3):
p0[i] /= scale
p1[i] /= scale
p2[i] /= scale
# Construct basis tetrahedron
placeholder = LocationMesh(p3, [p0, p1, p2])
# Unity import will render names unique with a _N suffix on the N copy
# so block name is included as a prefix to facilitate matching
# in the case that block objects names are not unique
block = rs.BlockInstanceName(object)
block_name = SafeObjectName(block)
object_name = rs.ObjectName(object)
rs.ObjectName(placeholder, block_name + "=" + object_name)
rs.ObjectLayer(placeholder, rs.ObjectLayer(object))
return placeholder
def blkObjs(blkid):
blockName = rs.BlockInstanceName(blkid)
objref = rs.coercerhinoobject(blkid)
idef = objref.InstanceDefinition
idefIndex = idef.Index
lvl = levels[rs.GetUserText(blkid, 'level')]
height = float(lvl['height'])
xform = rs.BlockInstanceXform(blkid)
objects = rs.BlockObjects(blockName)
# masses = map(lambda x: massFromSrf(x, height), objects)
# newblk = rs.AddBlock(masses, (0,0,0), name=name, delete_input=True)
# objects.extend(masses)
newGeometry = []
newAttributes = []
for object in objects:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
attr.SetUserString('blkname', blockName)
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry,
newAttributes)
# rs.TransformObjects(masses, xform)
rs.DeleteObjects(masses)
def MakeBlockUniqueButton():
try:
block = rs.GetObject("Select block to make unique",
rs.filter.instance,
preselect=True)
if block is None: return
defaultName = utils.UpdateString(rs.BlockInstanceName(block))
looping = True
while looping:
newName = rs.StringBox("Enter new block name",
default_value=defaultName,
title='MakeUnique')
if newName is None: return
if rs.IsBlock(newName):
print "Block name already exists"
elif len(newName) == 0:
print "Must specify a name"
else:
looping = False
if newName is None: return
rs.EnableRedraw(False)
newBlock = MakeBlockUnique(block, newName)
rs.EnableRedraw(True)
rs.SelectObject(newBlock)
return True
except:
return False
def Iterate():
block = rs.GetObject("Select Design Option Block to iterate",
rs.filter.instance, True)
if block is None: return
try:
prevBlockName = rs.BlockInstanceName(block)
prevBlockLayer = rs.ObjectLayer(block)
prevBlockLayerColor = rs.LayerColor(prevBlockLayer)
newBlock = ReplicateBlock(block)
newBlockName = rs.BlockInstanceName(newBlock)
#Ensure 3_DESIGN OPTIONS already exists
parentLayer = layers.AddLayerByNumber(3000, False)[0]
rs.LayerVisible(parentLayer, True)
#Create new design option layer
#newBlockLayer = rs.AddLayer(parentLayer + "::" + newBlockName, color = utils.StepColor(prevBlockLayerColor))
newBlockLayer = rs.AddLayer(parentLayer + "::" + newBlockName,
color=utils.GetRandomColor())
rs.LayerPrintColor(newBlockLayer, (0, 0, 0))
rs.ObjectLayer(newBlock, newBlockLayer)
#Save user text
try:
parentsUserTest = rs.GetUserText(block,
'Design Option History') + "<--"
except:
parentsUserTest = ''
rs.SetUserText(newBlock, 'Design Option History',
parentsUserTest + newBlockName)
#Turn off prev blocks layer
if rs.CurrentLayer() != prevBlockLayer:
rs.LayerVisible(prevBlockLayer, False)
result = True
except:
result = False
newBlockName = ''
utils.SaveFunctionData(
'Blocks-Iterate',
[__version__,
rs.BlockInstanceName(block), newBlockName, result])
return result
def AddBlockName(obj):
name = rs.BlockInstanceName(obj)
pt = rs.BlockInstanceInsertPoint(obj)
bb = rs.BoundingBox(obj)
text = rs.AddText(name, (bb[0] + bb[6]) / 2)
rs.SetUserText(text, 'tag', 'label')
group = rs.AddGroup()
rs.AddObjectsToGroup([obj, text], group)
def test_block_name(options):
layer_name = options['layer']
for x in get_blocks_by_layer(layer_name):
name = rs.BlockInstanceName(x.Id)
pattern = '^{layer}'.format(layer=layer_name)
if not re.match(pattern, name):
return False
return True
def GetCustomBlockNames():
block = rs.BlockNames(True)
if len(block) < 1:
print "There are no blocks in the file"
return None
objs = rs.GetObjects('Select block(s) to populate', rs.filter.instance,
True)
if objs is None: return None, None
blockNames = []
for obj in objs:
blockNames.append(rs.BlockInstanceName(obj))
return blockNames, objs
def getBlockName():
go = Rhino.Input.Custom.GetObject()
go.SetCommandPrompt("Select block instance to annotate")
go.GeometryFilter = Rhino.DocObjects.ObjectType.InstanceReference
go.EnablePreSelect(False, True)
go.InactiveDetailPickEnabled = True
rc = go.Get()
if rc == Rhino.Input.GetResult.Object:
objref = go.Object(0)
obj = objref.Object()
name = rs.BlockInstanceName(obj.Id)
return name
def IntersectGeo(obj, level):
tolerance = rs.UnitAbsoluteTolerance()
plane = rc.Geometry.Plane(rs.coerce3dpoint((0, 0, level)),
rs.coerce3dvector((0, 0, 1)))
finalCurves = []
#BLOCKS
if rs.IsBlockInstance(obj):
matrix = rs.BlockInstanceXform(obj)
blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj))
for eachBlockObj in blockObjs:
newCopy = rs.CopyObject(eachBlockObj)
xformedObj = rs.TransformObject(newCopy, matrix)
#EXTRUSIONS
if isinstance(xformedObj, rc.Geometry.Extrusion):
temp = sc.doc.Objects.AddBrep(xformedObj.ToBrep(False))
xformedObj = rs.coercebrep(temp)
rs.DeleteObject(temp)
#BREPS IN BLOCK
result = IntersectBrepPlane(xformedObj, plane)
if result is None: continue
for each in result:
if each is not None:
finalCurves.append(each)
rs.DeleteObject(xformedObj)
#MESHES IN BLOCK <---This code might not be necessary
result = IntersectMeshPlane(xformedObj, plane)
if result is None: continue
for each in result:
if each is not None:
finalCurves.append(each)
rs.DeleteObject(xformedObj)
#BREPS
elif rs.IsBrep(obj):
result = IntersectBrepPlane(obj, plane)
if result is None: return None
for each in result:
if each is not None:
finalCurves.append(each)
#MESHES
elif rs.IsMesh(obj):
result = IntersectMeshPlane(obj, plane)
if result is None: return None
for each in result:
if each is not None:
finalCurves.append(each)
return finalCurves
def RemoveFromBlock():
block = rs.GetObject("Select Block to extract objects from",
rs.filter.instance,
preselect=True)
if not block: return
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
XformBlock = rs.BlockInstanceXform(block)
blockObjects = rs.BlockObjects(blockName)
blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True)
objs = rs.GetObjects("Select Objects to extract from Block",
objects=blockInstanceObjects)
if not objs:
rs.DeleteObjects(blockInstanceObjects)
return
keep = [] #List to keep in block
delete = [] #list to delete from block and add to doc
rs.EnableRedraw(False)
for object in blockInstanceObjects:
if object in objs: delete.append(object)
else: keep.append(object)
if rs.IsBlockReference(blockName):
print "Block is referenced from file; unable to modify block"
rs.DeleteObjects(keep)
return
rs.TransformObjects(keep, rs.XformInverse(XformBlock), False)
newGeometry = []
newAttributes = []
for object in keep:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry,
newAttributes)
rs.DeleteObjects(keep)
rs.EnableRedraw(True)
def BlockTxt(block, str = False, cstr = False, boolFlipHeb=True):
if not block: return
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
XformBlock = rs.BlockInstanceXform(block)
blockObjects = rs.BlockObjects(blockName)
txtobjs = False
for obj in blockObjects:
if rs.IsText(obj):
if not str: txtobjs = True
elif rs.TextObjectText(obj) == str: txtobjs = True
if txtobjs:
blockInstanceObjects = rs.TransformObjects(blockObjects, XformBlock, True)
keep = []
rs.EnableRedraw(False)
for obj in blockInstanceObjects:
if rs.IsText(obj):
if not str and not cstr:
str = rs.TextObjectText(obj)
cstr = ConvTxt(str, boolFlipHeb)
if not cstr == str:
rs.TextObjectText(obj, cstr)
keep.append(obj)
else: keep.append(obj)
rs.TransformObjects(keep, rs.XformInverse(XformBlock), False)
newGeometry = []
newAttributes = []
for object in keep:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry, newAttributes)
rs.DeleteObjects(keep)
def resetBlockScale(block):
block_name = rs.BlockInstanceName(block)
blockXform = rs.BlockInstanceXform(block)
plane = rs.PlaneTransform(rs.WorldXYPlane(), blockXform)
# newplane = rs.CreatePlane(plane.Origin, plane.XAxis, plane.YAxis)
# cob = rs.XformChangeBasis(newplane, rs.WorldXYPlane())
cob = rs.XformChangeBasis(plane, rs.WorldXYPlane())
newBlock = rs.InsertBlock2(block_name, cob)
copySourceLayer(newBlock, block)
try:
copySourceData(newBlock, block)
except:
pass
rs.DeleteObjects(block)
return newBlock
def blkObjs(blkid):
blockName = rs.BlockInstanceName(blkid)
# objref = rs.coercerhinoobject(blkid)
# idef = objref.InstanceDefinition
# idefIndex = idef.Index
lvl = levels[rs.GetUserText(blkid, 'level')]
height = lvl['height']
xform = rs.BlockInstanceXform(blkid)
objects = [x for x in rs.BlockObjects(blockName) if rs.IsPolysurfaceClosed(x)]
objects = map(lambda x: rs.SetUserText(x, 'level', lvl), objects)
# map(lambda x: rs.SetUserText(x, 'height', lvl))
blockInstanceObjects = rs.TransformObjects(objects, xform, True)
def SampleBlockLeader():
go = Rhino.Input.Custom.GetObject()
go.SetCommandPrompt("Select block instance to annotate")
go.GeometryFilter = Rhino.DocObjects.ObjectType.InstanceReference
go.EnablePreSelect(False, True)
go.InactiveDetailPickEnabled = True
rc = go.Get()
if rc == Rhino.Input.GetResult.Object:
prompt0 = "First point of leader"
prompt1 = "Next point of leader. Press Enter when done"
points = rs.GetPoints(True, True, prompt0, prompt1)
if points is not None:
objref = go.Object(0)
obj = objref.Object()
name = rs.BlockInstanceName(obj.Id)
rs.AddLeader(points, None, name)
def Rename():
instance = rs.GetObject('block to rename', rs.filter.instance)
blockName = rs.BlockInstanceName(instance)
# blockName = rs.GetString("block to rename")
instanceDefinition = doc.InstanceDefinitions.Find(blockName, True)
if not instanceDefinition:
print "{0} block does not exist".format(blockName)
return
newName = rs.GetString("current name is '{0}'. Specify a new name".format(blockName))
instanceDefinition = doc.InstanceDefinitions.Find(newName, True)
if instanceDefinition:
print "the name '{0}' is already taken by another block".format(newName)
return
rs.RenameBlock(blockName, newName)
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 blkObjs(blkid):
blockName = rs.BlockInstanceName(blkid)
# objref = rs.coercerhinoobject(blkid)
# idef = objref.InstanceDefinition
# idefIndex = idef.Index
# lvl = levels[rs.GetUserText(blkid, 'level')]
# height = lvl['height']
xform = rs.BlockInstanceXform(blkid)
# objects = [x for x in rs.BlockObjects(blockName) if 'mass' in rs.ObjectLayer(x)]
objects = filter(lambda x: 'mass' in rs.ObjectLayer(x),
rs.BlockObjects(blockName))
# objects = filter(lambda x: 'mass' in rs.ObjectLayer(x) and rs.GetUserText(x, 'class') != 'na', rs.BlockObjects(blockName))
# objects = map(lambda x: rs.SetUserText(x, 'level', lvl), objects)
# map(lambda x: rs.SetUserText(x, 'height', lvl))
blockInstanceObjects = rs.TransformObjects(objects, xform, True)
masses.extend(blockInstanceObjects)
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 RunCommand(is_interactive):
if sc.escape_test(False):
print "script cancelled" #do something
print "Selecting all blocks of same definition..."
#******* 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 Name ********
#************************************
blockNames = []
for id in objectIds:
blockName = rs.BlockInstanceName(id)
if blockName not in blockNames:
blockNames.append(blockName)
#******* Get block instances by name ********
#********************************************
selIds = []
for name in blockNames:
blockIds = rs.BlockInstances(name)
selIds.extend(blockIds)
#******* Select blocks **************
#************************************
rs.SelectObjects(selIds)
rs.EnableRedraw(True)
print "...aaand its done."
#End RunCommand()
#end sane
return 0
def GetAllBlockObjectsInPosition(obj):
"""Recursively get all objects from a block (and blocks in blocks)
inputs:
obj (block instance)
returns:
objs (list guids): Geometry is a copy of the instance geometry
"""
blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj))
xform = rs.BlockInstanceXform(obj)
objList = []
for eachblockObj in blockObjs:
if rs.IsBlockInstance(eachblockObj):
thisBlockObjects = GetAllBlockObjectsInPosition(eachblockObj)
for eachObject in thisBlockObjects:
transformedObj = rs.TransformObject(eachObject, xform, False)
objList.append(transformedObj)
else:
transformedObj = rs.TransformObject(eachblockObj, xform, True)
objList.append(transformedObj)
return objList
def AddToBlock():
objects = rs.GetObjects("Choose Objects to Add to Block", preselect=True)
if not objects: return
block = rs.GetObject("Choose Block to Add Object to", rs.filter.instance)
if not block: return
rs.EnableRedraw(False)
blockName = rs.BlockInstanceName(block)
objref = rs.coercerhinoobject(block)
idef = objref.InstanceDefinition
idefIndex = idef.Index
if rs.IsBlockReference(blockName):
print "Block is referenced from file; unable to add object(s)"
return
blnCopy = False
XformBlock = rs.BlockInstanceXform(block)
rs.TransformObjects(objects, rs.XformInverse(XformBlock), blnCopy)
objects.extend(rs.BlockObjects(blockName))
newGeometry = []
newAttributes = []
for object in objects:
newGeometry.append(rs.coercegeometry(object))
ref = Rhino.DocObjects.ObjRef(object)
attr = ref.Object().Attributes
newAttributes.append(attr)
InstanceDefinitionTable = sc.doc.ActiveDoc.InstanceDefinitions
InstanceDefinitionTable.ModifyGeometry(idefIndex, newGeometry,
newAttributes)
rs.DeleteObjects(objects)
rs.EnableRedraw(True)
def BlockTxtSim(block, boolFlipHeb=True):
if not block: return
blockName = rs.BlockInstanceName(block)
blockObjects = rs.BlockObjects(blockName)
obj = blockObjects[0]
str= ""
cstr = ""
if rs.IsText(obj):
str = rs.TextObjectText(obj)
cstr = ConvTxt(str, boolFlipHeb)
else: return
blocks = rs.ObjectsByType(4096, False, 0)
for blockRef in blocks:
BlockTxt(blockRef, str, cstr, boolFlipHeb)
rs.EnableRedraw(True)
def ResetBlockScale():
try:
blocks = rs.GetObjects("Select blocks to reset",
rs.filter.instance,
preselect=True)
if blocks is None: return
points = [
rg.Point3d(0, 0, 0),
rg.Point3d(1, 0, 0),
rg.Point3d(0, 1, 0),
rg.Point3d(0, 0, 1)
]
for block in blocks:
xform = rs.BlockInstanceXform(block)
namne = rs.BlockInstanceName(block)
pts = rg.Polyline(points)
pts.Transform(xform)
finalOrigin = pts[1]
finalXaxis = rs.VectorSubtract(pts[1], pts[0])
finalYaxis = rs.VectorSubtract(pts[2], pts[0])
finalPlane = rg.Plane(finalOrigin, finalXaxis, finalYaxis)
xFac = 1 / rs.Distance(pts[1], pts[0])
yFac = 1 / rs.Distance(pts[2], pts[0])
zFac = 1 / rs.Distance(pts[3], pts[0])
newXForm = rg.Transform.Scale(finalPlane, xFac, yFac, zFac)
rs.TransformObject(block, newXForm)
return True
except:
return False
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)
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
import rhinoscriptsyntax as rs
crvIds = rs.GetObjects("Pick curves", rs.filter.curve)
ptIds = rs.GetObjects("Pick points", rs.filter.point)
blockId = rs.GetObject("Pick Block", rs.filter.instance)
if rs.IsBlockInstance(blockId):
block_name = rs.BlockInstanceName(blockId)
for crv in crvIds:
for pt in ptIds:
if rs.IsPointOnCurve(crv, pt):
param = rs.CurveClosestPoint(crv, pt)
tangent = rs.CurveTangent(crv, param)
tangent = rs.VectorUnitize(tangent)
normal = rs.WorldXYPlane().ZAxis
# normal = rs.VectorUnitize(normal)
plane = rs.PlaneFromNormal(pt, normal, tangent)
# plane = rs.CurvePerpFrame(crv, param)
xform = rs.XformChangeBasis(plane, rs.WorldXYPlane())
rs.InsertBlock2(block_name, xform)
