def exportTEN_CAD(): a = rs.GetObjects("Select Objects", preselect="True") b = rs.ScaleObjects(a, [0, 0, 0], [1000, 1000, 0], copy=True) rs.UnitSystem(2) savePath0 = rs.SaveFileName("Save", "Autocad (*.dwg)|*.dwg||") savePath1 = '"' + savePath0 + '"' rs.SelectObjects(b) rs.Command('_-Export ' + savePath1 + ' _Enter') rs.DeleteObjects(b) rs.UnitSystem(4) print "Exported" return None
def unit_convert(dimension): """assumes we want to convert to mm""" current_system = rs.UnitSystem() #see rs documentation for UnitSystem. Some units not implemented. unit_dict = { 1: 1.0e-6, 2: 1.0e-3, 3: 1.0e-2, 4: 1.0, 5: 1.0e+3, 6: 2.54e-8, 7: 2.54e-5, 8: 0.0254, 9: 0.3408, 10: 1609.344, 12: 1.0e-10, 13: 1.0e-9, 14: 1.0e-1, 15: 1.0e+1, 16: 1.0e+2, 17: 1.0e+6, 18: 1.0e+9, 19: 0.9144, 22: 1852, 23: 1.4959787e+11, 24: 9.46073e+15, 25: 3.08567758e+16 } conversion = 1 if current_system != 2: conversion = unit_dict[2] / unit_dict[current_system] return dimension*conversion
def main(): print "Checking model" #Check model units if rs.UnitSystem() != 8: rs.MessageBox("Your model is not in inches.", 16) print "Unit warning" #Check bad objects rs.Command('-_SelBadObjects ') objs = rs.SelectedObjects() if len(objs) > 0: message = "You have {} bad objects. Use SelBadObjects to delete them.".format( len(objs)) rs.MessageBox(message, 16) rs.UnselectAllObjects() #SelDup rs.Command('-_SelDup ') objs = rs.SelectedObjects() if len(objs) > 0: message = "You have {} duplicate objects. Use SelDup to delete them.".format( len(objs)) rs.MessageBox(message, 16) rs.UnselectAllObjects() #SelSmall rs.Command('-_SelSmall .01 ') objs = rs.SelectedObjects() if len(objs) > 0: message = "You have {} tiny objects. Use SelSmall to delete them.".format( len(objs)) rs.MessageBox(message, 16) rs.UnselectAllObjects()
def unit_check(): """ Warns the user if the Rhino doc is not set to 'Meters' as the unit """ try: # Check if its Rhino 7 or better first rhino_major_version = int(str(Rhino.RhinoApp.Version)[0]) if rhino_major_version >= 7: current_unit_num = rs.UnitSystem() current_unit_name = Rhino.UnitSystem(current_unit_num) msg = None if str(current_unit_name).upper() != 'METERS': msg = "Warning: The Rhino scene's current units are set to: '{}'\n"\ "LBT2PH currently only works reliably when the Rhino scene units are\n"\ "are set to 'METERS'. You can still export to the IP version of PHPP,\n"\ "but within the Rhino scene, please set your units to 'METERS' otherwise\n"\ "some of the data will not be converted correctly. Sorry about that.\n"\ "We're working on it.....".format(current_unit_name) else: msg = None except Exception: # So its not Rhino 7, don't know how to check units properly in 6 msg = 'g' return msg
def MainS(): #SETTING UP THE FILE ACCESS TO READ ALL THERE IS TO BE READ #THE SCRIPT FROM NOW ON LOOKS for FILE AND if IT CANNOT FIND ONE IT WILL HAVE TO MAKE ONE #SOOO WE START BY LOOKING for AND READING THE FILE if WE FIND IT ## ######################################################################## #READ INFO IN THE FILE ######################################################################## #ReadFile returns an array of [isAlive,startPoint,jointNos] content = History.ReadPolies(folder,file) rhUnitInches = 8 rs.UnitSystem(rhUnitInches, False, True) zero = [0,0,0] zaxis = [0,0,1] vrt = [] #Decimal display and decimal places #rs.UnitDistanceDisplayMode(0) #rs.UnitDistanceDisplayPrecision(7) #sth to control that we have an [0,0,0] to check endcheck = 1 size = 1 helper =[] #if we read nothing we should save 1 starting point - namely [0,0,0] if content is None: endpts = [[0,0,0]] npolies = 0 #polylines is an array of polylines #polyline is an array of points #point is an array of numbers #life#starting_point#joints_used sequence = [1,[0,0,0],[0]] #content = [[sequence],0] content = [sequence] else: #checking if new rib has actualy been started #[0,0,0] will always be the lasrt one for i = 0 To content(1] if rs.Distance(content(0](i](1],[0,0,0]]<tiny Then endcheck = endcheck*0 End if
def castToM(islen, value): factor = 0.001 if not islen: factor = factor * factor docUnits = rs.UnitSystem() if docUnits == 2: return value * factor else: return value
def scale(): system = rs.UnitSystem() if system == 2 or system == 3 or system == 4: scaleFactorDict = {2: 0.001, 3: 0.01, 4: 1} scaleFactor = scaleFactorDict[system] return scaleFactor if system != 2 or system != 3 or system != 4: return None
def exportPlanToCAD(chosenLevel, path): #Make sure layer is visible rs.LayerVisible("6_DRAWINGS", True) chosenChildren = rs.LayerChildren("6_DRAWINGS::" + chosenLevel) objects = [] for chosenChild in chosenChildren: tempObjects = rs.ObjectsByLayer(chosenChild) for tempObject in tempObjects: objects.append(tempObject) if objects is None: return scaledObjects = rs.ScaleObjects(objects, [0, 0, 0], [1000, 1000, 0], copy=True) #Format Coordinate # rawCoordinate = rs.GetDocumentData("Project Info", "CAD coordinate") # coordinate = rawCoordinate.split(",") # 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(scaledObjects, coordinate) rs.UnitSystem(2) savePath1 = '"' + path + '"' rs.SelectObjects(scaledObjects) rs.Command('_-Export ' + savePath1 + ' _Enter') rs.DeleteObjects(scaledObjects) rs.UnitSystem(4) print "Exported" return None
def getUnitSystemDescription(): unitSystemInt = rs.UnitSystem() if unitSystemInt == 2: return "mm3" elif unitSystemInt == 3: return "cm3" elif unitSystemInt == 4: return "m3" elif unitSystemInt == 8: return "in3" elif unitSystemInt == 9: return "ft3"
def get_conversion_factor(): unit_system = rs.UnitSystem() unit_conversion = { 2: 0.001, 3: 0.01, 4: 1.0, 8: 0.0254, 9: 0.3048 } return unit_conversion[unit_system]
def unitSystem(): unitsystemIndex = rs.UnitSystem() if unitsystemIndex == 2: return "mm3" elif unitsystemIndex == 3: return "cm3" elif unitsystemIndex == 4: return "m3" elif unitsystemIndex == 8: return "in3" elif unitsystemIndex == 9: return "ft3" else: return "of unknown unit system"
def unit_check(): """ Warns the user if the Rhino doc is not set to 'Meters' as the unit """ current_unit_num = rs.UnitSystem() current_unit_name = Rhino.UnitSystem(current_unit_num) msg = None if str(current_unit_name).upper() != 'METERS': msg = "Warning: The Rhino scene's current units are set to: '{}'\n"\ "LBT2PH currently only works reliably when the Rhino scene units are\n"\ "are set to 'METERS'. You can still export to the IP version of PHPP,\n"\ "but within the Rhino scene, please set your units to 'METERS' otherwise\n"\ "some of the data will not be converted correctly. Sorry about that.\n"\ "We're working on it.....".format(current_unit_name) return msg
def GetMap(): socket.setdefaulttimeout(10) filename = 'c:\\map.jpg' # you migth hve to change this path street = rs.GetString('Street') city = rs.GetString('City') country = rs.GetString('Country') zoom = rs.GetInteger('Zoom', 17, 1, 19) rs.UnitSystem(4, True) url = 'http://nominatim.openstreetmap.org/search?q=' + street + ',' + city + ',' + country + '&format=xml' rs.CurrentView('Top') try: xml = urllib.urlopen(url).read() except: print 'http://nominatim.openstreetmap.org produced an error' return temp = xml[xml.find("lat=") + 5:-1] lat = temp[0:temp.find("'")] temp = xml[xml.find("lon=") + 5:-1] lng = temp[0:temp.find("'")] print 'Latitude, Longitude: ' + lat + ", " + lng picture_page = 'http://osm-tah-cache.firefishy.com/MapOf/?lat=' + lat + '&long=' + lng + '&z=' + str( zoom) + '&w=1000&h=1000&format=jpeg' opener1 = urllib2.build_opener() try: page1 = opener1.open(picture_page) my_picture = page1.read() except: print 'http://osm-tah-cache.firefishy.com produced an error' return try: fout = open(filename, 'wb') fout.write(my_picture) fout.close() except: print 'writing of ' + path + ' produced an error' return res = 40075017 * math.cos( float(lat) / 180 * math.pi) / (256 * 2**zoom) * 1000 rs.Command('_-BackgroundBitmap Remove _Enter', False) rs.Command( '_-BackgroundBitmap ' + filename + ' ' + str(-res / 2) + ',' + str(-res / 2) + ',0 ' + str(res / 2) + ',' + str(res / 2) + ',0 _Enter', True) rs.Command('_-BackgroundBitmap Grayscale=No _Enter', False) rs.Command( '_-EarthAnchorPoint Latitude ' + lat + ' Longitude ' + lng + ' _Enter _Enter _Enter _Enter _Enter', False)
def UpdateAreaTag(): objs = rs.GetObjects('Select area tags to update', preselect = True) if objs is None: return successfulObjsRun = 0 failedObjsRun = 0 for obj in objs: try: host = rs.GetUserText(obj, 'hostGUID') if host is None: print "Could not find associated geometry" return None #Get number of dec places text = rs.TextObjectText(obj) splitText = text.Split(" ") numberString = splitText[0] units = splitText[-1] try: decPlaces = len(numberString.Split(".")[1]) except: decPlaces = 0 #Get area if rs.UnitSystem() == 8: area = rs.Area(rs.coerceguid(host))*0.0069444444444444 areaText = utils.RoundNumber(area, decPlaces) + " " + units else: print "WARNING: Your units are not in inches" area = rs.Area(rs.coerceguid(host)) areaText = area + ' ' + rs.UnitSystemName(False, True, True) rs.TextObjectText(obj, areaText) successfulObjsRun += 1 except: failedObjsRun += 1 print "Tag failed" utils.SaveFunctionData('Drawing-Update Area Tag', [__version__, successfulObjsRun, failedObjsRun]) return successfulObjsRun
def VolumeLiters(): """Report the volume in Litres of closed surfaces, polysurfaces, or meshes.""" input_obj = rs.SelectedObjects() if not input_obj: input_obj = rs.GetObjects("Select objects") if not input_obj: return volume = 0.0 for o in input_obj: if rs.IsMesh(o): a, b, c = rs.MeshVolume(o) volume += b elif rs.IsObjectSolid(o): a, b = rs.SurfaceVolume(o) volume += a if volume == 0.0: return volume = round(volume / (rs.UnitScale(rs.UnitSystem(), 3) * 10)**3, 3) print "Volume = {} liters".format(volume)
def PictureframeOnScale(): filter = "PNG (*.png)|*.png|JPG (*.jpg)|*.jpg|BMP (*.bmp)|*.bmp|All (*.*)|*.*||" #filter = "PNG (*.png)|*.png" filename = rs.OpenFileName("Select existing image file", filter) if not filename: return # use the System.Drawing.Bitmap class described at # [url]http://msdn.microsoft.com/en-us/library/system.drawing.bitmap.aspx[/url] img = SD.Bitmap(filename) img.Dispose # define scale from inch to file unitsystem dblScale = rs.UnitScale(rs.UnitSystem(), 8) #calculate width based on image pixel dimension and image HorizontalResolution w = str((img.Width / img.HorizontalResolution) * dblScale) #release the image (not sure if this is correct but seems to work) # scripted rhino command pictureframe with width and height as calculated above rs.Command("!_-PictureFrame \"" + filename + "\" _Pause " + w + " ")
def __init__(self, name): """Constructor Parameters: name = model name """ self.conversion_factor = StructuralModel.unit_conversion[ rs.UnitSystem()] self.name = name self.nodes = ElementList("nodes") self.springs_sn = ElementList("single node springs") self.line_elements = ElementList("line elements") self.area_elements = ElementList("area elements") self.gdiv = 1000 self.current_group = -1 return self
def Make2DTreads(obj, leftSegments, rightSegments, width, height): if rs.UnitSystem() == 8: minTreadDepth = 11 maxTreadDepth = 0 minRiserHeight = 4 maxRiserHeight = 7 numExtraTreads = 2 extraTreadLength = 12 else: print "Only inches supported" return None #Change from left and right lists to short and long shortEdges = [] longEdges = [] for i in range(len(leftSegments)): if leftSegments[i].GetLength() > rightSegments[i].GetLength(): shortEdges.append(rightSegments[i]) longEdges.append(leftSegments[i]) else: shortEdges.append(leftSegments[i]) longEdges.append(rightSegments[i]) #Check global numRisersFromHeight = int(math.floor((height / maxRiserHeight))) totalLength = 0 for i in range(len(shortEdges)): length = shortEdges[i].GetLength() #sc.doc.Objects.Add(shortEdges[i]) totalLength += (length - extraTreadLength) print maxNumRisers = int(math.floor(totalLength / minTreadDepth)) minNumRisers = int(math.floor(height / maxRiserHeight)) if numRisersFromHeight > maxNumRisers: print "Path not long enough to reach full height" if numRisersFromHeight < minNumRisers: print "Not enough risers to reach full height" #Get num risers numRisers = [] for i in range(len(shortEdges)): length = shortEdges[i].GetLength() usableLength = length - extraTreadLength percentOfLength = usableLength / totalLength x = round(percentOfLength * numRisersFromHeight) numRisers.append(x) #Draw riser lines allRiserLines = [] treadLengths = [] for i in range(len(shortEdges)): length = shortEdges[i].GetLength() numTreads = numRisers[i] if numTreads == 0: continue riserStParams = shortEdges[i].DivideByCount(numTreads, True) treadLengths.append(length / numTreads) riserLines = [] for riserStParam in riserStParams: shortEdgePt = shortEdges[i].PointAt(riserStParam) result = IsPointOnLeftSide(shortEdgePt, obj) longEdgeParam = longEdges[i].ClosestPoint( shortEdges[i].PointAt(riserStParam), width * 2)[1] longEdgePt = longEdges[i].PointAt(longEdgeParam) line = rc.Geometry.LineCurve(shortEdgePt, longEdgePt) if result: line.Reverse() riserLines.append(line) allRiserLines.append(riserLines) return allRiserLines, numRisers, treadLengths
from Rhino import ApplicationSettings import rhinoscriptsyntax as rs # Disable Autosave to prevent filesharing conflicts rs.EnableAutosave(False) rs.EnableRedraw(True) ''' Configure measurement unit and tolerances [Accuracy](https://www.rhino3d.com/accuracy) | Absolute | Relative | Angle --------|--------------|----------|--------- Min | 0.0000000001 | 0.0001 | 0.0001 Default | 0.001 | 1.0 | 1.0 2 | millimeters 4 | meters 13 | nanometers When tolerance >= 0.1 silhouette edges are fragmented. Set extreme intolerance to ensure precision. ''' rs.UnitAbsoluteTolerance(0.0000000001, True) rs.UnitRelativeTolerance(0.0, True) rs.UnitAngleTolerance(0.0, True) rs.UnitSystem(4, True, True) # Allow rotation when in Parallel ApplicationSettings.ViewSettings.AlwaysPanParallelViews = False
def StairGen(): class StairGenDialog(forms.Dialog[bool]): # Dialog box Class initializer def __init__(self): # Initialize dialog box self.Title = 'LandArchTools: Stair Generator' self.Padding = drawing.Padding(10) self.Resizable = False self.Closing += self.OnFormClosed ################################################################################ # Create controls for the dialog # Stair gen label self.stairGenLabel = forms.Label(Text='STAIR GENERATOR') # Gen Handrail label self.genStairLabel = forms.Label(Text='Generate Stair?:') # Gen Handrail control self.genStairBool = forms.CheckBox() self.genStairBool.Checked = False self.genStairBool.CheckedChanged += self.stairGen # Number of Steps Label self.numStepsLabel = forms.Label(Text='Number of steps:') # Number of Steps control self.numStepsC = forms.NumericStepper() self.numStepsC.DecimalPlaces = 0 self.numStepsC.Increment = 1 self.numStepsC.MaxValue = 100 self.numStepsC.MinValue = 2 self.numStepsC.Value = 3 self.numStepsC.ValueChanged += self.stairGen self.numStepsC.ValueChanged += self.handrailGen # Tread label self.treadLabel = forms.Label(Text='Tread (mm):') # Tread length control self.treadC = forms.NumericStepper() self.treadC.DecimalPlaces = 0 self.treadC.Increment = 1 self.treadC.MaxValue = 1000 self.treadC.MinValue = 1 self.treadC.Value = 300 self.treadC.ValueChanged += self.stairGen self.treadC.ValueChanged += self.handrailGen # Riser Label self.riserLabel = forms.Label(Text='Riser (mm):') # Tread length control self.riserC = forms.NumericStepper() self.riserC.DecimalPlaces = 0 self.riserC.Increment = 1 self.riserC.MaxValue = 1000 self.riserC.MinValue = 1 self.riserC.Value = 150 self.riserC.ValueChanged += self.stairGen self.riserC.ValueChanged += self.handrailGen # Flip label self.flipLabel = forms.Label(Text='Flip direction of stairs:') # Flip control self.flipC = forms.CheckBox() self.flipC.CheckedChanged += self.stairGen self.flipC.CheckedChanged += self.handrailGen ########################################### # Handrail Gen Label self.handrailGenLabel = forms.Label(Text='HANDRAIL GENERATOR') # self.handrailGenLabel.VerticalAlignment.Center # Gen Handrail label self.genHandrailLabel = forms.Label(Text='Generate Handrail?:') # Gen Handrail control self.genHandrailBool = forms.CheckBox() self.genHandrailBool.Checked = False self.genHandrailBool.CheckedChanged += self.handrailGen # Handrail Type Label self.handrailTypeLabel = forms.Label(Text='Handrail type:') # Handrail Type Dropdown self.handrailTypeC = forms.DropDown() self.handrailTypeC.DataStore = [ '180 No Return', '180 Full Return', 'Ground Triangular Return', 'Ground Return', 'Wall Return'] self.handrailTypeC.SelectedIndex = 0 self.handrailTypeC.SelectedIndexChanged += self.handrailGen # Handrail Height Label self.handrailHeightLabel = forms.Label( Text='Handrail height (mm):') # Handrail Height control self.handrailHeightC = forms.NumericStepper() self.handrailHeightC.DecimalPlaces = 0 self.handrailHeightC.Increment = 1 self.handrailHeightC.MaxValue = 5000 self.handrailHeightC.MinValue = 100 self.handrailHeightC.Value = 900 self.handrailHeightC.ValueChanged += self.handrailGen # Handrail offset label self.handrailOffsetLabel = forms.Label( Text='Handrail offset from edges (mm):') # Handrail offset control self.handrailOffsetC = forms.NumericStepper() self.handrailOffsetC.DecimalPlaces = 0 self.handrailOffsetC.Increment = 1 self.handrailOffsetC.MaxValue = 5000 self.handrailOffsetC.MinValue = 50 self.handrailOffsetC.Value = 150 self.handrailOffsetC.ValueChanged += self.handrailGen # Handrail extension Label self.handrailExtensionLabel = forms.Label( Text='Handrail extension (mm):') # Handrail extension Control self.handrailExtensionC = forms.NumericStepper() self.handrailExtensionC.DecimalPlaces = 0 self.handrailExtensionC.Increment = 1 self.handrailExtensionC.MaxValue = 5000 self.handrailExtensionC.MinValue = 300 self.handrailExtensionC.Value = 300 self.handrailExtensionC.ValueChanged += self.handrailGen # Handrail Diameter Label self.handrailDiameterLabel = forms.Label( Text='Handrail diameter (mm):') # Handrail Diameter control self.handrailDiameterC = forms.NumericStepper() self.handrailDiameterC.DecimalPlaces = 0 self.handrailDiameterC.Increment = 1 self.handrailDiameterC.MaxValue = 50 self.handrailDiameterC.MinValue = 30 self.handrailDiameterC.Value = 30 self.handrailDiameterC.ValueChanged += self.handrailGen # Create the default button self.DefaultButton = forms.Button(Text='OK') self.DefaultButton.Click += self.OnOKButtonClick # Create the abort button self.AbortButton = forms.Button(Text='Cancel') self.AbortButton.Click += self.OnCloseButtonClick ################################################################################ # Create a table layout and add all the controls layout = forms.DynamicLayout() layout.Spacing = drawing.Size(5, 5) layout.AddRow(None) layout.AddRow(self.stairGenLabel) layout.AddRow(None) layout.AddRow(None) layout.AddRow(self.genStairLabel, self.genStairBool) layout.AddRow(self.numStepsLabel, self.numStepsC) layout.AddRow(self.treadLabel, self.treadC) layout.AddRow(self.riserLabel, self.riserC) layout.AddRow(self.flipLabel, self.flipC) layout.AddRow(None) layout.AddRow(None) layout.AddRow(None) layout.AddRow(None) layout.AddRow(self.handrailGenLabel) layout.AddRow(None) layout.AddRow(None) layout.AddRow(self.genHandrailLabel, self.genHandrailBool) layout.AddRow(self.handrailTypeLabel, self.handrailTypeC) layout.AddRow(self.handrailHeightLabel, self.handrailHeightC) layout.AddRow(self.handrailOffsetLabel, self.handrailOffsetC) layout.AddRow(self.handrailExtensionLabel, self.handrailExtensionC) layout.AddRow(self.handrailDiameterLabel, self.handrailDiameterC) layout.AddRow(self.DefaultButton, self.AbortButton) # Set the dialog content self.Content = layout ################################################################################ # Stair Generator Method def stairGen(self, sender, e): # Variables and defaults tread = int(self.treadC.Value) * scale riser = int(self.riserC.Value) * scale numSteps = int(self.numStepsC.Value) flip = self.flipC.Checked stairLength = tread * numSteps genStair = self.genStairBool.Checked curveList = [] junkList = [] # get user line for top width of stair rs.EnableRedraw(False) if genStair == False: iteration = rs.ObjectsByName( "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") if iteration: rs.DeleteObject(iteration) rs.EnableRedraw(True) if genStair == True: # Delete any existing iteration iteration = rs.ObjectsByName( "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") if iteration: rs.DeleteObject(iteration) topLine = rs.AddLine(line[0], line[1]) topPoint = line[0] stepPoint = topPoint # get perp line - length of stair t = rs.CurveClosestPoint(topLine, topPoint) planeNormal = rs.CurveNormal(topLine) tangent = rs.CurveTangent(topLine, t) curveNormal = rs.VectorCrossProduct(planeNormal, tangent) # Get vector vectorRun = rs.VectorCreate( topPoint, topPoint + curveNormal * tread) # Bool flip direction of stair (add bool option in GUI) if flip == True: vector = rs.VectorReverse(vectorRun) else: vector = vectorRun # loop through number of steps to gen step curve for i in range(numSteps): pt01 = rs.AddPoint(stepPoint) pt02 = rs.CopyObject(pt01, vector) pt03 = rs.CopyObject(pt02, [0, 0, riser*-1]) curve = rs.AddPolyline([pt01, pt02, pt03]) curveList.append(curve) stepPoint = rs.CurveEndPoint(curve) rs.DeleteObjects([pt01, pt02, pt03]) # Extrude stair curve to full width joinedCurve = rs.JoinCurves(curveList) bottomPoint = rs.CopyObject( line[0], [0, 0, (riser*numSteps)*-1]) stairBottom = rs.CurveEndPoint(joinedCurve) curve = rs.AddPolyline([line[0], bottomPoint, stairBottom]) # createhandrail curve and return it handRailCurve = rs.AddCurve([bottomPoint, stairBottom]) curveList.append(curve) joinedCurves = rs.JoinCurves(curveList) stair = rs.ExtrudeCurveStraight(joinedCurves, line[0], line[1]) rs.CapPlanarHoles(stair) # this identifies the generated stair geometry rs.ObjectName( stair, "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") # clean up leftover geometry junkList.extend([bottomPoint, joinedCurve, joinedCurves, topLine, handRailCurve]) junkList = junkList + curveList rs.DeleteObjects(junkList) rs.EnableRedraw(True) # Handrail Generator Method # hType, curve, handrailOffset, tread, riser, numSteps, scale, vectorRun, hHeight, hEndLength, pipeDiameter, def handrailGen(self, sender, e): flip = self.flipC.Checked hType = self.handrailTypeC.SelectedIndex handrailOffset = int(self.handrailOffsetC.Value) * scale tread = int(self.treadC.Value) * scale riser = int(self.riserC.Value) * scale numSteps = int(self.numStepsC.Value) hEndLength = int(self.handrailExtensionC.Value) * scale pipeDiameter = int(self.handrailDiameterC.Value) * scale hHeight = int(self.handrailHeightC.Value) * scale topLine = rs.AddLine(line[0], line[1]) rs.ObjectName(topLine, "BC6#DT5LCQX*#8r97Tquf5gNF") topPoint = line[0] genHandrail = self.genHandrailBool.Checked rs.EnableRedraw(False) if genHandrail == False: iteration = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") if iteration: rs.DeleteObjects(iteration) rs.EnableRedraw(True) if genHandrail == True: # Delete any existing iteration iteration = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") if iteration: rs.DeleteObjects(iteration) # get perp line - length of stair t = rs.CurveClosestPoint(topLine, topPoint) planeNormal = rs.CurveNormal(topLine) tangent = rs.CurveTangent(topLine, t) if flip == False: curveNormal = rs.VectorCrossProduct(planeNormal, tangent) else: curveNormal = rs.VectorReverse( rs.VectorCrossProduct(planeNormal, tangent)) # Get guide curve scaledV = rs.VectorReverse( rs.VectorScale(curveNormal, tread*numSteps)) ptGuide1 = rs.AddPoint(line[0]) ptGuide2 = rs.CopyObject(ptGuide1, scaledV) rs.MoveObjects([ptGuide1, ptGuide2], [ 0, 0, (riser*numSteps)*-1]) curve = rs.AddCurve([ptGuide1, ptGuide2]) # Get vector for step run vectorRun = rs.VectorCreate( topPoint, topPoint + curveNormal * tread) # Setup curves for handrail curve1 = curve curve2 = rs.MoveObject(rs.CopyObject(curve1, rs.VectorCreate(line[1], rs.CurveStartPoint(curve1))), [0, 0, (riser * numSteps)*-1]) midPoint = rs.CurveMidPoint(userCurve) # Main slanted handrail curve pt1 = rs.MoveObject(rs.MoveObject(rs.CurveStartPoint(curve1), vectorRun), [ 0, 0, hHeight + (riser*numSteps)]) pt2 = rs.MoveObject(rs.MoveObject( rs.CurveEndPoint(curve1), vectorRun), [0, 0, hHeight]) mainCurve = rs.AddCurve([pt1, pt2]) # Top leveled handrail curve at 300mm standard DDA pt3 = rs.CopyObject(pt1, rs.VectorReverse( rs.VectorScale(rs.VectorUnitize(vectorRun), hEndLength))) topCurve = rs.AddCurve([pt1, pt3]) # Bottom leveled handrail curve at 300mm standard DDA pt4 = rs.CopyObject(pt2, rs.VectorScale( rs.VectorUnitize(vectorRun), hEndLength)) bottomCurve = rs.AddCurve([pt2, pt4]) # Start list of construction geometry for later cleanup hGeoList = [curve1, curve2, pt1, pt2, mainCurve, pt3, topCurve, pt4, bottomCurve, ptGuide1, ptGuide2, curve, topLine] # IF STATEMENTS FOR HANDRAIL TYPE # 1 180 degree, no return if hType == 0: # Lower Handrail return hpt1 = rs.CopyObject(pt4, [0, 0, (pipeDiameter * 2) * -1]) hpt2 = rs.MoveObject(rs.CopyObject( pt4, [0, 0, pipeDiameter * -1]), rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter)) lowerH = rs.AddArc3Pt(pt4, hpt1, hpt2) # Upper Handrail return hpt3 = rs.CopyObject(pt3, [0, 0, (pipeDiameter * 2) * -1]) hpt4 = rs.MoveObject(rs.CopyObject(pt3, [0, 0, pipeDiameter * -1]), rs.VectorReverse( rs.VectorScale(rs.VectorUnitize(vectorRun), pipeDiameter))) upperH = rs.AddArc3Pt(pt3, hpt3, hpt4) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Join, offset skeleton hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, lowerH, upperH]) hCurve1 = rs.CopyObject(hCurve, moveShort) lCurveUpper1 = rs.CopyObject(lCurveUpper, moveShort) lCurveLower1 = rs.CopyObject(lCurveLower, moveShort) # Pipe skeleton pipe1 = rs.AddPipe( hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower1, 0, pipeDiameter/2, blend_type=0, cap=1) # form list of generated geo handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # copy handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup construction linework hGeoList.extend([hpt1, hpt2, lowerH, hpt3, hpt4, upperH, lpt2, lpt3, lCurveLower, hCurve, hCurve1, lCurveUpper1, lCurveLower1, lCurveUpper]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 2 180 degree, full return if hType == 1: rs.EnableRedraw(False) # Lower handrail return hpt1 = rs.CopyObject(pt4, [0, 0, (hEndLength/3)*-2]) hpt2 = rs.CopyObject(pt2, [0, 0, (hEndLength/3)*-2]) hCurve11 = rs.AddPolyline([pt4, hpt1, hpt2]) lowerH = rs.JoinCurves([bottomCurve, hCurve11]) # Upper handrail return hpt3 = rs.CopyObject(pt3, [0, 0, (hEndLength/3)*-2]) hpt4 = rs.CopyObject(rs.CurveMidPoint( topCurve), [0, 0, (hEndLength/3)*-2]) hCurve2 = rs.AddPolyline([pt3, hpt3, hpt4]) upperH = rs.JoinCurves([topCurve, hCurve2]) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Pipe skeleton move hCurve1 = rs.JoinCurves([lowerH, upperH, mainCurve]) rs.MoveObjects( [hCurve1, lCurveUpper, lCurveLower], moveShort) # Pipe pipe1 = rs.AddPipe( hCurve1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # Move and copy into position handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup hGeoList.extend([hpt1, hpt2, hCurve11, lowerH, hpt3, hpt4, hCurve2, upperH, lpt2, lCurveUpper, lpt3, lCurveLower, hCurve1]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 3 Ground triangle return if hType == 2: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Lower Return lowerH = rs.AddCurve([pt4, lpt3]) # Upper Return upperH = rs.AddCurve([pt3, lpt2]) # Make vectors to move handrails into place moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # Join Curves and move hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, lowerH, upperH]) rs.MoveObjects( [hCurve, lCurveUpper, lCurveLower], moveShort) # pipe pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter / 2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # move and copy into place handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Cleanup hGeoList.extend( [lpt2, lCurveUpper, lpt3, lCurveLower, lowerH, upperH, hCurve, topLine]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 4 Ground return if hType == 3: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # Lower Return hpt1 = rs.CopyObject(pt4, [0, 0, hHeight*-1]) hCurve1 = rs.AddCurve([pt4, hpt1]) # Upper Return hpt2 = rs.CopyObject(pt3, [0, 0, hHeight*-1]) hCurve2 = rs.AddCurve([pt3, hpt2]) # Join curves hCurve = rs.JoinCurves( [mainCurve, topCurve, bottomCurve, hCurve1, hCurve2]) # Get Vectors moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - (handrailOffset*2)) # move rs.MoveObjects( [hCurve, lCurveUpper, lCurveLower], moveShort) # Pipe pipe1 = rs.AddPipe(hCurve, 0, pipeDiameter / 2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # move and copy into place handrailGeo2 = rs.CopyObjects(handrailGeo1, moveLong) # Clean up hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurve, topLine]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # 5 Wall return if hType == 4: rs.EnableRedraw(False) # Draw leg upper lpt1 = rs.CurveMidPoint(topCurve) lpt2 = rs.CopyObject(lpt1, [0, 0, hHeight*-1]) lCurveUpper = rs.AddCurve([lpt1, lpt2]) # Draw leg lower lpt3 = rs.CopyObject(pt2, [0, 0, hHeight*-1]) lCurveLower = rs.AddCurve([pt2, lpt3]) # get vectors vector1 = rs.VectorScale(rs.VectorUnitize( rs.VectorReverse(userVector)), handrailOffset) vector2 = rs.VectorScale( userVector, rs.CurveLength(userCurve)) # Lower Return hpt1 = rs.CopyObject(pt4, vector1) hCurve1 = rs.AddCurve([pt4, hpt1]) # Upper Return hpt2 = rs.CopyObject(pt3, vector1) hCurve2 = rs.AddCurve([pt3, hpt2]) # Join main curves hCurveMain1 = rs.JoinCurves( [mainCurve, topCurve, bottomCurve]) # Get Vectors moveShort = rs.VectorScale(userVector, handrailOffset) moveLong = rs.VectorScale( userVector, rs.CurveLength(userCurve) - handrailOffset) # Copy hanrail 2 hCurveMain2 = rs.CopyObject(hCurveMain1, moveLong) hCurve3 = rs.CopyObject(hCurve1, vector2) hCurve4 = rs.CopyObject(hCurve2, vector2) lCurveUpper2 = rs.CopyObject(lCurveUpper, moveLong) lCurveLower2 = rs.CopyObject(lCurveLower, moveLong) # Join curves hCurveJoined1 = rs.JoinCurves( [hCurve1, hCurve2, hCurveMain1]) hCurveJoined2 = rs.JoinCurves( [hCurveMain2, hCurve3, hCurve4, ]) # Pipe pipe1 = rs.AddPipe( hCurveJoined1, 0, pipeDiameter/2, blend_type=0, cap=1) pipe2 = rs.AddPipe( lCurveLower, 0, pipeDiameter/2, blend_type=0, cap=1) pipe3 = rs.AddPipe( lCurveUpper, 0, pipeDiameter/2, blend_type=0, cap=1) pipe4 = rs.AddPipe( hCurveJoined2, 0, pipeDiameter/2, blend_type=0, cap=1) pipe5 = rs.AddPipe( lCurveUpper2, 0, pipeDiameter/2, blend_type=0, cap=1) pipe6 = rs.AddPipe( lCurveLower2, 0, pipeDiameter/2, blend_type=0, cap=1) handrailGeo1 = [pipe1, pipe2, pipe3, pipe3, pipe4, pipe5, pipe6] # Name geo for deletion for i in handrailGeo1: rs.ObjectName( i, "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") # Move handrail 1 into place rs.MoveObjects([pipe1, pipe2, pipe3], moveShort) # Cleanup hGeoList.extend([lpt2, lCurveUpper, lpt3, lCurveLower, hpt1, hCurve1, hpt2, hCurve2, hCurveMain1, hCurveMain2, hCurve3, hCurve4, lCurveUpper2, lCurveLower2, hCurveJoined1, hCurveJoined2]) rs.DeleteObjects(hGeoList) rs.EnableRedraw(True) # Close button click handler def OnCloseButtonClick(self, sender, e): generatedStair = rs.ObjectsByName( "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") generatedHandrail = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") rs.DeleteObjects(rs.ObjectsByName( "xAbJgNV6^bz6azN&6E$Q^WeX$Dd^vygCz5z7Hmynb5")) rs.DeleteObjects(rs.ObjectsByName("BC6#DT5LCQX*#8r97Tquf5gNF")) if generatedStair: rs.DeleteObject(generatedStair) if generatedHandrail: rs.DeleteObjects(generatedHandrail) self.Close(False) # close x button handler def OnFormClosed(self, sender, e): generatedStair = rs.ObjectsByName( "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") generatedHandrail = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") rs.DeleteObjects(rs.ObjectsByName( "xAbJgNV6^bz6azN&6E$Q^WeX$Dd^vygCz5z7Hmynb5")) rs.DeleteObjects(rs.ObjectsByName("BC6#DT5LCQX*#8r97Tquf5gNF")) if generatedStair: rs.DeleteObject(generatedStair) if generatedHandrail: rs.DeleteObjects(generatedHandrail) self.Close(False) # OK button click handler def OnOKButtonClick(self, sender, e): # remove object name to avoid deletion generatedStair = rs.ObjectsByName( "GdC9V&^a^rGZZNgiWFH&aTRQLLscu*9AZCmhk8t2!a") generatedHandrail = rs.ObjectsByName( "qe7g&G5LzXEvbudtPT8xCxQbisusFVqCPqMsiHK2jc") rs.DeleteObjects(rs.ObjectsByName( "xAbJgNV6^bz6azN&6E$Q^WeX$Dd^vygCz5z7Hmynb5")) rs.DeleteObjects(rs.ObjectsByName("BC6#DT5LCQX*#8r97Tquf5gNF")) if generatedStair: rs.ObjectName(generatedStair, name="www.landarchtools.com") if generatedHandrail: rs.ObjectName(generatedHandrail, name="www.landarchtools.com") self.Close(True) ################################################################################ # Get scale factor and abort if not in mm cm or m system = rs.UnitSystem() if system == 2 or system == 3 or system == 4: scaleFactorDict = {2: 1, 3: 0.1, 4: 0.001} scaleFactor = scaleFactorDict[system] scale = scaleFactor else: rs.MessageBox("change document to use mm, cm or m") exit() # Get stair width line = rs.GetLine( mode=1, message1="Pick two points to define top step width") line[1].Z = line[0].Z userCurve = rs.AddLine([line[0].X, line[0].Y, line[0].Z], [ line[1].X, line[1].Y, line[0].Z]) userVector = rs.VectorUnitize(rs.VectorCreate( (line[1].X, line[1].Y, line[0].Z), (line[0].X, line[0].Y, line[0].Z))) rs.ObjectName(userCurve, "xAbJgNV6^bz6azN&6E$Q^WeX$Dd^vygCz5z7Hmynb5") # The script that will be using the dialog. def RequestStairGen(): # This will call the eto form and assign it as a daughter window of rhino dialog = StairGenDialog() # sets the ETO form to dialog variable # Launches UI as modal daughter of rhino window rc = dialog.ShowModal(Rhino.UI.RhinoEtoApp.MainWindow) ################################################################################ RequestStairGen()
#---------------------------------------------------------------------------------------------# # Copyright Manuel Gomez (2019) # # # # This script calculates volume and translates to weight for steel density (0.284 lbs/in3) # # # #---------------------------------------------------------------------------------------------# # Create button in Rhino and add this command: # # ! _-RunPythonScript "GetSteelWeight.py" # #---------------------------------------------------------------------------------------------# # Version 1.0 (2019-01-20) # # - Initial rev. # #---------------------------------------------------------------------------------------------# import rhinoscriptsyntax as rs if rs.UnitSystem() != 8: print("Units should be set to inches.") exit() object_ids = [] object_ids = rs.SelectedObjects() while not object_ids: object_ids = rs.GetObjects("Select some closed surfaces or polysurfaces",8+16) #loop between objects totalVolume = 0.0 for object_id in object_ids: #check to see if the object is closed before calculating volume
def stairHeight(route, width=48, height=120): """ Makes a stair to specified height. input: route(pline), width (num), height(num) returns: Geo """ try: rs.EnableRedraw(False) rs.SimplifyCurve(route) if route is None: print("ERROR: No path selected") return if (rs.UnitSystem() == 2): #if mm maxRiserHeight = 180 thickness = 200 if (rs.UnitSystem() == 4): #if m maxRiserHeight = .180 thickness = .200 if (rs.UnitSystem() == 8): #if in" maxRiserHeight = 7 thickness = 9 negativeBoo = False if (height < 0): #if the stair negativeBoo = True landingEdges = [] landings = [] segments = rs.ExplodeCurves(route) if len(segments) < 1: segments = [rs.CopyObject(route)] landingHeight = [] geometry = [] #Check that all segments are lines for i in range(0, len(segments)): if not (rs.IsLine(segments[i])): print( "ERROR: This function only accepts lines. No arcs or nurb curves." ) rs.DeleteObjects(segments) return #first landing edge norm = rs.VectorRotate(rs.CurveTangent(segments[0], 0), 90, [0, 0, 1]) norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2) side1Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), norm) side2Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), -norm) landingEdges.append(rs.AddLine(side1Pt, side2Pt)) #middle landing edges for i in range(0, len(segments) - 1): edgeList, landing = rampIntersection(segments[i], segments[i + 1], width) landingEdges.append(edgeList[0]) landingEdges.append(edgeList[1]) landings.append(landing) #last landing edge norm = rs.VectorRotate( rs.CurveTangent(segments[-1], rs.CurveParameter(segments[-1], 1)), 90, [0, 0, 1]) norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2) side1Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), norm) side2Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), -norm) landingEdges.append(rs.AddLine(side1Pt, side2Pt)) #Add risers riserCrvs = [] treadVecs = [] numRisersPerRun = [] numRisers = abs(int(math.ceil(height / maxRiserHeight))) risersSoFar = 0 totalRun = getTotalRun(landingEdges) optTreadDepth = totalRun / (numRisers - 1) #2R+T = 635 riserHeight = height / numRisers if (negativeBoo): curRiserHeight = 0 else: curRiserHeight = riserHeight for i in range(0, len(landingEdges), 2): #find numRisers in each run a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) runDist = rs.Distance(a, b) numRisersThisRun = int(round((runDist / optTreadDepth), 0)) if (numRisersThisRun == 0): numRisersThisRun = 1 if (i == len(landingEdges) - 2): #if last run, add the rest of the risers numRisersThisRun = numRisers - risersSoFar else: risersSoFar = risersSoFar + numRisersThisRun numRisersPerRun.append(numRisersThisRun) #Create Risers on Plan for i in range(0, len(landingEdges), 2): run = [] a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) centerStringer = rs.AddLine(a, b) runDist = rs.Distance(a, b) numRisersThisRun = numRisersPerRun[int(i / 2)] #risers in this run tarPts = rs.DivideCurve(centerStringer, numRisersThisRun, create_points=False) rs.DeleteObject(centerStringer) for j in range(0, numRisersThisRun + 1): if (j == 0): treadVecs.append(rs.VectorCreate(tarPts[0], tarPts[1])) transVec = rs.VectorCreate(tarPts[0], tarPts[j]) run.append(rs.CopyObject(landingEdges[i], -transVec)) riserCrvs.append(run) print('Flight {0} has {1} risers: {3}" tall, Treads: {2}" deep'. format( int(i / 2) + 1, numRisersThisRun, rs.VectorLength(treadVecs[int(i / 2)]), riserHeight)) #Move riser edges vertically for i in range(0, len(riserCrvs)): triangles = [] if (negativeBoo): for j in range(0, len(riserCrvs[i]) - 1): #if stairs descending rs.MoveObject( riserCrvs[i][j], rs.VectorAdd([0, 0, curRiserHeight], -treadVecs[i])) riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], [0, 0, riserHeight]) treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], treadVecs[i]) stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j])) pt1 = rs.CopyObject( stPt, [0, 0, riserHeight]) #first riser in run pt2 = rs.CopyObject(stPt, treadVecs[i]) #last riser in run triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt]) triangles.append(rs.AddPlanarSrf(triCrv)) geometry.append(riserGeo) #riser geometry.append(treadGeo) #tread curRiserHeight = curRiserHeight + riserHeight rs.MoveObject(riserCrvs[i][j], treadVecs[i]) #cleanup rs.DeleteObject(triCrv) rs.DeleteObject(stPt) rs.DeleteObject(pt1) rs.DeleteObject(pt2) else: for j in range(0, len(riserCrvs[i]) - 1): #if stairs ascend rs.MoveObject(riserCrvs[i][j], [0, 0, curRiserHeight]) stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j])) pt1 = rs.CopyObject( stPt, [0, 0, -riserHeight]) #first riser in run pt2 = rs.CopyObject(stPt, -treadVecs[i]) #last riser in run triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt]) triangles.append(rs.AddPlanarSrf(triCrv)) riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], [0, 0, -riserHeight]) treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], -treadVecs[i]) geometry.append(riserGeo) #riser geometry.append(treadGeo) #tread curRiserHeight = curRiserHeight + riserHeight #cleanup rs.DeleteObject(triCrv) rs.DeleteObject(stPt) rs.DeleteObject(pt1) rs.DeleteObject(pt2) #Make Stringer if (negativeBoo): firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0])) lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2])) #rs.MoveObject(firstStartPt, [0,0,riserHeight]) #first riser in run rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run rs.MoveObject(lastStartPt, [0, 0, riserHeight]) #last riser in run else: firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0])) lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2])) rs.MoveObject(firstStartPt, [0, 0, -riserHeight]) #first riser in run rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run stringerCrv = rs.AddLine(firstStartPt, lastStartPt) stringerSrf = rs.ExtrudeCurveStraight(stringerCrv, [0, 0, 0], [0, 0, -thickness]) triangles.append(stringerSrf) stringer = makeFace(triangles) stringerVec = rs.VectorCreate(rs.CurveEndPoint(riserCrvs[i][0]), rs.CurveStartPoint(riserCrvs[i][0])) underside = rs.ExtrudeCurveStraight( stringerCrv, rs.CurveStartPoint(riserCrvs[i][0]), rs.CurveEndPoint(riserCrvs[i][0])) geometry.append(rs.MoveObject(underside, [0, 0, -thickness])) geometry.append(rs.CopyObject(stringer, stringerVec)) geometry.append(stringer) #cleanup rs.DeleteObject(firstStartPt) rs.DeleteObject(lastStartPt) rs.DeleteObject(stringerCrv) rs.DeleteObject(stringerSrf) #Move Landings lastLandingHeight = 0 for i in range(0, len(segments) - 1): landingHeight = lastLandingHeight + numRisersPerRun[i] * riserHeight rs.MoveObject(landings[i], [0, 0, landingHeight]) landingTopSrf = rs.AddPlanarSrf(landings[i]) landingBtmSrf = rs.CopyObject(landingTopSrf, [0, 0, -thickness]) geometry.append(landingTopSrf) geometry.append(landingBtmSrf) lastLandingHeight = landingHeight landingEdgesToEx = rs.ExplodeCurves(landings[i]) geometry.append( rs.ExtrudeCurveStraight(landingEdgesToEx[1], [0, 0, 0], [0, 0, -thickness])) geometry.append( rs.ExtrudeCurveStraight(landingEdgesToEx[2], [0, 0, 0], [0, 0, -thickness])) rs.DeleteObjects(landingEdgesToEx) #Create final geometry joinedGeo = rs.JoinSurfaces(geometry, True) holes = rs.DuplicateSurfaceBorder(joinedGeo) cap = rs.AddPlanarSrf(holes) newGeo = rs.ExplodePolysurfaces(joinedGeo, True) for i in cap: newGeo.append(i) FinalGeo = rs.JoinSurfaces(newGeo, True) #cleanup try: rs.DeleteObjects(segments) except: rs.DeleteObject(segments) rs.DeleteObjects(holes) rs.DeleteObjects(landings) rs.DeleteObjects(landingEdges) for i in riserCrvs: rs.DeleteObjects(i) rs.EnableRedraw(True) return FinalGeo except: print "Error" return None
def main(): if (rs.UnitSystem() == 2): widthDefault = 1800 widthMin = 900 widthMax = 100000 heightDefault = 5000 heightMin = 300 elif (rs.UnitSystem() == 4): widthDefault = 1.8 widthMin = .9 widthMax = 100.0 heightDefault = 5.0 heightMin = .30 elif (rs.UnitSystem() == 8): widthDefault = 42 widthMin = 36 widthMax = 1000.0 heightDefault = 120 heightMin = 12 else: print "Change your units to inches" return route = rs.GetObject("Select Stair Guide Curve", rs.filter.curve, True) if route is None: return if 'stair-widthDefault' in sc.sticky: widthDefault = sc.sticky['stair-widthDefault'] if 'stair-heightDefault' in sc.sticky: heightDefault = sc.sticky['stair-heightDefault'] width = rs.GetReal("Stair Width", number=widthDefault, minimum=widthMin, maximum=widthMax) if width is None: return height = rs.GetReal("Stair Height", number=heightDefault, minimum=heightMin) if height is None: return sc.sticky['stair-widthDefault'] = width sc.sticky['stair-heightDefault'] = height try: stairGeo = stairHeight(route, width, height) result = True except: result = False try: layers.AddLayerByNumber(401, False) layerName = layers.GetLayerNameByNumber(401) rs.ObjectLayer(stairGeo, layerName) except: pass utils.SaveFunctionData('Architecture-Stair', [ width, height, str([(pt.X, pt.Y, pt.Z) for pt in rs.CurveEditPoints(route)]), result ]) utils.SaveToAnalytics('Architecture-Stair')
def FilamentCalculator(): """3D Printing filament length, weight, volume calculator.""" input_obj = rs.SelectedObjects() if not input_obj: input_obj = rs.GetObjects("Select objects") if not input_obj: return volume = 0.0 for o in input_obj: if rs.IsMesh(o): a, b, c = rs.MeshVolume(o) volume += b elif rs.IsObjectSolid(o): a, b = rs.SurfaceVolume(o) volume += a if volume == 0.0: return filaments = { "PLA": 1.24, "ABS": 1.05, "ASA": 1.07, "PETG": 1.27, "PETT": 1.45, "HIPS": 1.07, "TPU": 1.30, "PMMA": 1.18, "Nylon": 1.08, "Polycarbonate": 1.20, "Copperfill": 3.90 } filament = rs.GetString("Material:", "PLA", [a for a in filaments]) density = filaments[filament] volume = volume / rs.UnitScale(rs.UnitSystem(), 3)**3 weight = volume * filaments[filament] l1 = volume / (math.pi * (0.175 / 2)**2) / 100 l2 = volume / (math.pi * (0.285 / 2)**2) / 100 l3 = volume / (math.pi * (0.3 / 2)**2) / 100 volume = round(volume, 3) weight = round(weight, 3) l1 = round(l1, 2) l2 = round(l2, 2) l3 = round(l3, 2) message = """{f}: Density = {d} grams / cubic centimeter Volume = {v} cubic centimeters Weight ~ {w} grams 1.75 mm filament length ~ {l1} meters 2.85 mm filament length ~ {l2} meters 3.00 mm filament length ~ {l3} meters""" message = message.format(f=filament, d=density, v=volume, w=weight, l1=l1, l2=l2, l3=l3) rs.MessageBox(message, buttons=0, title="FilamentCalculator:") print(message)
def Generation(): #SETTING UP THE FILE ACCESS TO READ ALL THERE IS TO BE READ #THE SCRIPT FROM NOW ON LOOKS for FILE AND if IT CANNOT FIND ONE IT WILL HAVE TO MAKE ONE #SOOO WE START BY LOOKING for AND READING THE FILE if WE FIND IT ## ######################################################################## #READ INFO IN THE FILE ######################################################################## #ReadFile returns an array of [isAlive,startPoint,jointNos] content = History.ReadPolies(folder, file) rhUnitInches = 8 rs.UnitSystem(rhUnitInches, False, True) zero = [0, 0, 0] zaxis = [0, 0, 1] vrt = [] #Decimal display and decimal places #rs.UnitDistanceDisplayMode(0) #rs.UnitDistanceDisplayPrecision(7) #sth to control that we have an [0,0,0] to check endcheck = 1 size = 1 living = [] startpts = [] sequences = [] #if we read nothing we should save 1 starting point - namely [0,0,0] if content is None: living = [1] startpts = [[0, 0, 0]] sequences = [[0]] npolies = 0 content = [[living[0], startpts[0], sequences[0]]] endcheck = 0 else: for rib in content: living.append(rib[0]) startpts.append(rib[1]) sequences.append(rib[2]) #checking if new rib has actualy been started #[0,0,0] will always be there to be grown if rs.Distance(content[-1][1], [0, 0, 0]) < tiny: endcheck = 0 # if not and we have less than 4 legs start a new leg at [0,0,0] if (endcheck != 0 and len(content) < 4): ribs = content ribs.append([1, [0, 0, 0], [0]]) content = ribs endcheck = 0 living.append(1) startpts.append([0, 0, 0]) sequences.append([0]) npolies = len(content) narm = [] setforbool = [] content2 = [] crack = [] numb = 0 # P R O C E S S I N G #CASE 1. NOTHING HAS BEEN MADE. WE HAVE ONE EXISTING RIB. IT IS BUDDING (IT THINKS IT STARTS AT [0,0,0]) #NO CHECKS, NO INTERSECTIONS, THE B A S I C STUFF if npolies == 1: for i in range(noribs): rs.Command( "_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER") rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False, False) box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0], [5.25, 5.25, 0], [-5.25, 5.25, 0], [-5.25, -5.25, 0]]) rs.MoveObject(box2, move_it) line1 = [1, 0, 0] line1 = rs.VectorRotate(line1, i * 360 / (noribs), zaxis) sequence = [1, line1, [0]] polypoints = JointAccess.Outline(sequence[1], sequence[1], sequence[2]) verte = rs.AddPolyline(polypoints) intersection = rs.CurveCurveIntersection(verte, box2) if not intersection is None: sequence[0] = 0 rs.DeleteObject(verte) setforbool = [] setforbool.append(defject) setforbool.append( JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc)) container = rs.BooleanUnion(setforbool) if not container is None: defject = container(0) SaveNClean(defject, polypoints, numb, content2) numb = numb + 1 #CASE 2 ONE RIB HAS STARTED GROWING AND ONE RIB IS BUDDING (THINKS THE ENDPOINT IS (0,0,0)) #THE EXISTING RIB NEEDS TO CHECK FOR INTERECTIONS WITH ITSELF ALONE [MAYBE WITH THE BASE AS WELL????] #THE NEW RIB MUST MAKE SURE IT IS STARTING FROM A DIFFERENT POINT A N D THAT IT DOES NOT INTERSECT WITH EXISTING RIB elif npolies == 2 and rs.Distance(startpts[-1], [0, 0, 0]) <= tiny: #ADDING TO THE EXISTING RIB #THE LOOP BELOW IS INFRASTRUCTURE FOR CASE 3. RIGHT NOW IT ONLY HAS ONE ITERATION for i in range(npolies - 1): insequence = content[i] #do sth only if this particular rib is NOT DEAD if insequence[0] != 0: for i in range(noribs)[1:]: #i is going through 1 to 15 for different endings #in [s,e,q,u,e,n,c,e,0] we will get [s,e,q,u,e,n,c,e,i,0] rs.Command( "_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER" ) rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False, False) box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0], [5.25, 5.25, 0], [-5.25, 5.25, 0], [-5.25, -5.25, 0]]) rs.MoveObject(box2, move_it) joints = insequence[2][:-1] joints.append(i) joints.append(0) sequence = [1, insequence[1], joints] polypoints = JointAccess.Outline(sequence[1], sequence[1], sequence[2]) verte = rs.AddPolyline(polypoints) #CHECKING FOR SELF INTERSECTION #continue continues with the loop without reading the stuff below int = rs.CurveCurveIntersection(verte, None, 0.000001) if len(int) != 0: everything = rs.AllObjects() rs.DeleteObjects(everything) continue intersection = rs.CurveCurveIntersection(verte, box2) #NEED A SELF INTERSECTIOn CHECK if not intersection is None: sequence[0] = 0 rs.DeleteObject(verte) setforbool = [] setforbool.append(defject) setforbool.append( JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc)) container = rs.BooleanUnion(setforbool) if not container is None: defject = container(0) else: #print error message message = str(datetime.datetime.now() ) + "\n" + "BOOLEAN UNION FAIL" History.WriteFile( "C:\R3\OffCenter\Walk\ErrorMessage.dat", message) SaveNClean(defject, polypoints, numb, content2) numb = numb + 1 #MAKING OF THE NEW RIB other_ribs = [] for i in range(len(content) - 1): other_ribs.append(content[i]) for i in range(noribs): rs.Command( "_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER") rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False, False) box2 = rs.AddPolyline([[-5.25, -5.25, 0], [5.25, -5.25, 0], [5.25, 5.25, 0], [-5.25, 5.25, 0], [-5.25, -5.25, 0]]) rs.MoveObject(box2, move_it) line1 = [1, 0, 0] line1 = rs.VectorRotate(line1, i * 360 / (noribs), zaxis) sequence = [1, line1, [0]] polypoints = JointAccess.Outline(sequence[1], sequence[1], sequence[2]) verte = rs.AddPolyline(polypoints) #CHECKING FOR INTERSECTION with any of the already existent ribs #continue continues with the loop without reading the stuff below chck = False for i in range(len(content) - 1): chckpts = JointAccess.Outline(content[i][1], content[i][1], content[i][2]) chckcrv = rs.AddPolyline(chckpts) int = rs.CurveCurveIntersection(verte, chckcrv, 0.000001) if len(int) != 0: chck = True if chck: everything = rs.AllObjects() rs.DeleteObjects(everything) continue intersection = rs.CurveCurveIntersection(verte, box2) if not intersection is None: sequence[0] = 0 rs.DeleteObject(verte) setforbool = [] setforbool.append(defject) setforbool.append( JointAccess.Arm(sequence[1], sequence[1], sequence[2], fc)) for i in range(len(content) - 1): setforbool.append( JointAccess.Arm(content[i][1], content[i][1], content[i][2], fc)) container = rs.BooleanUnion(setforbool) if not container is None: defject = container(0) else: #print error message message = str( datetime.datetime.now()) + "\n" + "BOOLEAN UNION FAIL" History.WriteFile("C:\R3\OffCenter\Walk\ErrorMessage.dat", message) SaveNClean(defject, polypoints, numb, content2) numb = numb + 1 elif npolies > 2 and rs.Distance(startpts[-1], [0, 0, 0]) <= tiny: print "case npolies>2 and one budding not coded yet" else: print "case npolies>2 and none budding" #THE OUTERMOST POINT ROTATES THROUGH THE END POINTS - whatever that means:P """ for k in range(len(content)): #OOOOOOO #OOOOOOO #OOOOOOO #OOOOOOO #G O I N G T H R O U G H L I V I N G R I B S #if RIB IS ALIVE THEN DO WHAT FOLLOWS OTHERWISE THERE IS NOTHING TO LOOK AT #WHAT if ALL DIES??? I WILL WORRY ABOUT IT LATER for i in range(len(noribs)): rs.Command("_-Import C:\R3\OffCenter\Walk\Temp\protoslant_walk.igs ENTER") rs.Command("_SelAll") rs.Command("_Join") rs.Command("_SelNone") rs.Command("_SelAll") defject = rs.SelectedObjects(False,False) box2 = rs.AddPolyline([[-5.25,-5.25,0],[5.25,-5.25,0],[5.25,5.25,0],[-5.25,5.25,0],[-5.25,-5.25,0]]) rs.MoveObject(box2, move_it) pas = 1 con2 = -1 if rs.Distance(endpts[k],[0,0,0]) < tiny: #If we are working with a new rib then we need to set a new beginning. line1 = [1,0,0] line1 = rs.VectorRotate(line1,i*360/(noribs),zaxis) sequence = [1,line1,[0]] #TEST1 - CHECK for LEAVING OFF IN THE SAME DIRECTION pas = 1 for pt in startpts: if rs.Distance(pt,line1)<tiny: pas = 0 #TEST2 - CHECK for OVERLAP WITH OTHER CURVES if pas = 1: for j = 0 To npolies #CAN#T DO INTERSECTION WITH CURVE THAT HASN#T GROWN YET - OUTLINE PRODUCTION if rs.Distance(content(0](j](1],[0,0,0]] > tiny And j<>k Then carrier = content(0](j] con2 = con2 + 1 ReDim Preserve content2(con2] content2(con2] = Outline(carrier(1],carrier(1],carrier(2]] ReDim Preserve vrt(con2] vrt(con2] = rs.PolylineVertices(content2(j]] elif rs.Distance(content(0](j](1],[0,0,0]] < tiny And j=k Then carrier = sequence con2 = con2 + 1 ReDim Preserve content2(con2] content2(con2] = Outline(carrier(1],carrier(1],carrier(2]] ReDim Preserve vrt(con2] vrt(con2] = rs.PolylineVertices(content2(j]] verte = content2 #TEST3 - CHECK for OVERLAP WITH THE BORDER - OVERLAP = KILL intersection = rs.CurveCurveIntersection(verte(k],box2] if intersection not is None: sequence(0] = 0 for j = 0 To npolies if j <> k Then intersection = rs.CurveCurveIntersection(verte(k],verte(j]] if Not isNull(intersection] Then rs.DeleteObjects(verte] pass = 0 Exit for rs.DeleteObjects(verte] #STEP 4 - PRINT THE ARMS AND BOOLEAN THE HELL OUT OF THEM SAVE THEM ETC if pass = 1 Then for j = 0 To npolies if j <> k Then content2(j] = content(0](j] Else content2(k] = sequence End if Next ReDim setforbool(npolies+1] setforbool(0] = defject for j = 0 To npolies setforbool(j+1] = Arm(content2(j](1],content2(j](1],content2(j](2]] Next #BOOLEAN THINGS UP container = rs.BooleanUnion(setforbool] if Not IsNull(container] Then defject = container(0] End if SaveNClean(defject,vrt,numb,k,content2] numb = numb + 1 Else objects = rs.AllObjects(] rs.DeleteObjects(objects] End if Else if i <> 0 Then #STEP0 - MAKE A NEW RIB line1 = i size2 = UBound(content(0](k](2]] ReDim crack(size2+1] for j = 0 To size2-1 crack(j] = content(0](k](2](j] Next crack(size2] = line1 crack(size2+1] = 0 sequence = [content(0](k](0],content(0](k](1],crack] #TEST1 - CHECK for LEAVING OFF IN THE SAME DIRECTION #DROPPED if pass = 1 Then for j = 0 To npolies #CAN#T DO INTERSECTION WITH CURVE THAT HASN#T GROWN YET - OUTLINE PRODUCTION if rs.Distance(content(0](j](1],[0,0,0]] > tiny Then carrier = sequence con2 = con2 + 1 ReDim Preserve content2(con2] content2(con2] = Outline(carrier(1],carrier(1],carrier(2]] ReDim Preserve vrt(con2] vrt(con2] = rs.PolylineVertices(content2(j]] End if Next verte = content2 #TEST3 - CHECK for OVERLAP WITH THE BORDER - OVERLAP = KILL intersection = rs.CurveCurveIntersection(verte(k],box2] if Not isNull(intersection] Then sequence(0] = 0 End if #TEST2 - CHECK for OVERLAP WITH OTHER CURVES for j = 0 To con2 if j <> k Then intersection = rs.CurveCurveIntersection(verte(k],verte(j]] if Not isNull(intersection] Then pas = 0 Exit for End if End if Next rs.DeleteObjects(verte] End if #STEP 4 - PRINT THE ARMS AND BOOLEAN THE HELL OUT OF THEM SAVE THEM ETC if pass = 1 Then for j = 0 To con2 #[0,0,0] can only happen in the last poly if j <> k Then content2(j] = content(0](j] Else content2(k] = sequence End if Next ReDim setforbool(con2+1] setforbool[0] = defject for j = 0 To con2 setforbool[j+1] = Arm(content2[j][1],content2[j][1],content2[j][2]) container = rs.BooleanUnion(setforbool) if container not is None: defject = container(0) SaveNClean(defject,vrt,numb,k,content2) numb = numb + 1 else: objects = rs.AllObjects(] rs.DeleteObjects(objects] """ ## ######################################################################## #making a text file that will be read by python to decide how many iterations to run on testing ######################################################################## History.WriteFile(tempfolder, str(numb)) ######################################################################## ## #DONE History.WriteFile(tempfolder + "OutputNo.txt", str(numb)) #SET UP A CLEAN EXIT rs.Command("-saveas C:\\R3\OffCenter\Walk\Temp\rubbish.3dm")
def exportToRenderDWG(): try: fileLocations = config.GetDict() print "Exporting to 3ds max" objs = rs.GetObjects("Select objects to export", preselect=True) if objs is None: return #SAVE FILE NAME defaultFolder = rs.DocumentPath() defaultFilename = utils.GetDatePrefix() + '_OPTION_01' fileName = rs.SaveFileName("Export to render", "Autocad (*.dwg)|*.dwg||", defaultFolder, defaultFilename) if fileName is None: return base=os.path.basename(fileName) cadName = os.path.splitext(base)[0] #SUPER EXPLODE #EXPLODE SELECTED BLOCKS (CHECKLIST) #blockNames = rs.BlockNames(True) #print blockNames #results = rs.CheckListBox(blockNames, "Select blocks to explode", "Explode for render") #CHECK BACKFACES #CHECK GEOMETRY #EXPORT EACH LAYER AS SAT FILE. #CHECK ORIGIN #INSERT ORIGIN #CHECK SCALE (Units) if rs.UnitSystem() == 8: print "Units checked" else: print "This model is in {}, it should be in Inches".format(rs.UnitSystemName(singular=False)) #UNIFY MESH NORMALS #MERGE ALL EDGES #MERGE ALL FACES #DELETE DUPS #rs.UnselectAllObjects() #rs.Command('-_Seldup ', echo=False) #dupObjs = rs.SelectedObjects() #if len(dupObjs) > 0: # rs.DeleteObjects(dupObjs) # print "{} duplicate objects deleted".format(len(dupObjs)) #JOIN BY LAYER #PLACE UNDER A PARENT LAYER W/ DATESTAMP AddMasterRootLayer(cadName) #CHANGE LAYER NAMES? #IMPORT ACAD SCHEME standards.LoadAcadSchemes(fileLocations['ACAD Scheme Folder']) #SET DEFAULT FOLDER TO REFERENCE FOLDER UNDER RENDERING #EXPORT TO DWG rs.SelectObjects(objs) exportScheme = 'PCPA_MaxSolids' rs.Command('-_Export ' + '"' + fileName + '" S ' + '"' + exportScheme + '"' + ' Enter P 100 Enter', False) #REMOVE MASTER ROOT LAYER RemoveMasterRootLayer(cadName) return True except: return False
print resultsCompletedMsg print printOutputMsg level = Grasshopper.Kernel.GH_RuntimeMessageLevel.Warning level_remark = Grasshopper.Kernel.GH_RuntimeMessageLevel.Remark if sc.sticky.has_key("gismoGismo_released"): validVersionDate, printMsg = sc.sticky["gismo_check"].versionDate(ghenv.Component) if validVersionDate: gismo_preparation = sc.sticky["gismo_Preparation"]() randomRange, randomRangeStart, randomRangeEnd, roofType, roofType_str, shapeType, unitConversionFactor, validInputData, printMsg = checkInputData(_threeDeeShapes, _threeDeeKeys, _threeDeeValues, randomRange_, roofType_) if validInputData: if _runIt: if (rs.UnitSystem() == 4): threeDeeRoof, threeDeeRoofValues, angleOrHeight, valid_keysAndValues, printMsg = createThreeDeeRoofs(_threeDeeShapes, _threeDeeKeys, _threeDeeValues, randomRange, randomRangeStart, randomRangeEnd, roofType, roofType_str, unitConversionFactor) if valid_keysAndValues: #printOutput(randomRangeStart, randomRangeEnd, roofType) threeDeeRoofKeys = _threeDeeKeys else: print printMsg ghenv.Component.AddRuntimeMessage(level, printMsg) else: printMsg = "This is the only Gismo component which may experience issues if pitched 3d roof is not created in Meter units.\n" + \ "Set your Rhino units to \"Meters\", rerun this component, then bake the results and copy paste them into the Rhino file with your desired units. The roof geometry will be automatically scalled." print printMsg ghenv.Component.AddRuntimeMessage(level, printMsg) else: print "All inputs are ok. Please set \"_runIt\" to True, in order to run the OSM 3D Roof component" else:
def VolumeMassWeightCentroids(_materials, _densities): # object ids objects = rs.GetObjects("Pick objects of the same material", 16, preselect=True) if objects: objectsClosed = [] for obj in objects: if rs.IsPolysurfaceClosed(obj) == True: objectsClosed.append(obj) if len(objectsClosed) > 0: # choose material pickedMaterial = rs.ListBox(_materials, "Choose the material", "Material", "Stainless Steel ") if pickedMaterial: for i in range(len(materials)): if _materials[i] == pickedMaterial: density = _densities[i] break # units correction unitsystemIndex = rs.UnitSystem() if unitsystemIndex == 0: print "No unit system. Operation terminated" return elif unitsystemIndex == 2: #mm density = density / 1000000 massFactor = 0.001 massUnits = "g" volumeUnits = "mm3" lengthUnits = "mm" elif unitsystemIndex == 3: #cm density = density / 1000 massFactor = 0.001 massUnits = "g" volumeUnits = "cm3" lengthUnits = "cm" elif unitsystemIndex == 4: #m density = density massFactor = 1 massUnits = "kg" volumeUnits = "m3" lengthUnits = "m" elif unitsystemIndex == 8: #inches density = density * 0.00057803667443635 massFactor = 0.0283495 massUnits = "oz" volumeUnits = "in3" lengthUnits = "in" elif unitsystemIndex == 9: #feet density = density * 0.998847 massFactor = 0.453592 massUnits = "lb" volumeUnits = "ft3" lengthUnits = "ft" else: print "You are not using one of these unit systems: mm, cm, m, in, ft. Function terminated" return # volumes, masses, weights, centroids volumes = [] masses = [] centroids = [] weights = [] for obj in objectsClosed: vol = rs.SurfaceVolume(obj)[0] volumes.append(vol) mass = density * vol masses.append(mass) weight = mass * massFactor * 9.81 # additionally multiply with "0.001" in case you want Kilonewtons instead of Newtons for weight unit weights.append(weight) centr = rs.SurfaceVolumeCentroid(obj)[0] centroids.append(centr) # export data to csv file filename = rs.SaveFileName("Save csv file", "*.csv||", None, "VolMassWeigCen", "csv") file = open(filename, 'w') headerline = "Object name, Volume(%s), Mass(%s), Weight(N), Centroid(%s)[x], Centroid(%s)[y], Centroid(%s)[z]\n" % ( volumeUnits, massUnits, lengthUnits, lengthUnits, lengthUnits) file.write(headerline) index = 0 for i in range(len(objectsClosed)): objectName = rs.ObjectName(objectsClosed[i]) if not objectName: index += 1 objectName = "obj%s" % (index) volu = volumes[i] mas = masses[i] weig = weights[i] x = centroids[i][0] y = centroids[i][1] z = centroids[i][2] line = "%s,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f \n" % ( objectName, volu, mas, weig, x, y, z) # adding an annotation text dot to Rhino: rs.AddPoint(centroids[i]) rs.AddTextDot(objectName, centroids[i]) file.write(line) file.close() print "Done" else: print "You did not choose material. Function terminated." return else: print "All of objects you picked are not closed (solids). Function terminated" return else: print "You did not choose appropriate or any objects. Function terminated." return
def AreaTag(obj, decPlaces): try: rhsrf = rs.coercesurface(obj) if rs.IsCurve(obj): if rs.IsCurvePlanar(obj) == False: return [0, False] if rs.IsCurveClosed(obj) == False: return [0, False] #get area if rs.UnitSystem() == 8: if rs.IsCurve(obj): area = rs.CurveArea(obj)[0]*0.0069444444444444 else: area = rs.Area(obj)*0.0069444444444444 areaText = utils.RoundNumber(area, decPlaces) + " SF" else: print "WARNING: Your units are not in inches" area = rs.CurveArea(obj)[0] areaText = area + ' ' + rs.UnitSystemName(False, True, True) #add annotation style dimStyle = sc.doc.DimStyles.FindName('PCPA_12') ########################################################################### #CURVES if rs.IsCurve(obj): if utils.IsRectangle(obj)[0]: #RECTANGLES srf = rs.AddPlanarSrf(obj) plane = HorizPlaneFromSurface(srf) rs.DeleteObject(srf) else: #OTHER CURVES srf = rs.AddPlanarSrf(obj) plane = HorizPlaneFromSurface(srf) rs.DeleteObject(srf) ########################################################################### #HATCHES elif rs.IsHatch(obj): rhobj = rs.coercegeometry(obj) boundaryCrvs = [] crvs = rhobj.Get3dCurves(False) for crv in crvs: boundaryCrvs.append(crv) for crv in rhobj.Get3dCurves(True): boundaryCrvs.append(crv) srf = sc.doc.Objects.AddBrep(rc.Geometry.Brep.CreatePlanarBreps(boundaryCrvs)[0]) plane = HorizPlaneFromSurface(srf) rs.DeleteObject(srf) ########################################################################### #SURFACES elif rs.IsSurface(obj): plane = HorizPlaneFromSurface(obj) ########################################################################### #OTHER/ERROR else: pts = rs.BoundingBox(obj) centerPoint = (pts[0] + pts[6]) / 2 if dimStyle is not None: textHeight = dimStyle.TextHeight areaTag = rs.AddText(areaText, plane, height = textHeight, justification = 131074) else: areaTag = rs.AddText(areaText, plane, height = 1, justification = 131074) #Change layers hostLayer = layers.AddLayerByNumber(8103, False) rs.ObjectLayer(areaTag, layers.GetLayerNameByNumber(8103)) return [area, True, areaTag] except: return [0, False]
def createSinglePDF(_view, _saveFolder, _fileName): # Takes in a RhinoView and Exports it to PDF subFolder = '' #'\Exports\\' outputFolderPath = '{}{}'.format(_saveFolder, subFolder) if outputFolderPath[-1] == '\\': pass else: outputFolderPath = outputFolderPath + '\\' # If the folder doesn't already exist, create it if os.path.exists(os.path.dirname(outputFolderPath)) == False: print 'Creating the folder: {}'.format(outputFolderPath) os.makedirs(os.path.dirname(outputFolderPath)) else: pass # Layout Page Size in Layout's Units pageHeight = sc.doc.Views.ActiveView.PageHeight pageWidth = sc.doc.Views.ActiveView.PageWidth # Layout Page Size in Inches # Ref: https://developer.rhino3d.com/api/RhinoScriptSyntax/#document-UnitScale # Ref: https://developer.rhino3d.com/api/RhinoCommon/html/P_Rhino_RhinoDoc_PageUnitSystem.htm pageUnitSysemNumber = rs.UnitSystem(in_model_units=False) pageHeight = pageHeight * rs.UnitScale( 8, pageUnitSysemNumber) # Type 8 = Inches pageWidth = pageWidth * rs.UnitScale(8, pageUnitSysemNumber) pageHeight = round(pageHeight, 2) pageWidth = round(pageWidth, 2) pdf = Rhino.FileIO.FilePdf.Create() dpi = 300 size = System.Drawing.Size(pageWidth * dpi, pageHeight * dpi) # Should get this from the view? settings = Rhino.Display.ViewCaptureSettings(_view, size, dpi) settings.OutputColor = Rhino.Display.ViewCaptureSettings.ColorMode.DisplayColor pdf.AddPage(settings) filePath = outputFolderPath + _fileName + '.pdf' pdf.Write(filePath)