def CockpitWindowContours(Height=1.620, Depth=5):
P1 = [0.000, 0.076, Height - 1.620 + 2.194]
P2 = [0.000, 0.852, Height - 1.620 + 2.290]
P3 = [0.000, 0.904, Height + 0.037]
P4 = [0.000, 0.076, Height]
CWC1 = rs.AddPolyline([P1, P2, P3, P4, P1])
rs.SelectObject(CWC1)
rs.Command("_FilletCorners 0.08 ")
P1 = [0.000, 0.951, Height - 1.620 + 2.289]
P2 = [0.000, 1.343, Height - 1.620 + 2.224]
P3 = [0.000, 1.634, Height - 1.620 + 1.773]
P4 = [0.000, 1.557, Height - 1.620 + 1.588]
P5 = [0.000, 1.027, Height - 1.620 + 1.671]
CWC2 = rs.AddPolyline([P1, P2, P3, P4, P5, P1])
rs.SelectObject(CWC2)
rs.Command("_FilletCorners 0.08 ")
CWC3 = act.MirrorObjectXZ(CWC1)
CWC4 = act.MirrorObjectXZ(CWC2)
ExtPathId = rs.AddLine([0, 0, 0], [Depth, 0, 0])
CWC1s = rs.ExtrudeCurve(CWC1, ExtPathId)
CWC2s = rs.ExtrudeCurve(CWC2, ExtPathId)
CWC3s = rs.ExtrudeCurve(CWC3, ExtPathId)
CWC4s = rs.ExtrudeCurve(CWC4, ExtPathId)
rs.DeleteObjects([CWC1, CWC2, CWC3, CWC4, ExtPathId])
return CWC1s, CWC2s, CWC3s, CWC4s
def d(t, n):
"""
receives:
t = theta syuuki of sin (0 < t < 90)
n = number of waves (0 < n < 50)
works:
draw waves
returns:
None
"""
for x in range(0, n):
points = []
for y in range(1, n):
p = (x, y, ma.sin((ma.radians(t * (y + x)))))
points.append(p)
#rs.AddPoint(p)
a = rs.AddCurve(points, 5)
b = rs.AddLine((x, 0, 0), (x + 0.7, 0, 0))
rs.ExtrudeCurve(a, b)
for y in range(1, n):
list = []
for x in range(0, n):
p = (x, y, ma.cos(ma.radians(t * (x + y))))
list.append(p)
a = rs.AddCurve(list, 5)
b = rs.AddLine((0, y, 0), (0, y + 0.7, 0))
rs.ExtrudeCurve(a, b)
def c():
a = rs.AddLine((0, 0, 0), (0, 0, 1))
p = []
r = 10
for k in range(0, 50):
t = (k * ma.sin((k * r) / (2 * ma.pi)), k * ma.cos(
(k * r) / (2 * ma.pi)), 0)
p.append(t)
b = rs.AddCurve(p, 5)
rs.ExtrudeCurve(a, b)
def MakeWindow(FuselageSrf, Xwc, Zwc):
WinCenter = [Xwc, Zwc]
WCurve = WindowContour(WinCenter)
ExtPathStbd = rs.AddLine([0, 0, 0], [0, 10, 0])
ExtPathPort = rs.AddLine([0, 0, 0], [0, -10, 0])
TubeStbd = rs.ExtrudeCurve(WCurve, ExtPathStbd)
FuselageSrf, WinStbd = rs.SplitBrep(FuselageSrf,
TubeStbd,
delete_input=True)
TubePort = rs.ExtrudeCurve(WCurve, ExtPathPort)
FuselageSrf, WinPort = rs.SplitBrep(FuselageSrf,
TubePort,
delete_input=True)
rs.DeleteObjects([TubeStbd, TubePort, ExtPathStbd, ExtPathPort, WCurve])
return WinStbd, WinPort, FuselageSrf
def draw_sikaku(h):
p1 = (1000, 1000, h)
p2 = (1000, -1000, h)
p3 = (1000, 0, h)
p4 = (-1000, 0, h)
path = rs.AddLine(p1, p2)
side = rs.AddLine(p3, p4)
plate = rs.ExtrudeCurve(path, side)
rs.DeleteObject(path)
rs.DeleteObject(side)
return plate
def get_frame_brep(outline_srf, border_thickness, thickness):
"""get the frame brep. This is a solid that is booleaned with the slices of
terrain to make a border when border mode is on."""
edge_crvs = rs.DuplicateEdgeCurves(outline_srf)
outline_crv = rs.JoinCurves(edge_crvs)
pt, _ = rs.CurveAreaCentroid(outline_crv)
inner_crv = rs.OffsetCurve(outline_crv, pt, border_thickness, [0, 0, 1])
rs.MoveObjects([outline_crv, inner_crv], [0, 0, thickness * 2])
path_line = rs.AddLine([0, 0, 0], [0, 0, -thickness * 4])
inner_brep = rs.ExtrudeCurve(inner_crv, path_line)
outer_brep = rs.ExtrudeCurve(outline_crv, path_line)
rs.CapPlanarHoles(inner_brep)
rs.CapPlanarHoles(outer_brep)
frame_brep = rs.BooleanDifference([outer_brep], [inner_brep])
rs.DeleteObjects([outline_crv, inner_crv])
rs.DeleteObjects(edge_crvs)
rs.DeleteObject(path_line)
return frame_brep
def draw_sikaku(i):
h = height = 100
r = radius = 100
theta = ma.radians(i)
p1 = (0, 0, 0)
p2 = (0, 0, h)
path = rs.AddLine(p1, p2)
side = rs.AddLine((0, 0, -3), (r * ma.cos(theta), r * ma.sin(theta), -3))
plate = rs.ExtrudeCurve(side, path)
rs.DeleteObject(path)
rs.DeleteObject(side)
return plate
def make(self):
self.segments = rs.ExplodeCurves(self.Rect)
treadLength = rs.CurveLength(self.segments[1]) / self.numRisers
riserHeight = self.deltaHeight / self.numRisers
runVector = rs.VectorCreate(
rs.CurveEndPoint(self.segments[1]),
rs.CurveStartPoint(self.segments[1]))
unitRunVec = rs.VectorUnitize(runVector)
treadVec = rs.VectorScale(unitRunVec, treadLength)
riseVec = rs.VectorCreate([0, 0, riserHeight], [0, 0, 0])
newPt = [
rs.CurveStartPoint(self.segments[0]).X,
rs.CurveStartPoint(self.segments[0]).Y,
rs.CurveStartPoint(self.segments[0]).Z - self.deltaHeight
]
ptList = []
ptList.append(rs.AddPoint(newPt))
for i in range(self.numRisers):
tempPt = rs.CopyObject(ptList[-1])
rs.MoveObject(tempPt, riseVec)
ptList.append(tempPt)
tempPt = rs.CopyObject(ptList[-1])
rs.MoveObject(tempPt, treadVec)
ptList.append(tempPt)
downLine = rs.VectorCreate([0, 0, 0], [0, 0, self.thickness])
newBtmPt = rs.MoveObject(rs.CopyObject(ptList[0]), downLine)
ptList.insert(0, newBtmPt)
newBtmPt2 = rs.MoveObject(rs.CopyObject(ptList[-1]), downLine)
ptList.append(newBtmPt2)
stringer = rs.AddPolyline(ptList)
closeCrv = rs.AddLine(rs.CurveStartPoint(stringer),
rs.CurveEndPoint(stringer))
newStringer = rs.JoinCurves([stringer, closeCrv], True)
stair = rs.ExtrudeCurve(newStringer, self.segments[0])
rs.CapPlanarHoles(stair)
rs.DeleteObject(stringer)
rs.DeleteObject(newStringer)
rs.DeleteObjects(ptList)
rs.DeleteObjects(self.segments)
return stair
def e(theta, num):
"""
receives:
theta = degree of line ( 0 < theta < 45 )
num = number of pattern ( 0 < num < 15 )
works:
draw tile pattern
returns:
None
"""
def base(x, y):
d = ma.radians(theta)
r = 1 / ma.cos(d) - (ma.sin(d)**2) / ma.cos(d)
n = r * ma.sin(d)
k = r * ma.cos(d)
a1 = (x, y, 0)
b1 = (x, y + 1, 0)
c1 = (x + 1, y + 1, 0)
d1 = (x + 1, y, 0)
a2 = (x + k, y + n, 0)
b2 = (x + n, y + 1 - k, 0)
c2 = (x + 1 - k, y + 1 - n, 0)
d2 = (x + 1 - n, y + k, 0)
l1 = rs.AddLine(a1, a2)
l2 = rs.AddLine(b1, b2)
l3 = rs.AddLine(c1, c2)
l4 = rs.AddLine(d1, d2)
for i in range(0, num):
for k in range(0, num):
base(i, k)
line = rs.ObjectsByType(0)
n = len(line)
for i in range(0, n):
a = line[i]
b = rs.AddLine((0, 0, 0), (0, 0, 0.05))
c = rs.RotateObject(b, (0, 0, 0), 90, None, False)
s = rs.ExtrudeCurve(a, b)
rs.ExtrudeSurface(s, c)
def splitSrfVerticallyByPts(srf,pts):
normals=[]
up=(0,0,1000000000)
half=(0,0,500000000)
cutters=[]
for p in pts:
uv=rs.SurfaceClosestPoint(srf,p)
normal=rs.SurfaceNormal(srf,uv)
normal=rs.VectorScale(normal,1000)
normals.append(normal)
botStart=rs.VectorAdd(rs.VectorSubtract(p,half),normal)
botEnd=rs.VectorSubtract(rs.VectorSubtract(p,half),normal)
l=rs.AddLine(botStart,botEnd)
path=rs.AddLine(botStart,rs.VectorAdd(botStart,up))
cutter=rs.ExtrudeCurve(l,path)
rs.DeleteObjects([l,path])
#print(rs.IsBrep(cutter))
#print(cutter)
cutters.append(cutter)
# rs.SelectObjects(cutters)
srfs=splitSrfBySrfs(srf,cutters)
return srfs
import rhinoscriptsyntax as rs
import random
pickedCurves = rs.GetObjects("pick some curves", 4)
desiredArea = 1000.0
for curve in pickedCurves:
length = rs.CurveLength(curve)
extrudeAmt = desiredArea / length
direcitonalVector = (random.uniform(-10, 10), random.uniform(-10, 10),
random.uniform(-10, 10))
#how we have a vector with random x, y and z components
#to give it the precise amplitude we want, we will normalize it, meaning it will keep the direction, but have a length of one unit
#then, we'll scale the vector to the desired amplitude
unitVect = rs.VectorUnitize(direcitonalVector)
scaledVect = rs.VectorScale(unitVect, extrudeAmt)
startPoint = rs.CurveMidPoint(curve)
endPoint = rs.VectorAdd(startPoint, scaledVect)
pathCurve = rs.AddLine(startPoint, endPoint)
rs.ExtrudeCurve(curve, pathCurve)
rs.DeleteObject(pathCurve)
#further example: how to put the surface on a new layer
Points1 = rs.DivideCurve(L1, Ndiv, False)
#Second line of the base
p1 = (-1*L, W, 0)
p2 = (L,W,0)
L2 = rs.AddLine(p1, p2)
Points2 = rs.DivideCurve(L2, Ndiv, False)
#Stiffners of the base
rs.CurrentLayer("Beams")
for i in range(Ndiv + 1):
A_line = rs.AddLine(Points1[i], Points2[i])
rs.ExtrudeCurve(A_line, path)
rs.DeleteObject(A_line)
#Platform of the base
rs.CurrentLayer("Surface")
rs.AddLoftSrf([L1, L2])
#Definition of parabola points
rs.CurrentLayer("Points")
for i in range(Ndiv + 1):
x = Points1[i][0]
P = [x, 0, Amp*(x-L)*(x + L)*(-1/10)]
Points3.append(rs.AddPoint(P))
#Vertical lines btw Points1(base) and Points3 (Points form parabola)
rs.CurrentLayer("Columns")
def dd(t, n):
"""
receives:
t = theta syuuki of sin (0 < t < 90)
n = number of waves (0 < n < 200)
works:
draw waves
returns:
None
"""
list = []
for x in range(0, n):
for y in range(0, n):
p = [x, y, 0]
list.append(p)
number = len(list)
rx = rd.random() * n
ry = rd.random() * n
nn = n / 2
for k in range(0, number):
x = list[k][0]
y = list[k][1]
dx = x - rx
dy = y - ry
d = ma.sqrt(dx**2 + dy**2)
if d < nn:
list[k][2] = list[k][2] + (
(nn - d) / 6) * ma.sin(ma.radians(d * 10))
else:
pass
rx = rd.random() * n
ry = rd.random() * n
for k in range(0, number):
x = list[k][0]
y = list[k][1]
dx = x - rx
dy = y - ry
d = ma.sqrt(dx**2 + dy**2)
if d < nn:
list[k][2] = list[k][2] + (nn - d) / 3 * ma.cos(ma.radians(d * 3))
else:
None
rx = rd.random() * n
ry = rd.random() * n
for k in range(0, number):
x = list[k][0]
y = list[k][1]
dx = x - rx
dy = y - ry
d = ma.sqrt(dx**2 + dy**2)
if d < nn:
list[k][2] = list[k][2] + (nn - d) / 10
else:
None
for i in range(0, n):
a = rs.AddCurve(list[i * n:(i + 1) * n], 5)
b = rs.AddLine((x, 0, 0), (x + 0.7, 0, 0))
rs.ExtrudeCurve(a, b)
import rhinoscriptsyntax as rs
import random
pickedCurves = rs.GetObjects("pick some curves", 4)
for curve in pickedCurves:
#note, this is a good example of crafting procedure in reverse
startPoint = rs.CurveMidPoint(curve)
goalPoint = (startPoint[0], startPoint[1], 0)
pathLine = rs.AddLine(startPoint, goalPoint)
rs.ExtrudeCurve(curve, pathLine)
rs.DeleteObject(pathLine)
def cube(x, y, z):
line1 = rs.AddLine((x, y, z), (x, y + 5, z))
line2 = rs.AddLine((x, y, z), (x + 5, y, z))
surface = rs.ExtrudeCurve(line1, line2)
line3 = rs.AddLine((x, y, 0), (x, y, 5))
rs.ExtrudeSurface(surface, line3)
bottom_planes.append(planes)
# Rotate planes on ZAxis
rotated_planes = []
for i in bottom_planes:
plane = rs.ViewCPlane()
rndm_angle = random.randrange(-5, 5)
rotated_z = rs.RotatePlane(i, rndm_angle, planes.ZAxis)
# Tilt control
tilt = random.randrange(-5, 5) * max_tilt
rotated_x = rs.RotatePlane(rotated_z, tilt, planes.XAxis)
rotated_planes.append(rotated_x)
# Create solids
solids = []
lines = []
for j in range(0, len(rotated_planes)):
line = rs.AddLine(bottom_pts[j], top_pts[j])
lines.append(line)
tilt = random.randrange(-5, 5) * max_tilt
rot_lines = rs.RotateObject(line, bottom_pts[j], tilt, planes.XAxis, copy=False)
rct = rs.AddRectangle( rotated_planes[j],
rg.Interval(-0.5 * block_w, 0.5 * block_w),
rg.Interval(-0.5 * block_d, 0.5 * block_d))
solid = rs.ExtrudeCurve(rct, rot_lines)
sld = rs.CapPlanarHoles(solid)
solids.append(solid)
print('Ivan Perez | [email protected] | Bogotá | Colombia')
def Ramp_HeightSlope(path, width, slope):
#Variables
rampThickness = 6
handrailOffset = 3
handrailRadius = 1.5
handrailHeight = 34
if width < 36:
width = 36
width = width + (handrailOffset * 2)
comments = ''
handrailCenterlineOffset = (handrailOffset - handrailRadius / 2)
rs.SimplifyCurve(path)
runs = MakeRampRuns(path, width)
if slope > .05:
runData = CheckRunLengths(runs)
runs = runData[0]
comments += runData[1]
runGeo = []
hdrls = []
finalHandrails = []
vertMove = (0, 0, 0)
for run in runs:
length = rs.Distance(rs.CurveStartPoint(run[0]),
rs.CurveStartPoint(run[1]))
stHeight = vertMove
vertMove = (0, 0, length * slope)
rs.MoveObject(run[-1], vertMove)
rs.MoveObjects(run, stHeight)
vertMove = rs.VectorAdd(stHeight, vertMove)
srf = rs.AddLoftSrf(run)
norm = rs.SurfaceNormal(srf[0], [.5, .5])
if norm.Z < 0:
rs.FlipSurface(srf[0], True)
runGeo.append(srf[0])
else:
runGeo.append(srf[0])
hdrls.append(MakeHandrailFromRuns(run, handrailCenterlineOffset))
rs.DeleteObjects(run)
#Get highest and lowest lines
landingEdges = []
for run in runGeo:
curves = rs.DuplicateEdgeCurves(run)
highestIndex = None
highestValue = -999999
lowestIndex = None
lowestValue = 999999
for i, curve in enumerate(curves):
crvZ = rs.CurveMidPoint(curve)[2]
if crvZ < lowestValue:
lowestIndex = i
lowestValue = crvZ
if crvZ > highestValue:
highestIndex = i
highestValue = crvZ
lowestEdge = rs.CopyObject(curves[lowestIndex])
highestEdge = rs.CopyObject(curves[highestIndex])
landingEdges.append(lowestEdge)
rs.ReverseCurve(highestEdge)
landingEdges.append(highestEdge)
rs.DeleteObjects(curves)
comments += 'Total ramp height {}"\n'.format(str(highestValue))
#Make Landings
landingGeos = MakeRampLandings(landingEdges, handrailCenterlineOffset)
landings = landingGeos[0]
hdrls += landingGeos[1]
allHandrails = []
for hdrl in hdrls:
for each in hdrl:
allHandrails.append(each)
longRails = rs.JoinCurves(allHandrails, True)
#Handrail Extension
for rail in longRails:
stPt = rs.CurveStartPoint(rail)
stVec = rs.CurveTangent(rail, 0)
stVecProj = rs.VectorScale(
rs.VectorReverse(rs.VectorUnitize((stVec[0], stVec[1], 0))), 12)
endPt = rs.CurveEndPoint(rail)
endParam = rs.CurveClosestPoint(rail, endPt)
endVec = rs.CurveTangent(rail, endParam)
endVecProj = rs.VectorScale(
rs.VectorUnitize((endVec[0], endVec[1], 0)), 12)
stPtTemp = rs.CurveStartPoint(rail)
endPtTemp = rs.CurveEndPoint(rail)
stPtOffset = rs.MoveObject(stPtTemp, stVecProj)
endPtOffset = rs.MoveObject(endPtTemp, endVecProj)
stProj = rs.AddLine(stPt, stPtOffset)
endProj = rs.AddLine(endPt, endPtOffset)
finalHandrails.append(rs.JoinCurves([stProj, rail, endProj], True)[0])
rs.DeleteObject(stPtOffset)
rs.DeleteObject(endPtOffset)
#Move handrails up
for rail in finalHandrails:
rs.MoveObject(rail, (0, 0, handrailHeight))
#Make solid geometry
topSurface = rs.JoinSurfaces(runGeo + landings, True)
if topSurface is None: topSurface = runGeo
btmSurface = rs.CopyObject(topSurface, (0, 0, -rampThickness))
edgeCurves = rs.DuplicateSurfaceBorder(topSurface)
extrusionLine = rs.AddLine((0, 0, 0), (0, 0, -rampThickness))
extrusionGeo = rs.ExtrudeCurve(edgeCurves, extrusionLine)
rs.DeleteObject(extrusionLine)
rs.DeleteObject(edgeCurves)
finalGeo = rs.JoinSurfaces([topSurface, btmSurface, extrusionGeo], True)
#rs.EnableRedraw(True)
#print "A"
if slope <= .05:
rs.DeleteObjects(finalHandrails)
return [finalGeo, comments]
else:
return [finalGeo, comments, finalHandrails]
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minGapSize = .2
minTread = .260
maxRiser = .180
thickness = .15
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
rs.DeleteObject(rectSegments[2])
rs.DeleteObject(rectSegments[3])
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
rs.CurveArrows(longEdge, 2)
rs.CurveArrows(shortEdge, 2)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane,
rs.CurveLength(shortEdge), stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge),
shortVec, longVec)
landing2 = rs.AddRectangle(landing2Plane,
rs.CurveLength(shortEdge), stairWidth)
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
maxRisersPerRun = math.floor(runLength / minTread)
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / maxRisersPerRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] /
maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(
rs.MoveObject(rs.CopyObject(landing2), translation))
else:
landings.append(
rs.MoveObject(rs.CopyObject(landing1), translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i]))
stairGeo.append(runs[i].make())
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return finalGeo
coordinates2 = (x, y, 0)
rs.AddPoint(coordinates2)
coordinates2_list.append(coordinates2)
curve1 = rs.AddInterpCurve(coordinates1_list)
curve2 = rs.AddInterpCurve(coordinates2_list)
intersection_list = rs.CurveCurveIntersection(curve1, curve2)
#print(intersection_list)
points_intersection_list = []
for intersection in intersection_list:
if intersection[0] == 1:
print "Intersection point on first curve: ", intersection[1]
points_intersection_list.append(intersection[1])
#print(points_intersection_list)
distances = []
for point in points_intersection_list:
distances.append(rs.Distance((0, 0, 0), point))
print(distances)
distanceAndPointsPaired = zip(distances, points_intersection_list)
distanceAndPointsPaired.sort()
#need to take the second velue, because the first one is the beginning of the coordinates where the curves start
closestPoint = distanceAndPointsPaired[1][1]
closestDistance = distanceAndPointsPaired[1][0]
print(closestDistance)
#Extrude the curves by the pathline with the length that equals to the distance from the (0,0,0) to the closest intersection
(x, y, z) = closestPoint
endPoint = (x, y, z + closestDistance)
pathCurve = rs.AddLine(closestPoint, endPoint)
rs.ExtrudeCurve(curve1, pathCurve)
rs.ExtrudeCurve(curve2, pathCurve)
def makeFireStair(rect, landingLevels):
#HARD VARIABLES
minStairWidth = 1.118
minHeadroom = 2.032
maxRunRise = 3.658
minNumRisers = 3
minGapSize = .2
minTread = .280
maxTread = .400
minRiser = .100
maxRiser = .180
thickness = .25
maxRisersInRun = 16
maxWidth = 2.4
scissorStair = False
hdrlHeight = .900
#hdrlTopExtension = .305
#hdrlBtmExtension = 1*treadDepth
#hdrlMaxProjection = .114
#(1)Determine Run Direction
rs.SimplifyCurve(rect)
rectSegments = rs.ExplodeCurves(rect)
edge1 = rectSegments[0]
edge3 = rectSegments[1]
if rs.CurveLength(edge1) > rs.CurveLength(edge3):
longEdge = edge1
shortEdge = edge3
else:
longEdge = edge3
shortEdge = edge1
longVec = rs.VectorCreate(rs.CurveStartPoint(longEdge),
rs.CurveEndPoint(longEdge))
longVecRev = rs.VectorReverse(longVec)
shortVec = rs.VectorCreate(rs.CurveStartPoint(shortEdge),
rs.CurveEndPoint(shortEdge))
shortVecRev = rs.VectorReverse(shortVec)
#(2)Stair Width
stairWidth = (rs.CurveLength(shortEdge) - minGapSize) / 2
if stairWidth < .6:
print "ERROR: Stair is ridiculously too narrow."
return
#(3)Run Length
runLength = rs.CurveLength(longEdge) - (stairWidth * 2)
if runLength < 1:
print "ERROR: Stair is ridiculously too short."
return
#LandingRect
landing1Plane = rs.PlaneFromFrame(rs.CurveStartPoint(shortEdge),
shortVecRev, longVecRev)
landing1 = rs.AddRectangle(landing1Plane, rs.CurveLength(shortEdge),
stairWidth)
landing2Plane = rs.PlaneFromFrame(rs.CurveEndPoint(longEdge), shortVec,
longVec)
landing2 = rs.AddRectangle(landing2Plane, rs.CurveLength(shortEdge),
stairWidth)
#RunRects
run1Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing1)[3], shortVecRev, longVecRev)
run1Rect = rs.AddRectangle(run1Plane, stairWidth, runLength)
run2Plane = rs.PlaneFromFrame(
rs.CurveEditPoints(landing2)[3], shortVec, longVec)
run2Rect = rs.AddRectangle(run2Plane, stairWidth, runLength)
#(4)Num Flights between Landings
numLevels = len(landingLevels)
deltaLevels = []
runsPerLevel = []
mostRisersInRun = math.floor(runLength / minTread)
if mostRisersInRun > maxRisersInRun:
mostRisersInRun = maxRisersInRun
numRuns = 0
for i in range(0, numLevels - 1):
deltaLevels.append(landingLevels[i + 1] - landingLevels[i])
minNumRisers = math.ceil(deltaLevels[i] / maxRiser)
runsPerLevel.append(math.ceil(minNumRisers / mostRisersInRun))
numRuns = numRuns + int(runsPerLevel[i])
#(5) Which flights
listOfRuns = []
for i in range(0, numRuns):
if i % 2: #if even
listOfRuns.append(rs.CopyObject(run1Rect))
else:
listOfRuns.append(rs.CopyObject(run2Rect))
#(6) Num Treads per run
runsDeltaHeight = []
for i in range(0, numLevels - 1):
for j in range(0, int(runsPerLevel[i])):
runsDeltaHeight.append(deltaLevels[i] / runsPerLevel[i])
numRisersPerRun = []
for i in range(0, numRuns):
numRisersPerRun.append(math.ceil(runsDeltaHeight[i] / maxRiser))
#(7) Move Runs
elevation = 0
landings = []
for i in range(0, numRuns):
elevation = elevation + runsDeltaHeight[i]
translation = rs.VectorCreate([0, 0, elevation], [0, 0, 0])
rs.MoveObject(listOfRuns[i], translation)
if i % 2:
landings.append(rs.MoveObject(rs.CopyObject(landing2),
translation))
else:
landings.append(rs.MoveObject(rs.CopyObject(landing1),
translation))
#(8) Make Landings
stairGeo = []
for i in range(0, numRuns):
dir = rs.VectorCreate([0, 0, 0], [0, 0, runsDeltaHeight[i]])
#rs.MoveObject(landings[i], dir)
path = rs.AddLine([0, 0, 0], [0, 0, -thickness])
geo = rs.ExtrudeCurve(landings[i], path)
rs.CapPlanarHoles(geo)
stairGeo.append(geo)
rs.DeleteObject(path)
rs.DeleteObjects(landings)
#(9) Draw Stairs
runs = []
for i in range(0, numRuns):
runs.append(
Run(listOfRuns[i], runsDeltaHeight[i], numRisersPerRun[i],
thickness, i, maxTread))
stairGeo.append(runs[i].make())
runs[i].makeHandrail(hdrlHeight, minGapSize)
runs[i].printStats()
runs[i].cleanup()
finalGeo = rs.BooleanUnion(stairGeo, delete_input=True)
#(10) Scissor Stairs
if scissorStair:
pt0 = rs.CurveMidPoint(rectSegments[0])
pt1 = rs.CurveMidPoint(rectSegments[1])
pt2 = rs.CurveMidPoint(rectSegments[2])
pt3 = rs.CurveMidPoint(rectSegments[3])
mir1 = rs.MirrorObject(finalGeo, pt0, pt2, copy=True)
mirroredStair = rs.MirrorObject(mir1, pt1, pt3, copy=False)
#(11)Label
rs.SetUserText(finalGeo, "Brew", "Hot Coffee")
if scissorStair:
rs.SetUserText(mirroredStair, "Brew", "Hot Coffee")
#Cleanup
rs.DeleteObjects(listOfRuns)
rs.DeleteObjects(rectSegments)
rs.DeleteObject(landing1)
rs.DeleteObject(landing2)
rs.DeleteObject(run1Rect)
rs.DeleteObject(run2Rect)
print "done"
return None
def make(self):
runVector = rs.VectorCreate(rs.CurveEndPoint(self.runLongEdge),
rs.CurveStartPoint(self.runLongEdge))
unitRunVec = rs.VectorUnitize(runVector)
treadVec = rs.VectorScale(unitRunVec, self.treadLength)
riseVec = rs.VectorCreate([0, 0, self.riserHeight], [0, 0, 0])
newPt = [
rs.CurveStartPoint(self.firstRiserEdge).X,
rs.CurveStartPoint(self.firstRiserEdge).Y,
rs.CurveStartPoint(self.firstRiserEdge).Z - self.deltaHeight
]
ptList = []
ptList.append(rs.AddPoint(newPt))
for i in range(self.numRisers):
tempPt = rs.CopyObject(ptList[-1])
rs.MoveObject(tempPt, riseVec)
ptList.append(tempPt)
tempPt = rs.CopyObject(ptList[-1])
rs.MoveObject(tempPt, treadVec)
ptList.append(tempPt)
#stringer construct offset line
undersideLine = rs.AddLine(ptList[0], ptList[-1])
closestPtParam = rs.CurveClosestPoint(undersideLine, ptList[1])
closestPt = rs.EvaluateCurve(undersideLine, closestPtParam)
perpVec = rs.VectorUnitize(rs.VectorCreate(ptList[1], closestPt))
stringerBtm = rs.MoveObject(undersideLine,
rs.VectorScale(perpVec, -self.thickness))
cnstrLine = rs.ScaleObject(stringerBtm, rs.CurveMidPoint(stringerBtm),
[2, 2, 2])
#line going down
btmPt = rs.MoveObject(ptList[0], [0, 0, -self.thickness])
moveDir = rs.VectorCreate(ptList[2], ptList[1])
btmPtMoved = rs.MoveObject(rs.CopyObject(btmPt),
rs.VectorScale(moveDir, 3))
btmLineCnstr = rs.AddLine(btmPt, btmPtMoved)
ptIntersectBtm = rs.AddPoint(
rs.LineLineIntersection(btmLineCnstr, cnstrLine)[0]) #yes
#top lines
topVec = rs.VectorScale(
rs.VectorUnitize(rs.VectorCreate(ptList[-1], ptList[-2])),
self.extenionLength)
topPt1 = rs.MoveObject(ptList[-1], topVec)
topPtDown = rs.MoveObject(rs.CopyObject(topPt1),
[0, 0, -self.thickness])
extLengthTemp = self.extenionLength
if extLengthTemp < .1:
extLengthTemp = .1
topVec = rs.VectorScale(
rs.VectorUnitize(rs.VectorCreate(ptList[-1], ptList[-2])),
extLengthTemp)
topPtTemp = rs.MoveObject(rs.CopyObject(topPtDown), topVec)
topLine = rs.AddLine(topPtDown, topPtTemp)
ptIntersectTop = rs.AddPoint(
rs.LineLineIntersection(topLine, cnstrLine)[0]) #yes
ptList.append(topPtDown)
ptList.append(ptIntersectTop)
ptList.append(ptIntersectBtm)
stringer = rs.AddPolyline(ptList)
closeCrv = rs.AddLine(rs.CurveStartPoint(stringer),
rs.CurveEndPoint(stringer))
newStringer = rs.JoinCurves([stringer, closeCrv], True)
stair = rs.ExtrudeCurve(newStringer, self.firstRiserEdge)
rs.CapPlanarHoles(stair)
#make handrail guide curve
topOfNosing = rs.AddLine(ptList[1], ptList[-5])
self.guideCrv = topOfNosing
rs.DeleteObject(btmLineCnstr)
rs.DeleteObject(btmPtMoved)
rs.DeleteObject(btmLineCnstr)
rs.DeleteObject(ptIntersectTop)
rs.DeleteObject(undersideLine)
rs.DeleteObject(topPtTemp)
rs.DeleteObject(topLine)
rs.DeleteObject(stringer)
rs.DeleteObject(newStringer)
rs.DeleteObjects(ptList)
return stair
line2 = rs.AddLine(points[0], endPoint)
param = rs.SurfaceClosestPoint(face, points[1])
normal = rs.SurfaceNormal(face, param)
normalVect = distance * rs.VectorReverse(normal)
endPoint = points[1] + normalVect
line3 = rs.AddLine(points[1], endPoint)
curve1 = rs.AddFilletCurve(line, line2, radius)
curve2 = rs.AddFilletCurve(line, line3, radius)
curve = rs.JoinCurves([curve1, curve2], True)
profile = rs.ExtrudeCurve(curve, path)
splitSolids = rs.SplitBrep(solid, profile)
area1 = rs.SurfaceArea(splitSolids[0])
area2 = rs.SurfaceArea(splitSolids[1])
area3 = rs.SurfaceArea(splitSolids[2])
rs.DeleteObject(solid)
i = 0
swap = True
while swap == True:
swap = False
for i in range(0, 1):
#rs.DeleteObjects([A_lines, Poly_base, Poly_top])
#Create group
rs.AddGroup("Legs")
rs.AddObjectsToGroup(Legs, "Legs")
#Construct the table top, draw offset curve
offset_crv = rs.OffsetCurve(Poly_top,
Cen_top,
-(offset_dist),
normal=None,
style=1)
rs.CurrentLayer("Tabletop")
#extrude Offset Curve
extruded_crv = rs.ExtrudeCurve(offset_crv, extrude_path)
#cap Extruded shape
closed_polysrf = rs.CapPlanarHoles(extruded_crv)
#Delete objects
erase = [A_lines, Poly_base, Poly_top, offset_crv]
rs.DeleteObjects(erase)
#Redraw geometry
rs.EnableRedraw(True)
#zoom extents of drawn geometry
rs.ZoomExtents()
rs.CurrentLayer("Default")
import rhinoscriptsyntax as rs
p = rs.AddPoint(0, 0, 0)
q = rs.AddPoint(0, 0, 10)
t = rs.AddPoint(0, 5, 10)
#l=rs.AddLine(p,q)
l = rs.AddArc3Pt(p, q, t)
c = rs.AddCircle(p, 5)
m = rs.RotateObject(c, p, 45, None, False)
cy = rs.ExtrudeCurve(m, l)
for i in range(1, 25):
i = i * 5
p = rs.AddPoint(0, i, i)
q = rs.AddPoint(i, i, i * 10)
t = rs.AddPoint(i, i * 5, 0)
l = rs.AddArc3Pt(p, q, t)
c = rs.AddCircle(p, 5)
m = rs.RotateObject(c, p, 45, None, False)
cy = rs.ExtrudeCurve(c, l)
