def CaptureDisplayModesToFile(): try: displayModeNames = [] displayModeBool = [] displayModesChecked = [] ######## #Get current display mode originalDisplayMode = rc.RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport.DisplayMode.LocalName ######## #Get default display mode selection if 'CaptureDisplayModes-DisplayModes' in sc.sticky: dict = sc.sticky['CaptureDisplayModes-DisplayModes'] for each in rc.Display.DisplayModeDescription.GetDisplayModes(): displayModeNames.append(each.EnglishName) if each.EnglishName in dict: displayModeBool.append(dict[each.EnglishName]) else: displayModeBool.append(False) else: for each in rc.Display.DisplayModeDescription.GetDisplayModes(): displayModeNames.append(each.EnglishName) displayModeBool.append(False) results = rs.CheckListBox(zip(displayModeNames, displayModeBool), 'Select Display Modes', 'Capture Display Modes To File') if results is None: return ######## #Save display modes to sticky resultDict = {} for each in results: resultDict[each[0]] = each[1] sc.sticky['CaptureDisplayModes-DisplayModes'] = resultDict for each in results: if each[1]: displayModesChecked.append(each[0]) ######## #Get default filename date = utils.GetDatePrefix() activeView = sc.doc.Views.ActiveView.ActiveViewport.Name if activeView is None: activeView = 'VIEW' path = rs.SaveFileName('Export All Display Modes', "PNG (*.png)|*.png||", filename = date+'_'+activeView) if path is None: return ######## #Get sizes from sticky if 'catpureDisplays-width' in sc.sticky: widthDefault = sc.sticky['catpureDisplays-width'] else: widthDefault = 5100 if 'catpureDisplays-height' in sc.sticky: heightDefault = sc.sticky['catpureDisplays-height'] else: heightDefault = 3300 width = rs.GetInteger('Image Width', number = widthDefault, minimum = 200, maximum = 20000) height = rs.GetInteger('Image Height', number = heightDefault, minimum = 200, maximum = 20000) ######## #Save sizes to sticky sc.sticky['catpureDisplays-width'] = width sc.sticky['catpureDisplays-height'] = height ####################################################################### #Export the images count = 0 for name in displayModesChecked: try: rs.ViewDisplayMode(mode = name) exportImage(path, name, width, height) count += 1 except: pass print "{} Images saved to {}".format(count , os.path.abspath(os.path.join(path, os.pardir))) result = True except: result = False ######## #Restore original display mode if originalDisplayMode is not None: rs.ViewDisplayMode(mode = originalDisplayMode) ######## #Save analytics try: utils.SaveFunctionData('IO-Capture Display Modes', [__version__, str(displayModesChecked), width, height, result]) except: print "Failed to save function data" return result
import rhinoscriptsyntax as rs rs.EnableRedraw(False) #Get Kerf parameters for bending obj_0 = rs.GetObject("Select the bottom line", 4) obj_1 = rs.GetObject("Select the left line", 4) l = rs.GetInteger("Segments length [mm]") dis = rs.GetInteger("Distance x from the segments [mm]") sp = rs.GetInteger("Distance y from the segments [mm]") # Set the length of the segment L = rs.CurveLength(obj_0) x = (L/(l+dis)) xint = int(x+0.5) d = L/xint-l L_2 = rs.CurveLength(obj_1) x_2 = (L_2/sp) xint_2 = int(x_2+0.5) s = L_2/xint_2 #----------Generate pattern A----------# joins = [] a = rs.AddPoint(rs.CurveStartPoint (obj_0)) joins.append(a) p = rs.CopyObject(a,[(l/2),0,0]) joins.append(p) for i in range (1, (xint)): c = rs.CopyObject(p,[d,0,0]) joins.append(c)
#2D Point Grid with Circles generated with an Attractor Point #This script will create a 2D grid of points and circle centered on each point. #Circle radius is driven by the distance from the attractor to the point defining the center of the circle. import rhinoscriptsyntax as rs #spacing variable sets distance between points spacing = 3 #Dictionary to hold points pts = {} #Prompt user to set X and Y extents, default of 20 iMax = rs.GetInteger("Please enter max number of points in x", 20) jMax = rs.GetInteger("Please enter max number of points in y", 20) #select an attractor pt. This will drive the size of the circles attPt = rs.GetObject("Select attractor point", 1) #nested For loops for X and Y Domains for i in range(iMax): for j in range(jMax): #define x,y,(z) x = i * spacing y = j * spacing #z will always be 0 for a 2D Grid z = 0 #Store the points in the dictionary using the iterators as the reference keys pts[(i, j)] = [x, y, z]
def outline_region(): go = Rhino.Input.Custom.GetObject() go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve default_length = sc.sticky["length"] if sc.sticky.has_key("length") else 100 default_delete = sc.sticky["delete"] if sc.sticky.has_key("delete") else True opt_delete = Rhino.Input.Custom.OptionToggle(default_delete,"No","Yes") go.SetCommandPrompt("Select Curves") go.AddOptionToggle("DeleteInput", opt_delete) go.GroupSelect = True go.SubObjectSelect = False go.AcceptEnterWhenDone(True) go.AcceptNothing(True) go.EnableClearObjectsOnEntry(False) go.GroupSelect = True go.SubObjectSelect = False go.DeselectAllBeforePostSelect = False res = None bHavePreselectedObjects = False while True: res = go.GetMultiple(1,0) if res == Rhino.Input.GetResult.Option: #print res go.EnablePreSelect(False, True) continue #If not correct elif res != Rhino.Input.GetResult.Object: print "No curves selected!" return Rhino.Commands.Result.Cancel if go.ObjectsWerePreselected: bHavePreselectedObjects = True go.EnablePreSelect(False, True) continue break input_curves = [] for i in xrange(go.ObjectCount): b_obj = go.Object(i).Object() input_curves.append(b_obj.Id) #Get length extension_length = rs.GetInteger(message="Enter Extension Length",number=default_length) if not extension_length: rs.EnableRedraw(True) print "No Extension Length entered." return False arr_preview_geom = get_preview_geometry(input_curves) for indCrv in arr_preview_geom: rs.ExtendCurveLength(indCrv,0,2,extension_length) rs.EnableRedraw(False) #Get curveboolean and display it region_was_created = True rs.UnselectAllObjects() rs.SelectObjects(arr_preview_geom) rs.Command("_-CurveBoolean _AllRegions _Enter") pcurve_outline = rs.LastCreatedObjects() if isinstance(pcurve_outline,list): preview_srf = rs.AddPlanarSrf(pcurve_outline) rs.LockObjects(arr_preview_geom) rs.LockObjects(preview_srf) else: region_was_created = False rs.LockObjects(arr_preview_geom) preview_srf = [] rs.EnableRedraw(True) rs.Redraw() #Set up input object go = Rhino.Input.Custom.GetOption() optint = Rhino.Input.Custom.OptionDouble(extension_length) prompt = "Press Enter to accept" warning = "Insufficient overlap length. " s = prompt if region_was_created else warning+prompt go.SetCommandPrompt(s) go.AddOptionDouble("ExtensionLength", optint) go.AddOptionToggle("DeleteInput", opt_delete) go.AcceptEnterWhenDone(True) go.AcceptNothing(True) #control flow: can distinguish between inserting an option, cancelling, and pressing enter res = None while True: res = go.Get() rs.EnableRedraw(False) region_was_created = True #If new option entered, redraw a possible result if res == Rhino.Input.GetResult.Option: #Delete old preview rs.UnlockObjects(preview_srf+arr_preview_geom) rs.DeleteObjects(preview_srf+arr_preview_geom) if isinstance(pcurve_outline,list): rs.DeleteObjects(pcurve_outline) rs.SelectObjects(input_curves) #Draw new preview arr_preview_geom = get_preview_geometry(input_curves) if not extension_length: return False for indCrv in arr_preview_geom: rs.ExtendCurveLength(indCrv,0,2,optint.CurrentValue) rs.UnselectAllObjects() rs.SelectObjects(arr_preview_geom) rs.Command("_-CurveBoolean _AllRegions _Enter") pcurve_outline = rs.LastCreatedObjects() if isinstance(pcurve_outline,list): preview_srf = rs.AddPlanarSrf(pcurve_outline) rs.LockObjects(arr_preview_geom) rs.LockObjects(preview_srf) else: rs.LockObjects(arr_preview_geom) preview_srf = [] region_was_created = False rs.EnableRedraw(True) s = prompt if region_was_created else warning+prompt go.SetCommandPrompt(s) continue #If accepted, leave loop elif res == Rhino.Input.GetResult.Nothing: break #If cancelled, delete working geometry elif res != Rhino.Input.GetResult.Option: rs.UnlockObjects(preview_srf) rs.UnlockObjects(arr_preview_geom) rs.DeleteObjects(preview_srf) rs.DeleteObjects(arr_preview_geom) rs.DeleteObjects(pcurve_outline) rs.EnableRedraw(True) return Rhino.Commands.Result.Cancel #Clean up if successful if opt_delete.CurrentValue == True: rs.DeleteObjects(input_curves) rs.UnlockObjects(preview_srf) rs.UnlockObjects(arr_preview_geom) rs.DeleteObjects(preview_srf) rs.DeleteObjects(arr_preview_geom) if isinstance(pcurve_outline,list): rs.SelectObjects(pcurve_outline) sc.sticky["length"] = optint.CurrentValue sc.sticky["delete"] = opt_delete.CurrentValue rs.EnableRedraw(True)
def GetAllLayerNames(): allLayerNames = [] layerNums = [] setupVariables() global csvPath layerData = GetLayerData(csvPath) for i in range(0, 10000, 1000): layerNumsSet = GetChildNumbers(i, layerData) layerNumsSet.sort() layerNums = layerNums + layerNumsSet for each in layerNums: allLayerNames.append(GetLayerNameByNumber(each)) return allLayerNames if __name__ == "__main__" and utils.IsAuthorized(): setupVariables() layerNumRequested = rs.GetInteger( "Enter layer number to add to the document", number=10000, minimum=0, maximum=10000) AddLayerByNumber(layerNumRequested) utils.SaveToAnalytics('layers-' + str(layerNumRequested)) #print GetLayerNameByNumber(layerNumRequested)
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 # this pulls in all of rhino's native commands into python, # so from here on out we can just say rs.[whatever] to access rhino's stuff # a list of rhino python commands is here: http://www.rhino3d.com/5/ironpython/index.html # first, we need some information from the user: numberOfPoints = rs.GetInteger("how many data points?") # do the same for the number of data points radius = rs.GetReal("what's the radius of your sun-sphere?") # get a radius for the sphere the sun's going to rotate around rs.AddLayer("sun sphere", [0,0,255]) # make a new layer for the sphere itself, and color it blue rs.AddLayer("sun rays", [255,0,0]) # make a new layer for the rays shooting inwards from the sun, color it red rs.CurrentLayer("sun sphere") # go to the sun sphere layer sunSphere = rs.AddSphere([0,0,0], radius) # draw the sun sphere at the origin with a radius of whatever is in the variable "radius" (and store it in a variable called sunSphere) # saying if(something) is a boolean test - checks to see whether the statements are true. # it just checks to see whether there's anything positive in these variables if ((numberOfPoints > 0) and (radius > 0)): dayName = rs.GetString("which day is this? (no spaces!)") # ask for a label (text blocks are called 'strings') for the eventual curve object print "current day = ", dayName # print it to the command line, just to make sure it worked rs.AddLayer(dayName, [255,255,255]) # make a new layer for each day - make everything on them white, just to distinguish # (you can change [255,255,255] to any color, or delete that part) rs.CurrentLayer(dayName) # go to that layer listOfPoints = [] # setup a list (empty at this point) to hold all the points for the curve rs.AddPoint([0,radius,0]) # put down one point at x=0, y= the radius of the sun-sphere, z=0 starterPt = rs.FirstObject() # FirstObject grabs the last thing created, in this case that point we just made - let's name that 'starterPt'
import rhinoscriptsyntax as rs ### rs.GetInteger(msg, defalut, min, max) tmp_num_0 = rs.GetInteger("Please Enter an Integer-A", 10, 0, 100) tmp_num_1 = rs.GetInteger("Please Enter an Integer-B", 2) print "Integer-A + Interger-B =", tmp_num_0 + tmp_num_1 ### rs.GetString(msg, defalut) tmp_txt = rs.GetString("Please Enter Your Name", "aaa") print "Hello,", tmp_txt
def start(): from compas.geometry.algorithms.smoothing import mesh_smooth_centroid from compas.geometry.algorithms.smoothing import mesh_smooth_area from compas_pattern.algorithms.smoothing import define_constraints from compas_pattern.algorithms.smoothing import apply_constraints guid = rs.GetObject('get mesh') dense_mesh = RhinoGeometry.from_guid(guid) vertices, faces = dense_mesh.get_vertices_and_faces() dense_mesh = Mesh.from_vertices_and_faces(vertices, faces) #lines = rs.GetObjects('lines', filter = 4) #edges = [[rs.CurveStartPoint(line), rs.CurveEndPoint(line)] for line in lines] #dense_mesh = Mesh.from_lines(edges) #faces = list(dense_mesh.faces()) #for fkey in faces: # if len(dense_mesh.face_vertices(fkey)) > 10: # delete_face(dense_mesh, fkey) # print '-1 face' #dense_mesh = conway_ambo(dense_mesh) #dense_mesh = conway_dual(dense_mesh) #dense_mesh = conway_gyro(dense_mesh) #dense_mesh = conway_dual(dense_mesh) #dense_mesh = conway_gyro(dense_mesh) #dense_mesh = conway_kis(dense_mesh) #rs.EnableRedraw(False) #draw_mesh(dense_mesh) #rs.EnableRedraw(True) #return surface_guid = rs.GetSurfaceObject('surface constraint')[0] smooth_mesh = dense_mesh.copy() smoothing_iterations = rs.GetInteger('number of iterations for smoothing', number=20) damping_value = rs.GetReal('damping value for smoothing', number=.5) rs.EnableRedraw(False) #constraints, surface_boundaries = custom_constraints(smooth_mesh, surface_guid) constraints, surface_boundaries = define_constraints( smooth_mesh, surface_guid) rs.EnableRedraw(False) fixed_vertices = [ vkey for vkey, constraint in constraints.items() if constraint[0] == 'fixed' ] mesh_smooth_area(smooth_mesh, fixed=fixed_vertices, kmax=smoothing_iterations, damping=damping_value, callback=apply_constraints, callback_args=[smooth_mesh, constraints]) smooth_mesh_guid = draw_mesh(smooth_mesh) #layer = 'smooth_mesh' #rs.AddLayer(layer) #rs.ObjectLayer(smooth_mesh_guid, layer = layer) rs.EnableRedraw(True)
class GhcompService(rpyc.ClassicService): def on_connect(self, conn): print('Incoming connection.') super(GhcompService, self).on_connect(conn) import ghpythonlib.components as ghcomp self.ghcomp = ghcomp def on_disconnect(self, conn): print('Disconnected.') def get_component(self, component_name, is_cluster_component=False): component = getattr(self.ghcomp, component_name) if is_cluster_component: component = getattr( component, component_name ) # TODO: improve ghcomp to get clusters the same way we get compiled components, thus removing the need for a custom getter return component if __name__ == '__main__': import rhinoscriptsyntax as rs port = rs.GetInteger("Server bind port", 18871, 1023, 65535) server = OneShotServer(GhcompService, hostname='localhost', port=port, listener_timeout=None) server.start()
new_keys = [] for key in keys: point = mesh_obj.vertex_coordinates(key) x, y, z = add_vectors(point, vec) new_keys.append(mesh_obj.add_vertex(x=x, y=y, z=z)) mesh_obj.delete_face(fkey) mesh_obj.add_face(new_keys) for i, key in enumerate(keys): mesh_obj.add_face( [keys[i - 1], keys[i], new_keys[i], new_keys[i - 1]]) if selection == "steps": steps = rs.GetInteger("Subdivision steps", steps, 1, 5) # mesh_obj.draw(name="control", # layer="SD_mesh", # clear=False, # redraw=True, # show_faces=False, # rename to display_faces? # show_vertices=False, # rename to display_vertices? # show_edges=False, # rename to display_edges? # vertex_color=None, # edge_color=None, # face_color=None, # show_faces_mesh=True) # print mesh_obj # break if break_flag:
""" SHL Architects 07-02-2019 Sean Lamb (Developer) [email protected] """ import rhinoscriptsyntax as rs import shl_toolbox_lib.util as wut reload(wut) num = rs.GetInteger("Enter number of layers") prefix = rs.GetString("Enter layer name prefix") colors = wut.equidistant_hsv_color(num, 0.4) for i in xrange(num): rs.AddLayer(prefix + "-" + str(i), colors[i])
import rhinoscriptsyntax as rs numberofpoints = rs.GetInteger("how many points?") radius = rs.GetReal("what's the radius?") rs.AddLayer("Sphere", [255, 0, 0]) rs.CurrentLayer("Sphere") Sunsphere = rs.AddSphere([0, 0, 0], radius) if ((numberofpoints > 0) and (radius > 0)): #stuff if true print "we're good" dayname = rs.GetString("what day is this?") print "the entered day name is:", dayname rs.AddLayer(dayname, [0, 0, 255]) rs.CurrentLayer(dayname) listofpoints = [] startpoint = rs.AddPoint([0, radius, 0]) for i in range(numberofpoints): elevation = rs.GetReal("what's the elevation?") azimuth = rs.GetReal("what's the azimuth?") azimuth *= -1 rs.RotateObject(startpoint, [0, 0, 0], elevation, axis=[1, 0, 0],
def BatchCapture(): try: namedViews = rs.NamedViews() if len(namedViews) < 1: print "There are no Named Views in this file." return None #Prepare checklis items = [] for view in namedViews: items.append([view, False]) #Checklist returnedVals = rs.CheckListBox(items, "Select Views to Export", "Batch Capture") if returnedVals is None: return chosenViews = [] for val in returnedVals: if val[1]: chosenViews.append(val[0]) if len(chosenViews) < 1: return defaultFilename = utils.GetDatePrefix() + '_FILENAME' #path = rs.SaveFileName('Batch Capture', "PNG (*.png)|*.png||", filename = date+'_FILENAME') path = rs.SaveFileName('Save view location', "PNG (*.png)|*.png|JPEG (*.jpeg)|*.jpeg||", filename = defaultFilename, extension = ".png") if path is None: return #Check if in stick if 'batchCapture-width' in sc.sticky: defaultWidth = sc.sticky['batchCapture-width'] else: defaultWidth = 5100 if 'batchCapture-height' in sc.sticky: defaultHeight = sc.sticky['batchCapture-height'] else: defaultHeight = 3300 #Get output width width = rs.GetInteger('Width', defaultWidth, 200, 10000 ) if width is None: return sc.sticky['batchCapture-width'] = width #Get output height height = rs.GetInteger('Height', defaultHeight, 200, 10000 ) if height is None: return sc.sticky['batchCapture-height'] = height rs.AddNamedView("temp") baseName = os.path.splitext(path)[0] for eachView in chosenViews: rs.RestoreNamedView(eachView) splitPath = path.Split(".") if splitPath[-1] == "png": filePath = baseName + "_" + eachView + ".png" result = SafeCapture_PNG(filePath, width, height) else: filePath = baseName + "_" + eachView + ".jpg" result = SafeCapture_JPG(filePath, width, height) #return to original view rs.RestoreNamedView("temp") rs.DeleteNamedView("temp") result = True except: result = False utils.SaveFunctionData('IO-BatchCapture', [__version__] + chosenViews) return result
targetFolderUserObjects) result = True except: print "FAIL-----Could not copy dependencies. You must have Grasshopper open. Close and reopen Rhino, then run this again." result = False utils.SaveFunctionData( 'Standards-PCPA GH Dependencies', [numberOfLibraryObjects, numberOfUserObjects, result]) if __name__ == "__main__" and utils.IsAuthorized(): PreloadCheck() standardsRequested = rs.GetInteger("Standards to import", number=0, minimum=0, maximum=10000) fileLocations = config.GetDict() if standardsRequested == 0: LoadPCPAMaterials(fileLocations['Material File']) elif standardsRequested == 1: SetTemplateFolder(fileLocations['Template Folder']) SetTemplateFile(fileLocations['Template File']) utils.SaveToAnalytics('standards-Set Template') elif standardsRequested == 2: LoadPCPAComponents(fileLocations['PCPA GH Components']) LoadGHDependencies(fileLocations) utils.SaveToAnalytics('standards-Load GH Components') elif standardsRequested == 3: LoadAcadSchemes(fileLocations['ACAD Scheme Folder']) utils.SaveToAnalytics('standards-Load ACADSchemes')
def CA(): # input gridSizeX = rs.GetInteger("grid size X", 10) gridSizeY = rs.GetInteger("grid size Y", 10) steps = rs.GetInteger("how many steps", 20) listCells = [None]*gridSizeX # make first generation for x in range(gridSizeX): cells = [None]*gridSizeY for y in range(gridSizeY): if rnd.random() > 0.5: cells[y] = 1 else: cells[y] = 0 listCells[x] = cells # iterate through generations - steps for i in range(steps): rs.EnableRedraw(False) # loop x for x in range(gridSizeX): # loop y for y in range(gridSizeY): # torus space xMinus = x-1 if x==0: xMinus = gridSizeX-1 xPlus = x+1 if x==gridSizeX-1: xPlus = 0 yMinus = y-1 if y==0: yMinus = gridSizeY-1 yPlus = y+1 if y==gridSizeY-1: yPlus = 0 # sum neighbors sum = 0 sum = sum + listCells[xMinus][yMinus] sum = sum + listCells[x][yMinus] sum = sum + listCells[xPlus][yMinus] sum = sum + listCells[xMinus][y] sum = sum + listCells[xPlus][y] sum = sum + listCells[xMinus][yPlus] sum = sum + listCells[x][yPlus] sum = sum + listCells[xPlus][yPlus] # rules # if alive and < 2 neighbors - dies = 0 # if alive and == 2 or == 3 neighbors - alive = 1 # if alive and > 3 neighbors - dies = 0 # if dead and ==3 neighbors - alive = 1 if listCells[x][y] == 1: if sum < 2: listCells[x][y] = 0 if sum == 2 or sum == 3: listCells[x][y] = 0 if sum > 3: listCells[x][y] = 1 else: if sum == 3: listCells[x][y] = 0 # render if listCells[x][y] == 1: rs.AddPoint([x,y,i]) #rs.AddBox([ [x,y,i], [x+1,y,i], [x+1,y+1,i], [x,y+1,i], [x,y,i+1], [x+1,y,i+1], [x+1,y+1,i+1], [x,y+1,i+1]]) rs.EnableRedraw(True)
#Python Workshop Lesson:14 #http://www.designalyze.com/int2pythonscripting13_NotSoSimpleRecursion import rhinoscriptsyntax as rs def RecursiveScale(objID,scalePt,scaleFact, scaleVect, num): if num == 0: return 0 else: sc = (1.0 / scaleFact) scaleVect = [x - sc for x in scaleVect] rs.ScaleObject(objID, scalePt, scaleVect, True) return RecursiveScale(objID, scalePt, scaleFact, scaleVect, num-1) objID = rs.GetObject() scalePt = rs.GetPoint("Pick Scale Center") scaleFact = rs.GetReal("Enter a scale Factor", 10, 0) scaleVect = [1.0, 1.0, 1.0] num = rs.GetInteger("Enter a the number of iterations", 10, 1) RecursiveScale(objID, scalePt, scaleFact, scaleVect, num)
#of objects and functions in Rhino import rhinoscriptsyntax as rs #Let's work in 2D first (in Rhino, only look at Top window). #Points in 2D can be represented by a list of numbers [x, y, 0] p1 = [1, 12, 0] p2 = [-2, 2, 0] #and drawn to the canvas by using a built-in function rs.AddPoint(p1) rs.AddPoint(p2) #we can draw a collection of points, such as this zig-zag, #based on user-inputted data count = rs.GetInteger("Number of points") height = rs.GetInteger("Height of zig-zag") if count: for i in range(count): x = i if (i % (2 * height) < height): y = i % height else: y = height - (i % height) rs.AddPoint([x, y, 0]) #this is a collecton of points along a 'curve' defined by a #mathematical function, y = |x|sin(5x), for a specified range #and a fixed stepsize in x (representing angle in degrees). #For fixed intervals, the built-in function frange is very useful
""" Author: Angel Linares Garcia. Date: 150821 Description: This scripts takes one selected curve and creates N offsets at D distance. """ ############################## import rhinoscriptsyntax as rs strCrv0 = rs.GetCurveObject("Select curve", True) intTimes = rs.GetInteger("Number of repetitions") dblDist = rs.GetReal("Distance between curves") pt0 = rs.GetPoint("Selec offset side") rs.EnableRedraw(False) for i in range(intTimes): newCurve = rs.OffsetCurve(strCrv0[0], pt0, dblDist * (i + 1)) strCrv = newCurve rs.EnableRedraw(True)
# use rhinoscriptsyntax to get all the functions in one shot import rhinoscriptsyntax as rs import random import time import math import Rhino numCyls = rs.GetInteger("Number of sticks") spread = rs.GetInteger("spread") seed = rs.GetPoint("seed point") print "seed point: ", seed[0], " / ", seed[1], " / ", seed[2] pi = math.pi if numCyls and spread and seed: for a in range(numCyls): x = seed[0] y = seed[1] z = seed[2] # points.append([seed[0], seed[1], seed[2]]) offset = random.random() * spread stick = rs.AddCylinder([x + offset, y, z], random.random() * 10, random.random() * 0.5, True) rs.RotateObject(stick, seed, random.random() * 360) rs.ZoomExtents(view=None, all=True)
def __init__(self): rs.AddLayer("garbage", visible=False) self.max = 500 self.fsr = 3 self.loc_pts = [] self.res_obj = [] self.num_copies = 1 self.site_crv = rs.GetObject('pick site boundary') self.site_copy = [] FileName = "input.csv" FilePath = rs.GetString( "Enter the working directory for the program : ") if (FilePath == ""): FilePath = 'c:/nir_dev/temp/output_1' try: os.stat(FilePath) except: print('folder does not exist') return os.chdir(FilePath) req_fsr = 3.0 """ # since total area for each function is given, fsr required is not applicable try: self.fsr=float(rs.GetString("Enter FSR required")) except: print('this is incorrect data type default value of fsr=3.0 assumed') """ n = rs.GetInteger('Enter number of variations required') if (n == 0 or n == None): n = 1 a = int(math.sqrt(n)) b = int(math.sqrt(n)) self.num_copies = n self.max = self.getMax() req_str_li = [] k = 0 rs.ClearCommandHistory() print('processing...') rs.EnableRedraw(False) # this is the correct field for i in range(0, a, 1): for j in range(0, b, 1): print('iteration %s in RunProc()' % (k)) temp_site_crv = rs.CopyObject(self.site_crv, [self.max * i, self.max * j, 0]) self.site_copy.append(temp_site_crv) m = main(FileName, self.fsr, temp_site_crv) r = m.getInpObj() self.res_obj.append(r) m.genFuncObj_Site() s = m.retResult() req_str_li.append(s) pt = rs.CurveAreaCentroid(temp_site_crv)[0] self.loc_pts.append(pt) self.addLabel(k, temp_site_crv) k += 1 try: self.writeToCsv(k, req_str_li) except: pass # end of correct code block # start of revised code block """ for i in range(0,a,1): for j in range(0,b,1): print('iteration %s in RunProc()'%(k)) temp_site_crv=self.site_crv#rs.CopyObject(self.site_crv,[self.max*i,self.max*j,0]) self.site_copy.append(temp_site_crv) m=main(FileName,self.fsr,temp_site_crv) r=m.getInpObj() self.res_obj.append(r) m.genFuncObj_Site() s=m.retResult() req_str_li.append(s) pt=rs.CurveAreaCentroid(temp_site_crv)[0] self.loc_pts.append(pt) self.addLabel(k,temp_site_crv) rs.RenderColor(1,(255,255,255)) str_img=str(k+1)+'.png' rs.Redraw() #rs.Command("_ViewCaptureToFile",tr_img) rs.CreatePreviewImage(str_img, "Perspective", (1200,1024), 4, False) print('img created') m.delResult() k+=1 self.writeToCsvPcp(k,req_str_li) """ #end of revised code block rs.EnableRedraw(True)
import rhinoscriptsyntax as rs import createBox import exportObjs xNum = rs.GetInteger("X number", 5, 1) yNum = rs.GetInteger("Y number", 5, 1) boxes = createBox.Run(xNum, yNum) if boxes is None or len(boxes) == 0: rs.MessageBox("No objects to export") else: dir = rs.BrowseForFolder(None, "Select a folder to save files") exportObjs.Run(boxes, dir, "3dm")
clr.AddReference('System.Core') clr.AddReference('RhinoInside.Revit') clr.AddReference('RevitAPI') clr.AddReference('RevitAPIUI') from System.Linq import Enumerable from Autodesk.Revit.DB import * import Rhino as rh from RhinoInside.Revit import Revit, Convert import ghpythonlib as gh import scriptcontext as sc import rhinoscriptsyntax as rs # Select polylines from rhino obj = rs.GetObjects("Please select multiple polyline curves", 0, True, True) bool2 = rs.GetInteger("Press 0 to generate areas and 1 to generate rooms") input_curves = [] for o in obj: input_curves.append(rs.coercecurve(o)) doc = Revit.ActiveDBDocument tol = sc.doc.ModelAbsoluteTolerance _t = 100000000 # Filter out various revit elements levels = FilteredElementCollector(doc).OfClass(Level) rooms = FilteredElementCollector(doc).OfClass(SpatialElement).OfCategory( BuiltInCategory.OST_Rooms).ToElements() areas = FilteredElementCollector(doc).OfClass(SpatialElement).OfCategory( BuiltInCategory.OST_Areas).ToElements() views = FilteredElementCollector(doc).OfClass(ViewPlan).ToElements()
def getVertexString(point): return "v " + str(point[0]) + " " + str(point[1]) + " " + str( point[2]) + "\n" def getFaceString(indexes): faceString = "f" for index in indexes: faceString = faceString + " " + str(index) return faceString + "\n" polysurfaces = rs.GetObjects('select polysurfaces', 16) nU = rs.GetInteger("u", 1) nV = rs.GetInteger("v", 1) filename = rs.SaveFileName() vertices = {} vI = 1 # file = open("testPythonexport.obj", "w") file = open(filename, "w") for polysurface in polysurfaces: surfaces = rs.ExplodePolysurfaces(polysurface) for surface in surfaces: domainU = rs.SurfaceDomain(surface, 0) dU = (domainU[1] - domainU[0]) / nU domainV = rs.SurfaceDomain(surface, 1) dV = (domainV[1] - domainV[0]) / nV for i in range(nU): for j in range(nV):
else: # print "Cool" centroid = rs.CurveAreaCentroid(pl) centpt = rs.AddPoint(centroid[0]) curves = rs.ExplodeCurves(pl) for crv in curves: # print crv pt1 = rs.CurveStartPoint(crv) pt2 = rs.CurveEndPoint(crv) pts = [] pts.append(pt1) pts.append(pt2) pts.append(centpt) pts.append(pt1) newpl = rs.AddPolyline(pts) pls.append(newpl) rs.DeleteObject(crv) cleanup = [] cleanup.append(centpt) # cleanup.append(curves) rs.DeleteObjects(cleanup) count = count - 1 return crackpolygon(pls, count) count = rs.GetInteger("How many iterations would you like to do?", 3) pl = rs.GetCurveObject("pick a closed curve to crack") plguid = pl[0] polygons = [] polygons.append(plguid) crackpolygon(polygons, count)
# This script can be used to generate shipflow offsets from rhino surface # --------------------------- #| | #| | #AP-------------------------FP #x2_________________________x1 # the points x1 and x2 should be below the base line #x1 should be the foreend of the hull surface #x2 Aft End x1 = rs.GetPoint("Pick start point") x2 = rs.GetPoint("Pick end point") h = rs.GetPoint("Pick a point above deck") n = rs.GetInteger("Number of stations", 30, 0) dx = rs.Distance(x1, x2) / n # file for saving shf file surface = rs.GetObject("Select surface to project onto", rs.filter.surface) filter = "Text File (*.shf)|*.shf|All Files (*.*)|*.*||" filename = rs.SaveFileName("Save point coordinates as", filter) ### file = open(filename, "w") file.write("hull \n") for i in range(1, n): flg_stn = 1 c1 = (x1[0] - i * dx, x1[1], x1[2]) c2 = (x1[0] - i * dx, x1[1], h[2])
import rhinoscriptsyntax as rs idSurface = rs.GetObject("Surface to frame", 8, True, True) faces = [] intCount = rs.GetInteger("Number of iterations per direction", 20, 2) uDomain = rs.SurfaceDomain(idSurface, 0) vDomain = rs.SurfaceDomain(idSurface, 1) uStep = int((uDomain[1] - uDomain[0]) / intCount) vStep = int((vDomain[1] - vDomain[0]) / intCount) rs.EnableRedraw(False) for u in range(int(uDomain[0]), int(uDomain[1]), int(uStep)): for v in range(int(vDomain[0]), int(vDomain[1]), int(vStep)): pt = rs.EvaluateSurface(idSurface, u, v) srfFrame = rs.SurfaceFrame(idSurface, [u, v]) rs.AddPlaneSurface(srfFrame, 2.0, 2.0) #rs.AddEllipse(srfFrame, 1.0, 3.0) component = rs.GetObject("component to populate", rs.filter.mesh) faces = rs.MeshFaces(component, False) rs.AddMesh(faces, srfFrame) rs.EnableRedraw(True)
# use rhinoscriptsyntax to get all the functions in one shot import rhinoscriptsyntax as rs import random import time import Rhino count = rs.GetInteger("Number of points") points = [] if count: x = 0 y = 0 z = 0 xadd = 0 yadd = 0 rmin = 1 rmax = 20 toggle = 1 rs.AddPoint([x, y, z]) points.append([x, y, z]) for i in range(count): # time.sleep(0.001) xadd = random.randint(rmin, rmax) yadd = random.randint(rmin, rmax) if (i % 2 == 0):
from System.Drawing import Color ''' What it does is exporting drawings uniformly arranged on the plan to each .dwg file ''' #This part defines start position of drawings X_ST = 0 Y_ST = 0 #Change the girdsize based on your project X_Step = 9000 Y_Step = 10000 #Define the prefix of each file Sail_Name = rs.GetString("Input Sail Number") x = rs.GetInteger("Number of Drawings in X direction") y = rs.GetInteger("Number of Drawings in Y direction") direct = rs.BrowseForFolder(None, "Choose a folder", None) #Define color to exort geometry to DWG cause cannot see black in DWG Black = Color.Black White = Color.White #Change black color to white layers = rs.LayerIds() for layer in layers: print rs.LayerColor(layer) if rs.LayerColor(layer) == Black: rs.LayerColor(layer, White) #Select the drawings which are in grid and export.
filePath = baseName + "_" + eachView + ".jpg" result = SafeCapture_JPG(filePath, width, height) #return to original view rs.RestoreNamedView("temp") rs.DeleteNamedView("temp") result = True except: result = False utils.SaveFunctionData('IO-BatchCapture', [__version__] + chosenViews) return result if __name__ == "__main__" and utils.IsAuthorized(): func = rs.GetInteger("Function to run", number = 0) if func == 0: result = importCAD_Button() if result: utils.SaveToAnalytics('IO-Import CAD') elif func == 1: result = exportToRenderDWG() if result: utils.SaveToAnalytics('IO-Export To Render DWG') elif func == 2: result = exportToRenderSKP() if result: utils.SaveToAnalytics('IO-Export To Render SKP') elif func == 3: result = CaptureDisplayModesToFile() if result: utils.SaveToAnalytics('IO-Capture Display Modes') elif func == 4: result = SafeCaptureButton() if result: utils.SaveToAnalytics('IO-Safe Capture')