def applyXform(target, source):
targetXform = rs.BlockInstanceXform(target)
sourceXform = rs.BlockInstanceXform(source)
if targetXform is not None:
plane = rs.PlaneTransform(rs.WorldXYPlane(), targetXform)
# xformscale = rs.XformScale((1.0,20.0,1.0))
cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
temp = rs.XformMultiply(sourceXform, cob)
xform = rs.XformMultiply(cob_inverse, temp)
rs.TransformObjects(target, xform)
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 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 checkblkplane(blkid):
xform = rs.BlockInstanceXform(blkid)
plane = rs.PlaneTransform(rs.WorldXYPlane(), xform)
normal = plane.ZAxis.Z
print normal
if normal < 0:
newxform = rs.XformMirror(plane.Origin, plane.Normal)
return rs.TransformObject(blkid, newxform)
else:
return
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 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 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 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 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 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 blkFace(obj):
cameraPos = rs.ViewCamera()
cameraPos.Z = 0
xform = rs.BlockInstanceXform(obj)
plane = rs.PlaneTransform(rs.WorldXYPlane(), xform)
viewdir = rs.VectorUnitize(cameraPos - plane.Origin)
angle = rs.VectorAngle(viewdir, plane.YAxis)
newXform = rs.XformRotation3(plane.YAxis, viewdir, plane.Origin)
rs.TransformObject(obj, newXform)
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 bbsolid(obj):
if rs.IsBlockInstance(obj):
arrMatrix = rs.BlockInstanceXform(obj)
if arrMatrix is not None:
# pointId = rs.AddPoint([0,0,0])
plane = rs.PlaneTransform(rs.WorldXYPlane(), arrMatrix)
box = rs.BoundingBox(obj, plane)
bb = rs.AddBox(box)
# if box:
# for i, point in enumerate(box):
# rs.AddTextDot( i, point )
xformscale = rs.XformScale((1.0, 20.0, 1.0))
cob = rs.XformChangeBasis(rs.WorldXYPlane(), plane)
cob_inverse = rs.XformChangeBasis(plane, rs.WorldXYPlane())
temp = rs.XformMultiply(xformscale, cob)
xform = rs.XformMultiply(cob_inverse, temp)
rs.TransformObjects(bb, xform)
return bb
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 add_cutters_for_rivets():
"""
This script adds cylinder objects (as a group named 'rivet-hole-cutters')
at rivet block positions to easily cut holes into
the sheet metal objects.
www.studiogijs.nl
"""
depth = 12
origin = Rhino.Geometry.Point3d(0.0, 0.0, -depth / 2)
direction = Rhino.Geometry.Vector3d(0.0, 0.0, 1.0)
plane = Rhino.Geometry.Plane(origin, direction)
blocks = sc.doc.ActiveDoc.InstanceDefinitions
blocknames = []
for block in blocks:
if block.Name != None:
if block.Name.__contains__("rivet"):
blocknames.append(block.Name)
if len(blocknames) == 0:
print "no rivet block items found in this document"
return
rivets = []
for name in blocknames:
instances = rs.BlockInstances(name, 0)
for instance in instances:
rivets.append(instance)
cutters = []
cutter_group = rs.AddGroup("rivet-hole-cutters")
for rivet in rivets:
radius = float(
rs.coercerhinoobject(rivet).InstanceDefinition.Name[-5]) / 2 + 0.15
circle = Rhino.Geometry.Circle(plane, radius).ToNurbsCurve()
cyl = Rhino.Geometry.Extrusion.Create(circle, depth, True)
xform = rs.BlockInstanceXform(rivet)
trans = Rhino.Geometry.Transform(xform)
cyl.Transform(trans)
cutter = sc.doc.Objects.AddExtrusion(cyl)
rs.AddObjectToGroup(cutter, "rivet-hole-cutters")
sc.doc.Views.Redraw()
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 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 blkPlane(obj):
xform = rs.BlockInstanceXform(obj)
plane = rs.PlaneTransform(rs.WorldXYPlane(), xform)
return plane
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 Rhino
import rhinoscriptsyntax as rs
from math import atan2, pi, asin
def DecomposeXformRotation(arrXform):
arrRotate = Rhino.Geometry.Point3d.Unset
arrRotate.X = atan2(- arrXform.M21, arrXform.M22)
arrRotate.Y = asin(arrXform.M20)
arrRotate.Z = atan2(arrXform.M10, arrXform.M00)
return arrRotate
#pick an object
objects = rs.GetObjects("Select Curves", rs.filter.instance)
#Loop between my objects
for id in objects:
name = rs.ObjectName(id)
print "Object:", id, name
r = DecomposeXformRotation(rs.BlockInstanceXform(id))
v = round( r[0] * -180/pi, 0) + 0
if v < 0: v += 360
print "v = %.2f" % v
# new_id = rs.RotateObject(id, [0, 0, 0], 90, [1, 0, 0], 1);
# rs.ObjectName(new_id, "copy " + name)
# input is guid of referenced block import rhinoscriptsyntax as rs import ghpythonlib.treehelpers as th import scriptcontext as sc import Rhino as rc sc.doc = rc.RhinoDoc.ActiveDoc cameraPos = rs.ViewCamera() cameraPos.Z = 0 xform = rs.BlockInstanceXform(x) plane = rs.PlaneTransform(rs.WorldXYPlane(), xform) viewdir = rs.VectorUnitize(cameraPos - plane.Origin) angle = rs.VectorAngle(viewdir, plane.YAxis) newplane = rs.RotatePlane(plane, angle, plane.ZAxis) a = xform b = plane c = cameraPos d = viewdir e = plane.YAxis
def RunCommand( is_interactive ):
if sc.escape_test(False):
print "script cancelled" #do something
print "Resetting..."
#******* Get blocks ***********''****
#************************************
objectIds = rs.GetObjects("Pick some blocks", 4096, preselect=True)
if not objectIds:
print "No objects"
return False
rs.EnableRedraw(False)
#******* Ref Geometry ***************
#************************************
points = [
G.Point3d(0,0,0),
G.Point3d(1,0,0),
G.Point3d(0,1,0),
G.Point3d(0,0,1)
]
#gather all new objects when done
finalObjs = []
for id in objectIds:
#Get the block transformation matrix and name
blockXForm = rs.BlockInstanceXform(id)
blockName = rs.BlockInstanceName(id)
#Add reference geometry
pts = G.Polyline(points)
#Apply block transformation matrix to ref geometry
pts.Transform(blockXForm)
#create final plane
finalOrigin = pts[1]
finalXaxis = rs.VectorSubtract( pts[1], pts[0] )
finalYaxis = rs.VectorSubtract( pts[2], pts[0] )
finalPlane = G.Plane(finalOrigin, finalXaxis, finalYaxis)
#create scaling factors
xFac = 1 / rs.Distance(pts[1],pts[0])
yFac = 1 / rs.Distance(pts[2],pts[0])
zFac = 1 / rs.Distance(pts[3],pts[0])
#Scale block
newXForm = G.Transform.Scale(finalPlane, xFac, yFac, zFac)
rs.TransformObject(id,newXForm)
#Select all new objects
rs.SelectObjects(objectIds)
rs.EnableRedraw(True)
print "...aaand its done."
#End RunCommand()
#end sane
return 0
