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