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)