def finish(): items = ("Points", "Reserve", "Delete") results = rs.GetBoolean("Delete options", items, (True)) if results[0]: for object in ltObjectPoint: rs.DeleteObject(object) return 0
def GetOptions(): restore = rs.GetBoolean("Rhino Appearance Settings", [("Option", "Save", "Restore")], [False]) if restore is None: return restore = restore[0] name = rs.GetString("Scheme Name") if name: return name, restore
def DelOffScreen(): try: obj = rs.GetObjects('Select objects to test', preselect=True) bool = rs.GetBoolean('Delete or Hide', ('Option', 'Delete', 'Hide'), (False)) if obj: rs.EnableRedraw(False) for i in obj: isVisible = rs.IsVisibleInView(i) if isVisible == False: if bool[0] == True: rs.HideObject(i) if bool[0] == False: rs.DeleteObject(i) rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def continue_or_not(): items = ("Continue", "False", "True") results = rs.GetBoolean("Continue options", items, (True)) if results: return results[0] else: return 1
def RunCommand(is_interactive): global params center = rs.GetPoint(message="Select center point") n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4) r = rs.GetReal(message="Outside Diameter", number=params["r"]) m = rs.GetReal(message="Gear module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) bool_opts = rs.GetBoolean(message="Output options", items=(("PitchCircle", "No", "Yes"), ), defaults=(params["pc"], )) if None in [center, n, m, pa, bool_opts]: return 1 # Cancel pc = bool_opts[0] params["n"] = n params["m"] = m params["r"] = r params["pa"] = pa params["pc"] = pc cplane = rs.ViewCPlane() # Get current CPlane cplane = rs.MovePlane(cplane, center) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) gear = generate_gear_crv_with_outside(teeth=params["n"], module=params["m"], outside_diam=params["r"], pressure_angle=params["pa"]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(gear, xform) rs.EnableRedraw(True) if pc: circle = generate_pitch_circle_crv(teeth=params["n"], module=params["m"]) rs.TransformObjects(circle, xform) rs.SelectObjects([gear, circle]) else: rs.SelectObjects(gear) return 0 # Success
def main(): """ Creates a part list for all blocks in a document. Numbers will correspond with balloons, but balloons don't need to be present for the table to be generated version 1.3 www.studiogijs.nl version 1.1 adds table heading version 1.2 option for choosing between all or only top level blocks version 1.3 adds block description. Use change_block_description.py or change in block manager """ t = sc.sticky['top_level_only'] if sc.sticky.has_key( 'top_level_only') else 0 #0 = top level only, 1= all blocks if t == None: t = 0 top_level_only = rs.GetBoolean("annotate top level blocks only?", ["top_level_only", "yes", "no"], t) if not top_level_only: return sc.sticky['top_level_only'] = top_level_only[0] previous_layer = rs.CurrentLayer() #check if layer 'annotation' exist, else create it if not rs.IsLayer("annotation"): rs.AddLayer("annotation") rs.LayerColor("annotation", Col.Black) rs.CurrentLayer("annotation") groups = sc.doc.ActiveDoc.Groups partlist = [] blocknames = get_block_names() if not blocknames: print "This file does not contain block items (titleblock will be ignored)" return #add headings texts = ["ITEM", "PART NAME", "DESCR", "QTY"] partlist.append(texts) texts = [] for block_nr, blockname in enumerate(blocknames, 1): texts.append(str(block_nr)) texts.append(blockname) description = rs.BlockDescription(blockname) if description is None: description = "" texts.append(description) blockcount = get_block_count(blockname) texts.append(str(blockcount)) partlist.append(texts) texts = [] create_table(partlist) #change back to previous layer rs.CurrentLayer(previous_layer)
def annotation_balloon(): """ Adds a numbered balloon to the document based on the numbering in part list. Works only with block items, similar to how this works in 'solid modelers' on parts in assemblies www.studiogijs.nl version 1.1: option for choosing between all or only top level blocks """ t = sc.sticky['top_level_only'] if sc.sticky.has_key('top_level_only') else 0 #0 = top level only, 1= all blocks if t==None: t=0 top_level_only = rs.GetBoolean("annotate top level blocks only?", ["top_level_only", "yes", "no"],t) if not top_level_only: return sc.sticky['top_level_only'] = top_level_only[0] name = get_blockname() if not name: return previous_layer = rs.CurrentLayer() #check if layer 'annotation' exist, else create it if not rs.IsLayer("annotation"): rs.AddLayer("annotation") rs.LayerColor("annotation",Col.Black) rs.CurrentLayer("annotation") block_nr = get_block_index(name)+1 curve, size = get_input() if curve and size: aCircle, aText, aCurve = add_annotation_circle(curve, block_nr, size) aEndDot = add_end_dot(curve, size) else: rs.CurrentLayer(previous_layer) return #create annotation object groupname = 'annotation-object_'+str(block_nr) rs.AddGroup(groupname) rs.AddObjectsToGroup([aCircle, aText, aCurve, aEndDot], groupname) groups = sc.doc.ActiveDoc.Groups for group in groups: if group.Name == groupname: group.SetUserString("group-nr", str(block_nr)) group.SetUserString("block-name", name) #change back to previous layer rs.CurrentLayer(previous_layer)
def main(): objs = rs.GetObjects("Select Objects to Send to CAD", preselect = True) if objs is None: return items = [ ["Units", "Millimeters", "Meters"] ] defaults = [False] CADinMeters = rs.GetBoolean("Autocad DWG units", items, defaults)[0] if CADinMeters is None: return coordRaw = rs.GetDocumentData("Project Info", "CAD coordinate (X,Y,Z)") if len(coordRaw) == 0: print "You have not specified a CAD Coordinate. Sending to 0,0,0." coord = [0,0,0] else: coordTemp = coordRaw.split(',') coord = [] for x in coordTemp: coord.append(float(x.lstrip())) send2CAD(objs, coord, CADinMeters)
def main(): sourceObjects = rs.GetObjects( message="Select Objects to Move to Other Layers.", preselect=True, select=True) copy = rs.GetBoolean("Do you want to copy this layer?", ("Copy", "No", "Yes"), False) includeList = None excludeList = [".3dm", "Make2D"] targetLayers = sorted(getLayerList.getLayers(includeList, excludeList)) targetLayers = [(x, False) for x in targetLayers] destinationLayer = rs.CheckListBox(targetLayers) if not destinationLayer: return False rs.EnableRedraw(enable=False) sourceObjects = list( filter(lambda x: not rs.IsLayerReference(rs.ObjectLayer(x)), sourceObjects)) for obj in sourceObjects: objLayer = rs.ObjectLayer(obj) parent, child = objLayer.split("::")[-2:] for dLayer in destinationLayer: if dLayer[1] == True: fullDLayer = dLayer[0] + "::" + child if not rs.IsLayer(fullDLayer): print(dLayer[0] + "::" + child, objLayer) fullDLayer = duplicateLayer(child, objLayer, dLayer[0]) if copy[0] == True: copyObj = rs.CopyObject(obj, translation=None) rs.ObjectLayer(copyObj, layer=fullDLayer) else: rs.ObjectLayer(obj, layer=fullDLayer) rs.EnableRedraw(enable=True)
def LayerObjectRandomizer(): prefix = "RandomLayer" separator = "_" objs = rs.GetObjects("Select objects", preselect=True) if not objs: return intObjLen = len(objs) leadZero = len(str(abs(intObjLen))) layer_count = rs.GetInteger("Number of layers to create?", minimum=1, maximum=intObjLen) if not layer_count: return layer_state = rs.GetBoolean("Group the new layers?", ("ParentLayer", "Off", "On"), True) if layer_state is None: return if layer_state[0]: parentLayer = "Random Layer Parent" rs.AddLayer(parentLayer) else: parentLayer = "" rs.EnableRedraw(False) layer_set = [] for i in range(layer_count): iZero = str(i + 1).zfill(leadZero) layer = "{}{}{}".format(prefix, separator, iZero) if not rs.IsLayer(layer): layer_set.append( rs.AddLayer(layer, RandomColor(), parent=parentLayer)) if layer_count == intObjLen: for obj in objs: popIndex = random.choice(layer_set) rs.ObjectLayer(obj, popIndex) layer_set.remove(popIndex) else: for obj in objs: rs.ObjectLayer(obj, random.choice(layer_set))
def wallJoin(layer): if not rs.IsLayer("Wall"): util.initCaadLayer("Wall") if not rs.IsLayer("Axis"): util.initCaadLayer("Axis") haveLayer = True items = (layer, "Off", "On") result = rs.GetBoolean("current layer option", items, True) if result: haveLayer = result[0] oldLockMode = rs.LayerLocked("Axis", True) while True: go = Rhino.Input.Custom.GetObject() go.SetCommandPrompt("Select 4 lines, each two parallel to anthor") go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve go.GetMultiple(4, 4) if go.CommandResult() != Rhino.Commands.Result.Success: rs.LayerLocked("Axis", oldLockMode) return go.CommandResult() if go.ObjectCount != 4: return Rhino.Commands.Result.Failure crv = [] for obj in go.Objects(): crv.append(obj.Geometry().Line) rc, doubleLines = DoubleLine.GetIntersectedDoubleline(crv) if rc: doubleLine0 = doubleLines[0] doubleLine1 = doubleLines[1] if haveLayer: oldLayer = rs.CurrentLayer(layer) doubleLine0.drawIntersectionWithDoubleLine(doubleLine1) if haveLayer: rs.CurrentLayer(oldLayer) rs.DeleteObjects(go.Objects()) else: print "Error: no two doubleLines"
def MultiOffset(): try: obj = rs.GetObjects('Select Closed Curves for Offset', preselect=True) bool = rs.GetBoolean('Offset Direction', ('Direction', 'Inward', 'Outward'), (False)) if bool: bool = bool[0] offset = rs.GetReal('Distance to Offset') for i in obj: if rs.IsCurveClosed(i): if bool == False: pt = rs.CurveAreaCentroid(i) pt = pt[0] rs.OffsetCurve(i, pt, offset) if bool == True: pt = [1000000, 1000000, 1000000] rs.OffsetCurve(i, pt, offset) except: print("Failed to execute") rs.EnableRedraw(True) return
def MultiNestedBoundaryTrimCurves(): msg="Select closed boundary curves for trimming" TCrvs = rs.GetObjects(msg, 4, preselect=False) if not TCrvs: return cCrvs=[crv for crv in TCrvs if rs.IsCurveClosed(crv)] if len(cCrvs)==0: print "No closed trim curves found" return rs.LockObjects(cCrvs) origCrvs = rs.GetObjects("Select curves to trim", 4) rs.UnlockObjects(cCrvs) if not origCrvs : return #plane which is active when trim curve is chosen refPlane = rs.ViewCPlane() if sc.sticky.has_key("TrimSideChoice"): oldTSChoice = sc.sticky["TrimSideChoice"] else: oldTSChoice=True choice = [["Trim", "Outside", "Inside"]] res = rs.GetBoolean("Side to trim away?", choice, [oldTSChoice]) if not res: return trimIns = res[0] #False=Outside tol=sc.doc.ModelAbsoluteTolerance bb=rs.BoundingBox(origCrvs,refPlane) #CPlane box, world coords if not bb: return zVec=refPlane.ZAxis rs.EnableRedraw(False) botPlane=Rhino.Geometry.Plane(bb[0]-zVec,zVec) #check xform=rs.XformPlanarProjection(botPlane) cutCrvs=rs.TransformObjects(cCrvs,xform,True) ccc=CheckPlanarCurvesForCollision(cutCrvs) if ccc: msg="Boundary curves overlap, results may be unpredictable, continue?" res=rs.MessageBox(msg,1+32) if res!= 1: return bSrfs=rs.AddPlanarSrf(cutCrvs) rs.DeleteObjects(cutCrvs) if bSrfs == None: return line=rs.AddLine(bb[0]-zVec,bb[4]+zVec) vols=[] for srf in bSrfs: ext=rs.ExtrudeSurface(srf,line,True) if ext != None: vols.append(ext) rs.DeleteObjects(bSrfs) rs.DeleteObject(line) if len(vols)==0: return exGroup=rs.AddGroup() rs.AddObjectsToGroup(vols,exGroup) rs.Prompt("Splitting curves...") rs.SelectObjects(origCrvs) rs.Command("_Split _-SelGroup " + exGroup + " _Enter", False) splitRes=rs.LastCreatedObjects() rs.DeleteGroup(exGroup) rs.Prompt("Classifying trims...") noSplit=[] for crv in origCrvs: #add curve to list if it has not been split (still exists in doc) id=sc.doc.Objects.Find(crv) if id != None: noSplit.append(crv) errors=0 if splitRes: if len(noSplit)>0: splitRes.extend(noSplit) for crv in splitRes: inside=MultiTestInOrOut(crv,vols) if inside != None: if (inside and trimIns) or (not inside and not trimIns): rs.DeleteObject(crv) else: errors+=1 rs.DeleteObjects(vols) if errors>0: print "Problems with {} curves".format(errors) sc.sticky["TrimSideChoice"] = trimIns
def ScatterBlocks(): try: ################################################################################ # GET OBJECTS AND VARIABLE # ################################################################################ obj = rs.GetObject(message="Select surface to scatter on", filter=8 | 16 | 32, preselect=False, select=False, custom_filter=None, subobjects=False) if not obj: return blocks = rs.GetObjects(message="Select blocks to scatter", filter=4096, group=True, preselect=False, select=False, objects=None, minimum_count=1, maximum_count=0, custom_filter=None) if not blocks: return scatterNum = rs.GetInteger( message="Enter scatter amount", number=100, minimum=1, maximum=10000) if not scatterNum: return userScale = rs.GetReal( "enter scale multiplyer (0 for no scaling)", number=0, minimum=None, maximum=None) userRotation = rs.GetBoolean( "random rotation of blocks?", ("Rotation", "No", "Yes"), (True)) if not userRotation: return isMesh = rs.IsMesh(obj) ptBucket = 0 pointList = [] blockList = [] worldZVector = (rs.WorldXYPlane()).ZAxis rs.EnableRedraw(False) def MeshBrep(brep_id, params): brep = rs.coercebrep(brep_id) if brep: mesh = Rhino.Geometry.Mesh() mesh_parts = Rhino.Geometry.Mesh.CreateFromBrep(brep, params) for mesh_part in mesh_parts: mesh.Append(mesh_part) mesh.Compact() return mesh def TestMeshBrep(): mesh_params = Rhino.Geometry.MeshingParameters.Coarse mesh_brep = MeshBrep(obj, mesh_params) if mesh_brep: mesh = sc.doc.Objects.AddMesh(mesh_brep) return mesh def chunks(lst, n): # list split generator for i in xrange(0, len(lst), n): yield lst[i:i + n] if isMesh == False: mesh = TestMeshBrep() else: mesh = obj # Get and format vertex points in mesh, format from point3d object to float list meshVerts = rs.MeshFaces(mesh, face_type=False) totalArea = rs.MeshArea(mesh) meshFaceCount = rs.MeshFaceCount(mesh) PT01 = meshVerts[0::3] PT01S = [] for i in PT01: i = (i.X, i.Y, i.Z) PT01S.append(i) PT02 = meshVerts[1::3] PT02S = [] for i in PT02: i = (i.X, i.Y, i.Z) PT02S.append(i) PT03 = meshVerts[2::3] PT03S = [] for i in PT03: i = (i.X, i.Y, i.Z) PT03S.append(i) # format list together in order to loop through triangleList = zip(PT01S, PT02S, PT03S) ################################################################################ # POINT SCATTER LOOP # ################################################################################ # loop through the three vertexes forming individual triangles for i in triangleList: a = i[0] # triangle vert 1 b = i[1] # triangle vert 2 c = i[2] # triangle vert 3 # Find area of triangle dist01 = rs.Distance(a, b) dist02 = rs.Distance(a, c) dist03 = rs.Distance(b, c) # Herons formula to find area of triangle by sides s = (dist01 + dist02 + dist03) / 2 tArea = math.sqrt(s*(s-dist01)*(s-dist02)*(s-dist03)) # assign portion of points base on area of triangle, if assignment of points is lower then one, add that to the next assignment numPtsPerUnit = totalArea[1] / scatterNum ptAllocation = tArea / numPtsPerUnit ptBucket = ptBucket + ptAllocation if ptBucket < 1: continue else: pointShare = int(math.floor(ptBucket)) ptBucket = 0 # Vectors from origin to either corner of triangle ac = rs.VectorCreate(c, a) ab = rs.VectorCreate(b, a) originVector = rs.VectorCreate(a, (0, 0, 0)) # Generate random numbers between 0,1. Random scatter onto triangle for i in range(pointShare): r1 = random.random() r2 = random.random() if r1 + r2 < 1: p = r1 * ac + r2 * ab else: p = (1 - r1) * ac + (1 - r2) * ab points = rs.AddPoint(p) pointList.append(points) rs.MoveObjects(points, originVector) ################################################################################ # MOVE BLOCKS TO POINTS WITH ROTATION / SCALE # ################################################################################ # shuffle point list then split list by the number of blocks to scatter. Copy blocks to split lists random.shuffle(pointList) ptDivision = int(len(pointList) / len(blocks)) genList = chunks(pointList, ptDivision) blockIndex = 0 for pts in genList: # looping through split point list and blocks and copying blocks to scatter blockPt = rs.BlockInstanceInsertPoint(blocks[blockIndex]) for pt in pts: vector = rs.VectorCreate(pt, blockPt) newBlock = rs.CopyObject(blocks[blockIndex], vector) # create list of blocks for later modification blockList.append(newBlock) if blockIndex < (len(blocks) - 1): blockIndex += 1 # apply random scaling and rotation to blocks if userRotation[0] == True: for block in blockList: centerPt = rs.BlockInstanceInsertPoint(block) angle = random.randint(0, 360) rs.RotateObject(block, centerPt, angle, worldZVector) for block in blockList: centerPt = rs.BlockInstanceInsertPoint(block) scale = random.uniform((userScale/4), userScale) rs.ScaleObject(block, centerPt, (scale, scale, scale)) # If a mesh was created, delete it, general cleanup if isMesh == False: rs.DeleteObject(mesh) rs.DeleteObjects(pointList) rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
import rhinoscriptsyntax as rs copy = rs.GetBoolean("Do you want to copy this layer?", ("Copy", "No", "Yes"), True) print(copy) def duplicateLayer(name, source, destination): newLayer = rs.AddLayer(name, color=rs.LayerColor(source), parent = destination) matchLayer(newLayer, source) return(newLayer) def matchLayer(name, source): rs.LayerLinetype(name, linetype = rs.LayerLinetype(source)) rs.LayerPrintColor(name, color = rs.LayerPrintColor(source)) rs.LayerPrintWidth(name, width = rs.LayerPrintWidth(source)) sourceObjects = rs.GetObjects(message="Select Object to Move", preselect=True, select=False) allLayers = rs.LayerNames() topList = [] for layer in allLayers: if rs.LayerChildCount(layer) > 0: topList.append(layer) destinationLayer = rs.ListBox(topList) rs.EnableRedraw(enable=False) for obj in sourceObjects: objLayer = rs.ObjectLayer(obj) parent, child = objLayer.split("::") fullDLayer = destinationLayer + "::" + child
def main(): # create globally used array of copies copies = [] biesse_layers = [] # promt convert for biesse items = ( ['convert_to_biesse_layers', 'no', 'yes'], ['export_clamex_txt', 'no', 'yes'], ['open_after_export', 'no', 'yes'], ) default_values = getDefaultValues() options = rs.GetBoolean("conversion options", items, default_values) if not options or len(options) < 2: print "checkAndExport aborted" return convert_for_biesse = options[0] export_clamex_txt = options[1] open_after_export = options[2] storeDefaultValues(convert_for_biesse, export_clamex_txt, open_after_export) # get objects to export objs = rs.GetObjects("select objects to export", 0, True, True) if not objs: print "checkAndExport aborted" return rs.EnableRedraw(False) # create copies of all block contents copies = rs.CopyObjects(objs) # explodeblock copies = explodeBlock(copies) copies = explodeTextObjects(copies) # filter objects to only curves and textobjects copies = filterObjects(copies) # check curves for deviation from c-plane if checkCurvePosition(copies): clamexdata = None if export_clamex_txt: clamexdata = extractClamexOrientation(copies) # obj properties are lost here copies = joinCurves(copies) simplify(copies) if checkCurveIntegrity(copies): # rs.UnselectAllObjects() # check curve dir if not setCurveDir(copies): print "checkAndExport aborted" return #get left bottom rs.EnableRedraw(True) selection_origin = rs.GetPoint("Pick export base point") rs.EnableRedraw(False) # move to origin result = moveToOrigin(copies, selection_origin) if convert_for_biesse: biesse_layers = convertLayers(copies) if result: # export rs.SelectObjects(copies) redraw() filename = rs.SaveFileName("Save", "dxf Files (*.dxf)|*.dxf||") if filename: result = rs.Command('! _-Export "' + filename + '" _Enter', False) if open_after_export: if os.path.isfile( 'C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe' ): print( '"C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe" /nosplash /runscript="_-open ""' + filename + '"" _Enter"') Popen( '"C:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe" /nosplash /runscript="_-open ""' + filename + '"" _Enter"') else: rs.MessageBox( 'dxf cannot be openened automatically. Could not find:\nC:\Program Files\Rhinoceros 5 (64-bit)\System\Rhino.exe' ) filename_stripped, file_extension = os.path.splitext( filename) if clamexdata: with open(filename_stripped + '.txt', 'w') as the_file: the_file.write('') with open(filename_stripped + '.txt', 'a') as the_file: for line in clamexdata: str = 'CLAMEX POSX=%.3f POSY=%.3f RICHTING="%s"\n' % ( line[0], line[1], line[2]) print str the_file.write(str) if result: print 'exported succesfully' rs.DeleteObjects(copies) if biesse_layers and len(biesse_layers) > 0: for layer in biesse_layers: rs.PurgeLayer(layer) rs.EnableRedraw(True)
def getLayerType(object): """ Will get the type of hatch based on the layer structure "LAYER::A-HATCH-TYPE" """ if getParent(object) in parentLayers and rs.ObjectLayer( object) in hatchLayers: return (rs.ObjectLayer(object).split("-")[2]) areasTable = {} hatchnames = set([]) layers = rs.LayerNames() levelLayers = [x for x in layers if re.match("^L\d+|^P\d+|^M\d+", x)] parentLayers = [x for x in levelLayers if "::" not in x] hatchLayers = [x for x in levelLayers if "HATCH" in x] requestType = rs.GetBoolean("Choose output data", ("Output", "Gross_Area", "Unit_Areas"), False) requestType = requestType[0] #Gather all the different hatch types for area analysis for layer in levelLayers: hlayers = [ x.split("::")[1] for x in rs.LayerChildren(layer) if "HATCH" in x ] if len(hlayers) > 0: sublay = ([x.split("-")[2] for x in hlayers]) hatchnames = hatchnames.union(sublay) # sort the level keys L1 = False M1 = False outputLevels = [] inputLevels = list(parentLayers)
if pick == 'pick_face': fkey = mesh_select_face(cell) target_area = rs.GetReal('set target area', 1, 0.1, 1000.0) target_areas[fkey] = target_area elif pick == 'exit': break artist = MeshArtist(cell) artist.draw_facelabels(text=target_areas) rs.EnableRedraw(True) # arearisation options ------------------------------------------------- fix_normal = rs.GetBoolean('Fix face normals?', items=[('fix_normals', 'no', 'yes')], defaults=[False]) target_normals = {} if fix_normal: for fkey in cell.faces(): target_normals[fkey] = cell.face_normal(fkey) # arearise ------------------------------------------------------------- initial_flatness = cell_face_flatness(cell) conduit = MeshConduit(cell) def callback(cell, k, args): current_flatness = cell_face_flatness(cell)
def main(): #select a brep and 2 guide curves filter = ObjectType.Mesh | ObjectType.Brep result, obj = RhinoGet.GetOneObject('选择多重曲面或者网格', False, filter) brep = obj.Brep() or obj.Mesh() id1 = rs.GetCurveObject('第一条引导曲线')[0] curve1 = rs.coercecurve(id1) id2 = rs.GetCurveObject('第二条引导曲线')[0] while id2 == id1: id2 = rs.GetCurveObject('选择一条不同的曲线!')[0] curve2 = rs.coercecurve(id2) step1 = rs.GetInteger('沿第一条曲线的切割间距', number = 5) step2 = rs.GetInteger('沿第二条曲线的切割间距', number = 5) global solid solid = rs.GetBoolean('是否切穿实体?',('选择','否','是'),False)[0] offset_dist = rs.GetReal('生成条带的偏移宽度?(正值向外,负值向内,决定标注字体大小)', number = 2) thickness = rs.GetReal('材料的厚度', number = 0.3) #make ribs breps1, outline1 = make_ribs(brep, curve1, step1, offset_dist, thickness) breps2, outline2 = make_ribs(brep, curve2, step2, offset_dist, thickness) offset_dist = abs(offset_dist) #cutline stroage for s in breps1: cutlines[str(s)] = [] for s in breps2: cutlines[str(s)] = [] #find intersect and make notch line brep_surf = breps1 + breps2 out_lines = outline1 + outline2 intsect(brep_surf, thickness) #arrange to xy plane y1 = 0 y2 = 0 x_max = 0 for i, b in enumerate(brep_surf): outline = out_lines[i] cut = cutlines[str(b)] for c in cut: count = 0 for c2 in outline[:-1]: event = Intersect.Intersection.CurveCurve(c, c2, 0.2, tol) if event: count += 1 if count > 1: outline = outline[0:-1] #0: orient to worldXY plane surf = b.Surfaces[0] from_pl = surf.TryGetPlane()[1] to_pl = Plane.WorldXY xform = Transform.PlaneToPlane(from_pl, to_pl) group1 = Group(str(b)) group1.Add(cut) group1.Add(outline) group = Group('new' + str(b)) group.Add(group1.objects) b_in_breps1 = 0 if b in breps1: text = 'x%d'%i b_in_breps1 = 1 else: text = 'y%d'%(i-len(breps1)) original_box = group1.bbox(plane = from_pl) group1.Add([TextDot(text,from_pl.Origin)]) group1.Display() #arrange 1 : get boundingbox group.Transform(xform) bbox = group.bbox() bbox.Inflate(offset_dist, offset_dist, 0) xlen = (bbox.Max-bbox.Min).X ylen = (bbox.Max-bbox.Min).Y #arrange 2 : rotate according to x,y size if ylen > xlen: xlen, ylen = ylen, xlen rot = Transform.Rotation(math.pi/2, Vector3d.ZAxis,bbox.Center) group.Transform(rot) x_max = xlen if xlen > x_max else x_max #arrange 3 : align bbox cornor to worldXY origin cornor_plane = Plane(bbox.Min, Vector3d.ZAxis) align_xform = Transform.PlaneToPlane(cornor_plane, to_pl) group.Transform(align_xform) #arrange 4 : translate each group to proper position center = bbox.Center if b_in_breps1: move = Vector3d(0,y1,0) y1 += ylen else: move = Vector3d(x_max ,y2,0) y2 += ylen group.Transform(Transform.Translation(move)) group.label(text,offset_dist) group.Display() render(brep_surf) doc.Objects.Hide(obj,True) doc.Views.Redraw()
import rhinoscriptsyntax as rs import Rhino import sys #rs.DeleteObjects(rs.AllObjects()) def check_input(input): #check if user hits cancel if input is None: rs.MessageBox("canceling...quitting scripts...") sys.exit() """Ask for inputs""" type = rs.GetBoolean("Select stairs type", ("type", "straight", "curvy/spiral"), True)[0] check_input(type) curve = rs.GetObject( "Select a curve and make sure it's not parallel to the xy plane", rs.filter.curve) check_input(curve) start_pt = rs.CurveStartPoint(curve) end_pt = rs.CurveEndPoint(curve) if type: spiral = rs.GetBoolean("Select stairs type", ("type", "curvy", "spiral"), True)[0] if spiral: center = rs.GetPoint("Select the center point for your spiral stairs") stair_width = rs.GetReal(message="Enter stair width", number=5)
def RunCommand(is_interactive): global params center = rs.GetPoint(message="Select center point") n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4) m = rs.GetReal(message="Gear module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) ha = rs.GetReal(message="Helix angle", number=params["ha"], minimum=-45, maximum=45) t = rs.GetReal(message="Thickness", number=params["t"], minimum=0) bool_opts = rs.GetBoolean(message="Output options", items=(("PitchCylinder", "No", "Yes"),), defaults=(params["pc"],)) if None in [center, n, m, pa, ha, t, bool_opts]: return 1 # Cancel pc = bool_opts[0] params["n"] = n params["m"] = m params["pa"] = pa params["ha"] = ha params["t"] = t params["pc"] = pc cplane = rs.ViewCPlane() # Get current CPlane cplane = rs.MovePlane(cplane, center) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) gear = generate_gear_crv(teeth=params["n"], module=params["m"], pressure_angle=params["pa"]) pitch = abs((n * m * pi) / tan(radians(ha))) turns = t / pitch if ha < 0: # Left handed helix turns = -turns centerline = rs.AddLine([0, 0, 0], [0, 0, t]) helix = rs.AddSpiral([0, 0, 0], [0, 0, t], pitch=pitch, turns=turns, radius0=(m * n) / 2) helical_gear_srf = rs.AddSweep2(rails=[centerline, helix], shapes=[gear]) rs.DeleteObjects([centerline, helix, gear]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(helical_gear_srf, xform) if pc: circle = generate_pitch_circle_crv(teeth=params["n"], module=params["m"]) pitch_cyl_srf = rs.ExtrudeCurveStraight(circle, start_point=[0, 0, 0], end_point=[0, 0, t]) rs.TransformObjects(pitch_cyl_srf, xform) rs.DeleteObject(circle) rs.SelectObjects([helical_gear_srf, pitch_cyl_srf]) else: rs.SelectObjects(helical_gear_srf) rs.EnableRedraw(True) return 0 # Success
def OffsetCrvLoose(): crv = rs.GetObject("select curve to offset loosely", rs.filter.curve, True) if crv == None: return if not rs.IsCurvePlanar(crv): print "Sorry, but that curve is not planar." return if rs.IsPolyCurve(crv): print "This simple script works only for single open or closed curves" return offset = rs.GetReal("offset amount", 5) if offset == None or offset == 0: return both_sides = rs.GetBoolean("Offset both sides?", ["both_sides", "off", "on"], False)[0] bPeriodic = False #rs.EnableRedraw(False) pts = rs.CurvePoints(crv) degree = rs.CurveDegree(crv) if rs.IsCurvePeriodic(crv): pts = rs.CullDuplicatePoints(pts, 0.01) bPeriodic = True offset_pts = [] offset_pts2 = [] #if both_sides=true plane = rs.CurvePlane(crv) axis = plane.ZAxis for pt in pts: cp = rs.CurveClosestPoint(crv, pt) v = rs.CurveTangent(crv, cp) v = rs.VectorUnitize(v) v *= offset v = rs.VectorRotate(v, 90, axis) pt_ = rs.AddPoint(pt) #create points for offset on one side of the curve movedpt = rs.MoveObject(pt_, v) newpt = rs.coerce3dpoint(movedpt) offset_pts.append(newpt) #create points for offset on other side of the curve movedpt = rs.MoveObject(pt_, -2 * v) newpt = rs.coerce3dpoint(movedpt) offset_pts2.append(newpt) rs.DeleteObject(pt_) nc = Rhino.Geometry.NurbsCurve.Create(bPeriodic, degree, offset_pts) nc2 = Rhino.Geometry.NurbsCurve.Create(bPeriodic, degree, offset_pts2) if not both_sides: if nc.GetLength(0.1) > nc2.GetLength(0.1): #get the longest curve... if offset > 0: #...and add it to the document for positive offsets... sc.doc.Objects.AddCurve(nc) else: #...or the shortest for negative offsets. sc.doc.Objects.AddCurve(nc2) else: if offset > 0: sc.doc.Objects.AddCurve(nc2) else: sc.doc.Objects.AddCurve(nc) else: #add both curves to the document sc.doc.Objects.AddCurve(nc) sc.doc.Objects.AddCurve(nc2) rs.EnableRedraw(True) sc.doc.Views.Redraw()
def RunCommand(is_interactive): sc.doc.EndUndoRecord(sc.doc.CurrentUndoRecordSerialNumber) if '3GS' not in sc.sticky: compas_rhino.display_message('3GS has not been initialised yet.') return scene = sc.sticky['3GS']['scene'] if not scene: return # get ForceVolMeshObject from scene ---------------------------------------- objects = scene.find_by_name('force') if not objects: compas_rhino.display_message("There is no force diagram in the scene.") return force = objects[0] # get global settings ------------------------------------------------------ kmax = scene.settings['Solvers']['arearization.kmax'] refresh = scene.settings['Solvers']['arearization.refreshrate'] tol = scene.settings['Solvers']['arearization.tol'] options = [ 'Iterations', 'Refreshrate', 'Set_target_areas', 'Fix_face_normals', 'Fix_vertices', 'Tolerance' ] # options ------------------------------------------------------------------ fix_vertices = [] target_areas = {} target_text = {} target_colors = {} target_normals = {} while True: rs.EnableRedraw(True) option = compas_rhino.rs.GetString( 'Press Enter to run or ESC to exit.', strings=options) if option is None: scene.clear_layers() scene.clear() scene.update() print("Arearization aborted!") return if not option: break if option == 'Iterations': new_kmax = compas_rhino.rs.GetInteger('Enter number of iterations', kmax, 1, 10000) if new_kmax or new_kmax is not None: kmax = new_kmax elif option == 'RefreshRate': new_refresh = compas_rhino.rs.GetInteger( 'Refresh rate for dynamic visualisation', refresh, 0, 1000) if new_refresh or new_refresh is not None: refresh = new_refresh elif option == 'Set_target_areas': while True: areas = { face: round(force.diagram.face_area(face), 2) for face in force.diagram.faces() if face not in target_areas } force.artist.draw_facelabels(text=areas) rs.EnableRedraw(True) faces = force.select_faces() if not faces or faces is None: break target_area = rs.GetReal("Enter target area value", minimum=0.1, maximum=10000.0) if target_area: for face in faces: current_area = force.diagram.face_area(face) if current_area > target_area: color = (255, 0, 0) text = str(round(current_area, 2)) + ' ---> ' + str( round(target_area, 2)) else: color = (0, 0, 255) text = str(round(current_area, 2)) + ' ---> ' + str( round(target_area, 2)) target_areas[face] = target_area target_text[face] = text target_colors[face] = color scene.clear_layers() scene.clear() scene.update() force.artist.draw_facelabels(text=target_text, color=target_colors) elif option == 'Fix_face_normals': target_normals = {} items = ("Boundary_faces", "No", "Yes"), ("Interior_Faces", "No", "Yes") boundary, interior = rs.GetBoolean("Fix normals of...", items, (False, False)) if boundary: target_normals.update({ face: force.diagram.face_normal(face) for face in force.diagram.halffaces_on_boundaries() }) if interior: for face in force.diagram.faces(): if not force.diagram.is_halfface_on_boundary(face): target_normals[face] = force.diagram.face_normal(face) elif option == 'Fix_vertices': fix_vertices += force.select_vertices() elif option == 'Tolerance': new_tol = compas_rhino.rs.GetReal('Enter areaness tolerance', tol, 0.001, 1.0) if new_tol or new_tol is not None: tol = new_tol if refresh > kmax: refresh = 0 scene.settings['Solvers']['planarization.kmax'] = kmax scene.settings['Solvers']['planarization.refreshrate'] = refresh scene.settings['Solvers']['arearization.tol'] = tol # -------------------------------------------------------------------------- # planarization # -------------------------------------------------------------------------- if refresh > 0: initial_flatness = volmesh_face_areaness(force.diagram, target_areas) conduit = VolmeshConduit(force.diagram) def callback(forcediagram, k, args, refreshrate=refresh): if k % refreshrate: return current_flatness = volmesh_face_areaness(force.diagram, target_areas) face_colordict = compare_initial_current(current_flatness, initial_flatness, color_scheme=i_to_red) conduit.face_colordict = face_colordict conduit.redraw() # planarise with conduit.enabled(): volmesh_planarise( force.diagram, kmax=kmax, target_areas=target_areas, target_normals=target_normals, fix_vkeys=fix_vertices, fix_boundary_normals=False, tolerance_flat=scene.settings['Solvers']['planarization.tol'], tolerance_area=tol, callback=callback, print_result_info=True) # check if there is form diagram ------------------------------------------- objects = scene.find_by_name('form') if not objects: force.check_eq() scene.update() return form = objects[0] # update ------------------------------------------------------------------- form.diagram.update_angle_deviations() form.check_eq() force.check_eq() scene.update() scene.save()
def importTEN_CAD(): savePath0 = rs.OpenFileName("Open", "Autocad (*.dwg)|*.dwg||") items = [["Units", "Meters", "Millimeters"]] defaults = [False] CADinMilli = rs.GetBoolean("Is that CAD file in meters or mm?", items, defaults)[0] explodeBlockBoo = True if savePath0 is None: return rs.EnableRedraw(False) #setup the layers rs.AddLayer("7_REF") rs.AddLayer("CAD", parent="7_REF") fileNameExt = savePath0.split('\\')[-1] fileName = fileNameExt.split('.')[0] savePath1 = '"' + savePath0 + '"' #create layer name now = datetime.date.today() dateList = [] if len(str(now.month)) > 1: month = str(now.month) else: month = "0" + str(now.month) if len(str(now.day)) > 1: day = str(now.day) else: day = "0" + str(now.day) time = str(now.year) + month + day layerName = time + "_" + fileName + "_01" children = rs.LayerChildren("7_REF::CAD") finalNums = [] for child in children: num = rs.LayerName(child, fullpath=False).split("_")[-1] try: finalNums.append(int(num)) except: finalNums.append(0) finalNums.sort() if rs.IsLayer("7_REF::CAD::" + layerName): num = int(finalNums[-1]) + 1 if len(str(num)) < 2: finalNum = "0" + str(num) else: finalNum = str(num) layerName = time + "_" + fileName + "_" + finalNum par = rs.AddLayer("7_REF") cat = rs.AddLayer("CAD", parent=par) element = rs.AddLayer(layerName, parent=cat) rs.CurrentLayer(element) #get intial list of all layers in the file currentLayers = rs.LayerNames() rs.Command('_-Import ' + savePath1 + ' _Enter') #get new layers added endLayersNames = rs.LayerNames() #newLayers = [item for item in currentLayers if item not in endLayersNames] newLayers = diff(endLayersNames, currentLayers) print newLayers for layer in newLayers: rs.ParentLayer(layer, element) objects = rs.ObjectsByLayer(layer) if rs.IsLayerEmpty(layer): rs.DeleteLayer(layer) else: for obj in objects: if rs.IsDimension(obj): rs.DeleteObject(obj) elif rs.IsHatch(obj): rs.DeleteObject(obj) #Get all the imported geometry allObjects = [] finalLayers = rs.LayerChildren(rs.CurrentLayer()) for finalLayer in finalLayers: allObjects.append(rs.ObjectsByLayer(finalLayer)) finalAllObjects = [item for sublist in allObjects for item in sublist] #Format Coordinate try: rawCoordinate = rs.GetDocumentData("Project Info", "CAD coordinate (X,Y,Z)") except: print "No CAD Coordinate specified in the Project Info" rawCoordinate = (0, 0, 0) coordinate = rawCoordinate.split(",") print "Aa" try: for i in range(0, 3): coordinate[i] = float(coordinate[i]) except: coordinate = None if coordinate is None: print "CAD coordinate has an error" else: #move all objects negVec = rs.VectorReverse(coordinate) rs.MoveObjects(finalAllObjects, negVec) if CADinMilli: rs.ScaleObjects(finalAllObjects, [0, 0, 0], [.001, .001, .001]) importGroup = rs.AddGroup(str(layerName)) rs.AddObjectsToGroup(finalAllObjects, importGroup) rs.ZoomSelected() print "Import EXECUTED" rs.EnableRedraw(True) return None
def RunCommand(is_interactive): global params center = rs.GetPoint(message="Select center point") n = rs.GetInteger(message="Number of teeth", number=params["n"], minimum=4) m = rs.GetReal(message="Gear module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) ca = rs.GetReal(message="Cone angle", number=params["ca"], minimum=0, maximum=180) bool_opts = rs.GetBoolean(message="Output options", items=(("PitchCone", "No", "Yes"),), defaults=(params["pc"],)) if None in [center, n, m, pa, ca, bool_opts]: return 1 # Cancel pc = bool_opts[0] params["n"] = n params["m"] = m params["pa"] = pa params["ca"] = ca params["pc"] = pc cplane = rs.ViewCPlane() # Get current CPlane cplane = rs.MovePlane(cplane, center) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) gear = generate_gear_crv(teeth=params["n"], module=params["m"], pressure_angle=params["pa"], cone_angle=params["ca"]) # Calculate pitch cone tip cone_tip = [0, 0, (m * n / 2) / tan(radians(ca/2))] bevel_gear_srf = rs.ExtrudeCurvePoint(gear, cone_tip) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(bevel_gear_srf, xform) if pc: circle = generate_pitch_circle_crv(teeth=params["n"], module=params["m"]) pitch_cone_srf = rs.ExtrudeCurvePoint(circle, cone_tip) rs.TransformObjects(pitch_cone_srf, xform) rs.DeleteObjects([gear, circle]) rs.SelectObjects([bevel_gear_srf, pitch_cone_srf]) else: rs.DeleteObject(gear) rs.SelectObjects(bevel_gear_srf) rs.EnableRedraw(True) return 0 # Success
# first point pt_sum = rs.PointCoordinates(rs.CreatePoint(ids[0])) # sum rest of points for i in xrange(1, len(ids)): pt_sum += rs.PointCoordinates(ids[i]) # divide with amount of points to get average pt_sum = pt_sum / len(ids) return pt_sum widgets = rs.GetObjects() rotate = rs.GetBoolean("Rotate items?", ("Rotate", "No", "Yes"), (True)) bounds = rs.BoundingBox(widgets) print(bounds) x_dist = rs.Distance(bounds[0], bounds[1]) y_dist = rs.Distance(bounds[1], bounds[2]) z_dist = rs.Distance(bounds[3], bounds[4]) for ind, w in enumerate(widgets): # print(rotate) # if rotate: # print("ROTATE") # centerPt = FindCentroidOfPoints(bounds) # print(centerPt) # rs.RotateObject(w, centerPt, random.uniform(0,360)) # x = random.uniform(0, x_dist) y = random.uniform(0, y_dist)