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)
