def wave_line(values, r, in_d):
### interpolation dist
# inter_dist = 4 * 0.5
inter_dist = in_d
for i in xrange(len(values)):
tmp_pt = rs.AddPoint(values[i], i * r, 0)
tmp_pt_m = rs.MirrorObject(tmp_pt, (0, 0, 0), (0, 10, 0), True)
# zigzag
if i % 2 == 0:
tmp_pt_0 = rs.CopyObject(tmp_pt)
tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0))
tmp_pt_1 = rs.CopyObject(tmp_pt)
tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0))
zigzag.append(tmp_pt_0)
zigzag.append(tmp_pt_1)
else:
tmp_pt_0 = rs.CopyObject(tmp_pt_m)
tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0))
tmp_pt_1 = rs.CopyObject(tmp_pt_m)
tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0))
zigzag.append(tmp_pt_0)
zigzag.append(tmp_pt_1)
tmp_polyline = rs.AddPolyline(zigzag)
return zigzag, tmp_polyline
def createAirplane():
#CREATE FUSELAGE
rectangleFuselage = rs.AddRectangle(rs.WorldXYPlane(), Fw, Fh)
endPointsF = rs.PolylineVertices(rectangleFuselage)
fPtsB = offsetPoints(Fpb, endPointsF[0], endPointsF[1])
fPtsR = offsetPoints(Fpr, endPointsF[1], endPointsF[2])
fPtsT = offsetPoints(Fpt, endPointsF[2], endPointsF[3])
fPtsL = offsetPoints(Fpl, endPointsF[3], endPointsF[0])
fPtsL.append(fPtsB[0])
fCurveOpen = rs.AddCurve(fPtsB + fPtsR + fPtsT + fPtsL, 2)
#CREATE WING SLOT
wingSlotStart = rs.VectorAdd(endPointsF[0], (Fwx, Fwy, 0))
wingSlotEnd = rs.VectorAdd(wingSlotStart,
(Fw - Fwx + maxPointOffset * 2, 0, 0))
wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd)
wingSlotOffset = rs.OffsetCurve(wingSlot, (0, 1, 0), 1 / 32)
rs.AddLine(rs.CurveStartPoint(wingSlot),
rs.CurveStartPoint(wingSlotOffset))
#CREATE WING
wPlaneOffY = Wh + 1
wPlaneOffX = Fw / 2
wingPlane = rs.MovePlane(rs.WorldXYPlane(), (wPlaneOffX, -wPlaneOffY, 0))
rectangleWing = rs.AddRectangle(wingPlane, Ww, Wh)
endPointsW = rs.PolylineVertices(rectangleWing)
wPtsB = offsetPoints(Wpb, endPointsW[0], endPointsW[1])
wPtsR = offsetPoints(Wps, endPointsW[1], endPointsW[2])
wPtsT = offsetPoints(Wpt, endPointsW[2], endPointsW[3])
wPtsT.append(endPointsW[3])
wPtsB.insert(0, endPointsW[0])
wingCurve = rs.AddCurve(wPtsB + wPtsR + wPtsT)
#wingLine = rs.AddLine(endPointsW[3],endPointsW[0])
rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0], True)
#CREATE WING GROOVE
wingGrooveStart = rs.VectorAdd(endPointsW[3], (-1 / 64, maxPointOffset, 0))
wingGrooveEnd = rs.VectorAdd(wingGrooveStart,
(0, -(maxPointOffset + Wh * Wsd), 0))
wingGroove = rs.AddLine(wingGrooveStart, wingGrooveEnd)
wingGrooveOffset = rs.OffsetCurve(wingGroove, (1, 0, 0), -1 / 32)
rs.AddLine(rs.CurveEndPoint(wingGroove),
rs.CurveEndPoint(wingGrooveOffset))
#DELETE RECTANGLES
rs.DeleteObject(rectangleFuselage)
rs.DeleteObject(rectangleWing)
def add_tickmarks(rect, len, offset):
c, _ = rs.CurveAreaCentroid(rect)
mirror_v = [c, rs.PointAdd(c, [0, 10, 0])]
mirror_h = [c, rs.PointAdd(c, [10, 0, 0])]
pts = rs.CurvePoints(rect)
if not pts:
return "ERROR"
pts = rs.SortPoints(pts)
# print pts
t_0 = rs.CopyObject(pts[0], [offset, offset, 0])
t_1 = rs.CopyObject(t_0, [len, 0, 0])
t_2 = rs.CopyObject(t_0, [0, len, 0])
tick = rs.AddPolyline([t_1, t_0, t_2])
rs.DeleteObjects([t_0, t_1, t_2])
tick_2 = rs.MirrorObject(tick, mirror_v[0], mirror_v[1], True)
ticks_3 = rs.MirrorObjects([tick, tick_2], mirror_h[0], mirror_h[1], True)
rs.ObjectLayer([tick, tick_2] + ticks_3, LCUT_NAMES[3])
tick_list = [tick, tick_2] + ticks_3
return tick_list
import rhinoscriptsyntax as rs
import random
aCircle = rs.AddEllipse((random.uniform(5, 10), 0, 0), 1, 1)
def circleLine(start, end):
circles = []
for c in range(start, end, 1):
anotherCircle = rs.AddEllipse((c, c, 0), random.uniform(1, 2),
random.uniform(1, 2))
circles.append(anotherCircle)
rs.AddObjectsToGroup(circles, "lottacircles")
print(circles)
mz = circleLine(9, 14)
obj = aCircle
# start = (0,0,0)
# end = (4,4,0)
# if start and end:
rs.MirrorObject(obj, (0, 0, 0), (4, 4, 0), True)
def drawOpening(self, distance, length, side=0, block=0, direct=0):
"""
side=0 start from startPoint , side=1 start from endPoint
direct:
0 | 1
-------
2 | 3
block 0=empty 1=window 2=door
"""
localDirect = direct
if side == 1:
self.flip()
if direct == 0: localDirect = 3
if direct == 1: localDirect = 2
if direct == 2: localDirect = 1
if direct == 3: localDirect = 0
startParameter = self.line1.ClosestParameter(self.line0.From)
startPoint = self.line1.ClosestPoint(self.line0.From, False)
if startParameter >= 0:
distance00 = distance
distance10 = distance + startPoint.DistanceTo(self.line1.From)
else:
distance00 = distance + startPoint.DistanceTo(self.line1.From)
distance10 = distance
distance01 = distance00 + length
distance11 = distance10 + length
"""
p10 p11
------ ------>line1
| |
------ ------>line0
p00 p01
"""
point00 = self.line0.PointAtLength(distance00)
point10 = self.line1.PointAtLength(distance10)
point01 = self.line0.PointAtLength(distance01)
point11 = self.line1.PointAtLength(distance11)
parameter00 = self.line0.ClosestParameter(point00)
parameter10 = self.line1.ClosestParameter(point10)
parameter01 = self.line0.ClosestParameter(point01)
parameter11 = self.line1.ClosestParameter(point11)
if parameter00 < 0 or parameter00 > 1 or parameter10 < 0 or parameter10 > 1 or parameter01 < 0 or parameter01 > 1 or parameter11 < 0 or parameter11 > 1:
print("error: wrong opening length")
return 0
# drawing
sc.doc.Objects.AddLine(point00, point10)
sc.doc.Objects.AddLine(point01, point11)
sc.doc.Objects.AddLine(self.line0.From,
self.line0.PointAt(parameter00))
sc.doc.Objects.AddLine(self.line0.PointAt(parameter01), self.line0.To)
sc.doc.Objects.AddLine(self.line1.From,
self.line1.PointAt(parameter10))
sc.doc.Objects.AddLine(self.line1.PointAt(parameter11), self.line1.To)
# empty
if block == 0:
pass
# window
elif block == 1:
scaleX = point00.DistanceTo(point01) / 1000
scaleY = point00.DistanceTo(point10) / 100
origin = (point00 + point10 + point01 + point11) / 4
block_id = rs.InsertBlock("window", origin, (scaleX, scaleY, 1), 0,
(0, 0, 1))
angle_degrees = rs.Angle(point00, point01)[0]
rs.RotateObject(block_id, origin, angle_degrees)
# door
elif block == 2:
scaleX = point00.DistanceTo(point01) / 1000
scaleY = scaleX
origin = (point00 + point10 + point01 + point11) / 4
block_id = rs.InsertBlock("door", origin, (scaleX, scaleY, 1), 0,
(0, 0, 1))
angle_degrees = rs.Angle(point00, point01)[0]
rs.RotateObject(block_id, origin, angle_degrees)
if localDirect == 0:
pass
elif localDirect == 1:
rs.MirrorObject(block_id, (point10 + point11) / 2,
(point00 + point01) / 2)
elif localDirect == 2:
rs.MirrorObject(block_id, (point00 + point10) / 2,
(point01 + point11) / 2)
elif localDirect == 3:
rs.MirrorObject(block_id, (point10 + point11) / 2,
(point00 + point01) / 2)
rs.MirrorObject(block_id, (point00 + point10) / 2,
(point01 + point11) / 2)
import rhinoscriptsyntax as rs
import random
import math
obj = rs.GetObject("Select object to mirror")
if obj:
start = rs.GetPoint("Start of mirror plane")
end = rs.GetPoint("End of mirror plane")
if start and end:
rs.MirrorObject(obj, start, end, True)
import rhinoscriptsyntax as rs
import random
def blipCurve(y):
x1 = random.uniform(0, 10)
z1 = random.uniform(0, 10)
x2 = random.uniform(10, 20)
z2 = random.uniform(10, 100)
x3 = random.uniform(20, 30)
z3 = random.uniform(10, 20)
listOfPoints = [(0, y, 0), (x1, y, z1), (x2, y, z2), (x3, y, z3),
(0, y, 0)]
return rs.AddCurve(listOfPoints, 3)
whereIsBlip = random.randint(0, 9)
for c in range(10):
aCurve = blipCurve(c)
rs.MirrorObject(aCurve, (0, 0, 0), (0, 40, 0), True)
# if c == whereIsBlip:
# rs.MoveObject(aCurve, (0,0,random.uniform(-100,-50)))
# rs.MirrorObject(aCurve, (0,0,0),(0,0,10))
def LEAF(startX, startY, width, left):
if (left == True):
rotationAngle = random.uniform(40, 140)
elif (left == False):
rotationAngle = random.uniform(200, 300)
halfLeaf = rs.AddArc3Pt((startX, startY, 0), (startX, startY + 12, 0),
(startX + width, startY + 4, 0))
secondHalf = rs.MirrorObject(halfLeaf, (startX, startY, 0),
(startX, startY + 12, 0),
copy=True)
rs.RotateObject(halfLeaf, (startX, startY, 0),
rotationAngle,
axis=None,
copy=False)
rs.RotateObject(secondHalf, (startX, startY, 0),
rotationAngle,
axis=None,
copy=False)
veinPoints = [(startX, startY, 0)]
widthFixer = 2.2
for points in range(1, 12, 2):
veinPoint = (startX + random.uniform(-1, 1), startY + points, 0)
veinPoints.append(veinPoint)
# rs.AddPoint(veinPoint)
if (points < 7):
points = (startX - width + widthFixer,
startY + points + random.uniform(-.5, .5),
0), veinPoint, (startX + width - widthFixer, startY +
points + random.uniform(-.5, .5), 0)
vein = rs.AddCurve(points)
rs.RotateObject(vein, (startX, startY, 0),
rotationAngle,
axis=None,
copy=False)
widthFixer = widthFixer - 1
# print(widthFixer)
elif (points == 7):
widthFixer = .2
points = (startX - width + widthFixer,
startY + points + random.uniform(-.5, .5),
0), veinPoint, (startX + width - widthFixer, startY +
points + random.uniform(-.5, .5), 0)
vein = rs.AddCurve(points)
rs.RotateObject(vein, (startX, startY, 0),
rotationAngle,
axis=None,
copy=False)
elif (points > 7):
widthFixer = widthFixer + 1
points = (startX - width + widthFixer,
startY + points + random.uniform(-.5, .5),
0), veinPoint, (startX + width - widthFixer, startY +
points + random.uniform(-.5, .5), 0)
vein = rs.AddCurve(points)
rs.RotateObject(vein, (startX, startY, 0),
rotationAngle,
axis=None,
copy=False)
# print(widthFixer)
middleVein = rs.AddInterpCurve(veinPoints)
rs.RotateObject(middleVein, (startX, startY, 0),
rotationAngle,
axis=None,
copy=False)
def outbox(self, gap):
#DEFINE BASE SLICE------------>
rec_lr = rs.AddRectangle(rs.WorldYZPlane(), self.data[0], self.data[1])
srf_lr = rs.AddPlanarSrf(rec_lr)
rec_lr = rs.MoveObject(
rec_lr, rs.VectorCreate(ZERO,
rs.SurfaceAreaCentroid(srf_lr)[0]))
rs.DeleteObject(srf_lr)
rec_lr = cutrec(2, rec_lr, gap)
srf_lr = rs.AddPlanarSrf(rec_lr)
rs.DeleteObjects(rec_lr)
### CANNOT USE WORLDZX()---------->
xz = rs.PlaneFromFrame([0, 0, 0], [1, 0, 0], [0, 0, 1])
rec_fk = rs.AddRectangle(xz, self.data[2], self.data[3])
###<-------------
srf_fk = rs.AddPlanarSrf(rec_fk)
rec_fk = rs.MoveObject(
rec_fk, rs.VectorCreate(ZERO,
rs.SurfaceAreaCentroid(srf_fk)[0]))
rs.DeleteObject(srf_fk)
rec_fk = cutrec(2, rec_fk, gap)
srf_fk = rs.AddPlanarSrf(rec_fk)
rs.DeleteObjects(rec_fk)
rec_tb = rs.AddRectangle(rs.WorldXYPlane(), self.data[5], self.data[4])
srf_tb = rs.AddPlanarSrf(rec_tb)
rec_tb = rs.MoveObject(
rec_tb, rs.VectorCreate(ZERO,
rs.SurfaceAreaCentroid(srf_tb)[0]))
rs.DeleteObject(srf_tb)
rec_tb = cutrec(1, rec_tb, 0)
srf_tb = rs.AddPlanarSrf(rec_tb)
rs.DeleteObject(rec_tb)
#CONSTRUCT THE BOX-------------------->
srfs = []
srfs.append(rs.CopyObject(srf_tb, [0, 0, self.data[3] / 2.0]))
srfs.append(rs.CopyObject(srf_tb, [0, 0, self.data[3] / (-2.0)]))
srfs.append(rs.CopyObject(srf_fk, [0, self.data[0] / 2.0, 0]))
srfs.append(
rs.MirrorObject(
rs.CopyObject(srf_fk, [0, self.data[0] / (-2.0), 0]),
[0, 1, 0], [0, 0, 1]))
srfs.append(rs.CopyObject(srf_lr, [self.data[5] / (-2.0), 0, 0]))
srfs.append(
rs.MirrorObject(
rs.CopyObject(srf_lr, [self.data[5] / (2.0), 0, 0]), [1, 0, 0],
[0, 0, 1]))
bele = []
for srf in srfs:
extvec = rs.VectorCreate(ZERO, rs.SurfaceAreaCentroid(srf)[0])
max, sign, loc = 0, -1, 0
for i in range(len(extvec)):
if abs(extvec[i]) > max:
max = abs(extvec[i])
sign = extvec[i]
loc = i
if loc == 0:
line = rs.AddLine(
ZERO, rs.VectorScale(rs.VectorUnitize([sign, 0, 0]), cut2))
bele.append(rs.ExtrudeSurface(srf, line))
elif loc == 1:
line = rs.AddLine(
ZERO, rs.VectorScale(rs.VectorUnitize([0, sign, 0]), cut2))
bele.append(rs.ExtrudeSurface(srf, line))
elif loc == 2:
line = rs.AddLine(
ZERO, rs.VectorScale(rs.VectorUnitize([0, 0, sign]), cut2))
bele.append(rs.ExtrudeSurface(srf, line))
rs.DeleteObject(line)
rs.DeleteObjects(srfs)
rs.DeleteObjects([srf_lr, srf_fk, srf_tb])
return bele
newRect = rs.AddRectangle(plane, wSquare, wSquare)
rs.ObjectLayer(newRect, "Rects")
gridRects.append(newRect)
allRects.append(newRect)
# Rotate all rects from the grid
for rect in gridRects:
for ntimes in range(1,4):
newRect = rs.RotateObject( rect , start , 15.0*ntimes, None, True )
rs.ObjectLayer(newRect, "Rects")
allRects.append(newRect)
# Mirror all rects using Y axe
mirrorYRects = []
for rect in allRects:
newRect = rs.MirrorObject( rect, start, end, True )
mirrorYRects.append(newRect)
allRects.append(mirrorYRects);
# Mirror all rects using X axe
if(mirrorX):
mirrorXRects = []
for rect in allRects:
newRect = rs.MirrorObject( rect, (-100,0,0), (100,0,0), True )
mirrorXRects.append(newRect)
allRects.append(mirrorXRects);
lines = []
rs.AddLayer("Split Lines")
def createAirplane(self):
#CREATE FUSELAGE
rectangleFuselage = rs.AddRectangle(self.location,
self.genes.values['Fw'],
self.genes.values['Fh'])
endPointsF = rs.PolylineVertices(rectangleFuselage)
fPtsB = offsetPoints(self.genes.values['Fpb'], endPointsF[0],
endPointsF[1])
fPtsR = offsetPoints(self.genes.values['Fpr'], endPointsF[1],
endPointsF[2])
fPtsT = offsetPoints(self.genes.values['Fpt'], endPointsF[2],
endPointsF[3])
fPtsL = offsetPoints(self.genes.values['Fpl'], endPointsF[3],
endPointsF[0])
fPtsL.append(fPtsB[0])
fCurveOpen = rs.AddCurve(fPtsB + fPtsR + fPtsT + fPtsL, 2)
#CREATE WING SLOT
wingSlotStart = rs.VectorAdd(
endPointsF[0],
(self.genes.values['Fwx'], self.genes.values['Fwy'], 0))
wingSlotEnd = rs.VectorAdd(
wingSlotStart,
(self.genes.values['Fw'] - self.genes.values['Fwx'] +
maxPointOffset * 2, 0, 0))
wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd)
#guideLine = rs.AddLine(wingSlotStart,rs.VectorAdd(wingSlotStart,(0,0.2,0)))
#rs.ObjectColor(guideLine,(0,0,200))
#wingSlotOffset = rs.OffsetCurve(wingSlot,(0,1,0),1/32)
#rs.AddLine(rs.CurveStartPoint(wingSlot),rs.CurveStartPoint(wingSlotOffset))
#CREATE WING
wPlaneOffY = self.genes.values['Wh'] + 1
wPlaneOffX = self.genes.values['Fw'] / 2
wingPlane = rs.MovePlane(self.location,
(wPlaneOffX + self.location[0].X,
-wPlaneOffY + self.location[0].Y, 0))
rectangleWing = rs.AddRectangle(wingPlane, self.genes.values['Ww'],
self.genes.values['Wh'])
endPointsW = rs.PolylineVertices(rectangleWing)
wPtsB = offsetPoints(self.genes.values['Wpb'], endPointsW[0],
endPointsW[1])
wPtsR = offsetPoints(self.genes.values['Wps'], endPointsW[1],
endPointsW[2])
wPtsT = offsetPoints(self.genes.values['Wpt'], endPointsW[2],
endPointsW[3])
wPtsT.append(endPointsW[3])
wPtsB.insert(0, endPointsW[0])
wingCurve = rs.AddCurve(wPtsB + wPtsR + wPtsT)
#wingLine = rs.AddLine(endPointsW[3],endPointsW[0])
wingCurveM = rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0],
True)
#CREATE WING GROOVE
wingGrooveStart = rs.VectorAdd(endPointsW[3], (0, maxPointOffset, 0))
wingGrooveEnd = rs.VectorAdd(
wingGrooveStart,
(0, -(maxPointOffset +
self.genes.values['Wh'] * self.genes.values['Wsd']), 0))
wingGroove = rs.AddLine(wingGrooveStart, wingGrooveEnd)
#wingGrooveOffset = rs.OffsetCurve(wingGroove,(1,0,0),-1/32)
#rs.AddLine(rs.CurveEndPoint(wingGroove),rs.CurveEndPoint(wingGrooveOffset))
#DELETE RECTANGLES
rs.DeleteObject(rectangleFuselage)
rs.DeleteObject(rectangleWing)
textPlane = rs.MovePlane(
self.location,
(self.location[0].X + .25, self.location[0].Y + .25, 0))
text = rs.AddText(self.number, textPlane, 0.25)
textCurves = rs.ExplodeText(text, True)
rs.ObjectColor(textCurves, (0, 0, 200))
planeGroup = rs.AddGroup()
rs.AddObjectsToGroup(
[fCurveOpen, wingCurveM, wingSlot, wingCurve, wingGroove, text],
planeGroup)
def testCase(self):
self.clear()
#------------add 1st room------------
self.addRoom()
#add the wall
corners = [
[0,0,0]
,[10,0,0]
,[10,5,0]
,[15,5,0]
,[15,20,0]
,[11,20,0]
,[11,18,0]
,[4,18,0]
,[4,20,0]
,[0,20,0]
,[0,0,0]
]
thickness = 0.8
height = 10
id1 = self.addWall3(corners, thickness, height)
#self.rooms[0].addID("wall", wallid)
#add door
doorBtmPts = [
[1,0,0]
,[3.5,0,0]
,[3.5,thickness,0]
,[1,thickness,0]
]
doorHeight = 7
id1 = self.addDoor(id1, doorBtmPts, doorHeight)
#add door
hallThickness = 0.5
hallBtmPts1 = [
[15,10,0]
,[25,10,0]
,[25,14,0]
,[15,14,0]
,[15,10,0]
]
hallBtmPts2 = [
[15,10+hallThickness,0]
,[25,10+hallThickness,0]
,[25,14-hallThickness,0]
,[15,14-hallThickness,0]
,[15,10+hallThickness,0]
]
hallHeight = 7
doorBtmPts2 = [
[15-thickness,10+hallThickness,0]
,[15,10+hallThickness,0]
,[15,14-hallThickness,0]
,[15-thickness,14-hallThickness,0]
]
doorHeight2 = hallHeight - hallThickness
id1 = self.addDoor(id1, doorBtmPts2, doorHeight2)
#add window
winBtmPts = [
[0,3,4]
,[thickness,3,4]
,[thickness,7,4]
,[0,7,4]
]
doorHeight = 4
id1 = self.addWindow(id1, winBtmPts, doorHeight)
#add 2nd room
#id2 = rs.CopyObjects(id1, [30,0,0])
id2 = rs.MirrorObject(id1, [20,0,0], [20,20,0], True)
#add hallway
self.addHallWall([id1,id2], hallBtmPts1, hallBtmPts2, hallThickness, hallHeight)
def quad_mirror_object(object_id):
_mirror = rss.MirrorObject(object_id, (0, -1, 0), (0, 1, 0), copy=True)
return [object_id, _mirror] + rss.MirrorObjects((object_id, _mirror), (-1, 0, 0), (1, 0, 0), copy=True)
if ADD_JUNCTION:
# Original `base` is deleted during the boolean union, re-binding name `base` for later reference.
base = rss.BooleanUnion(
base + quad_mirror_object(
rss.AddCylinder((CORE_RADIUS, 1, PLANE_HEIGHT), 3, 0.8)
)
)
slot = add_box(
(CORE_RADIUS, 4, PLANE_HEIGHT),
(-1, 0, 0),
(0, -8, 0),
(0, 0, 5)
)
layer2 = rss.BooleanUnion(
layer2
+ [slot, rss.MirrorObject(slot, (0, -1, 0), (0, 1, 0), copy=True)]
)
diff = rss.BooleanDifference(layer2, base, delete_input=False)
rss.DeleteObject(layer2)
layer2 = diff
if REMOVE_DRAFT:
rss.DeleteObject(beam_path)
# Part 3: Layer 3
PLANE_HEIGHT = 87.5
BEAM_HALF_LENGTH = 35.75
if BUILD_TARGET == 'all' or 'layer3' in BUILD_TARGET:
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 CreateCoreShell(self):
x1 = self.coreInnerRadius
x0 = x1 - self.coreSpacerLedgeWidth
x2 = x1 + self.corePressDepth
x3 = x1 + self.coreCoverSlopeDepth
x4 = x1 + self.coreShellWidth
y0 = 0
y1 = y0 + self.coreCoverSlopeHeight
y2 = y1 + self.coreCoverSpace
y3 = y2 + self.corePressHeight
y5 = y0 + self.coreShellHeight
y4 = y5 - self.coreSpacerLedgeHeight
path = Path()
path.MoveTo(x3, y0)
path.LineTo(x4, y0)
path.LineTo(x4 - self.GetDraftDistance(y0, y5), y5)
path.CutInFillet(0.2)
path.LineTo(x0, y5)
path.CutInFillet(0.2)
path.LineTo(x0, y4)
path.LineTo(x1, y4)
path.LineTo(x1, y3)
path.LineTo(x2, y3)
path.LineTo(x2, y2)
path.LineTo(x1, y2)
path.LineTo(x1, y1)
path.ClosePath()
polysurface = path.Revolve()
# cut the press fit slots required for making molds
curve = rs.AddLine((x2, 0, y0), (x2, 0, y2))
cut1 = rs.AddRevSrf(curve, ((0, 0, 0), (0, 0, 1)), -15, 15)
rs.DeleteObject(curve)
box = rs.BoundingBox(cut1)
xa = box[0][0]
ya = box[0][1]
xb = box[3][0]
yb = box[3][1]
cut2 = rs.MirrorObject(cut1, (0, -1, 0), (0, 1, 0), True)
side1 = self.CreateRect([(xa, ya, y0), (xa, ya, y2), (-xa, ya, y2),
(-xa, ya, y0)])
side1s = self.SplitAndKeep(side1, polysurface, [0, 2], 0)
side2 = self.CreateRect([(xb, yb, y0), (xb, yb, y2), (-xb, yb, y2),
(-xb, yb, y0)])
side2s = self.SplitAndKeep(side2, polysurface, [0, 2], 0)
cut1 = rs.JoinSurfaces([cut1, side1s[1], side2s[1]], True)
cut2 = rs.JoinSurfaces([cut2, side1s[0], side2s[0]], True)
polysurface = self.SplitAndKeep(polysurface, cut1, 0, 0)
polysurface = self.SplitAndKeep(polysurface, cut2, 1, 0)
polysurface = rs.JoinSurfaces([polysurface, cut1, cut2], True)
# cut the USB opening
zb = self.coreShellHeight - self.coreSpacerLedgeHeight - self.pcbTopClearance - self.pcbThickness
usb = self.ImportObject("usb-opening")
rs.MoveObject(usb, (0, 0, zb - 1.3))
usb = self.SplitAndKeep(usb, polysurface, 1)
polysurface = self.Cut(polysurface, [usb])
# add "keyed" areas to shell for aligning spacer
for a in self.alignmentAngles:
key = self.CreateKey(y4 - self.coreSpacerInnerHeight, y4)
rs.RotateObject(key, (0, 0, 0), a)
polysurface = self.SplitAndKeepLargest(polysurface, key)
polysurface = rs.JoinSurfaces([key, polysurface], True)
self.coreShell = polysurface
self.CreateLayer("shell", 0xff0000, self.coreShell)
def generate_gear_crv(teeth,
module,
pressure_angle=20,
cone_angle=0,
clearance=0.167,
involute_samples=5):
pressure_angle = radians(pressure_angle)
pitch_diam = module * teeth
base_circle = pitch_diam * cos(pressure_angle)
addendum = module
dedendum = (1 + clearance) * module
outside_diam = pitch_diam + 2 * addendum
root_diam = pitch_diam - 2 * dedendum
chordal_thickness = pitch_diam * sin((pi / 2) / teeth)
# Partial function to transform point from xy plane to surface
# perpendicular to pitch cone surface. Used for bevel gears.
tilt = partial(tilt_pt_around_circle,
angle=cone_angle / 2,
circle_diam=pitch_diam)
invol_start_angle = (pi / 2 + asin(chordal_thickness / pitch_diam) -
pressure_angle +
sqrt((pitch_diam / base_circle)**2 - 1))
invol_end_angle = (invol_start_angle -
sqrt((outside_diam / base_circle)**2 - 1))
if root_diam > base_circle:
invol_angle_mod = sqrt((root_diam / base_circle)**2 - 1)
else:
invol_angle_mod = 0
invol_pts = generate_involute_pts(base_circle_diam=base_circle,
start_angle=invol_start_angle,
end_angle=invol_end_angle,
angle_mod=invol_angle_mod,
samples=involute_samples)
invol_pts = map(tilt, invol_pts)
tooth_crvs = []
invol_crv1 = rs.AddInterpCurve(invol_pts, degree=3, knotstyle=1)
invol_crv2 = rs.MirrorObject(invol_crv1, [0, 0, 0], [0, 1, 0], copy=True)
top_arc = rs.AddArc3Pt(start=rs.CurveEndPoint(invol_crv1),
end=rs.CurveEndPoint(invol_crv2),
point_on_arc=tilt([0, outside_diam / 2, 0]))
tooth_crvs.append(invol_crv1)
tooth_crvs.append(invol_crv2)
tooth_crvs.append(top_arc)
# Dedendum
if root_diam < base_circle:
pt = [
root_diam / 2 * cos(invol_start_angle),
root_diam / 2 * sin(invol_start_angle), 0
]
ded_crv1 = rs.AddLine(rs.CurveStartPoint(invol_crv1), tilt(pt))
ded_crv2 = rs.MirrorObject(ded_crv1, [0, 0, 0], [0, 1, 0], copy=True)
tooth_crvs.append(ded_crv1)
tooth_crvs.append(ded_crv2)
tooth = rs.JoinCurves(tooth_crvs, delete_input=True)[0]
# Tooth bottom
angle = 2 * pi / teeth
start_pt = rs.CurveStartPoint(tooth)
end_pt = rs.CurveEndPoint(tooth)
end_pt = [
end_pt[0] * cos(angle) - end_pt[1] * sin(angle),
end_pt[1] * cos(angle) + end_pt[0] * sin(angle), end_pt[2]
]
pt_on_arc = [
-sin(angle / 2) * (root_diam / 2),
cos(angle / 2) * (root_diam / 2), 0
]
bottom_arc = rs.AddArc3Pt(start_pt, end_pt, tilt(pt_on_arc))
tooth = rs.JoinCurves([tooth, bottom_arc], delete_input=True)[0]
# Copy and rotate tooth N times
crvs = [tooth]
for i in xrange(1, teeth):
crv = rs.RotateObject(tooth, [0, 0, 0], degrees(i * angle), copy=True)
crvs.append(crv)
crvs = rs.JoinCurves(crvs, delete_input=True)
return crvs
xymeshes.append(xymesh0) #将第一个展平面加入列表
#print(xymeshes)
else:
vertices2 = rs.MeshVertices(meshes[i]) #获取索引值为i时，单元面所有顶点
vertices1 = rs.MeshVertices(meshes[i-1]) #i-1时，单元面的所有顶点
ver = [m for m in vertices1 for n in vertices2 if m==n] #遍历两mesh中的点，提取重合点ab
#print(vertices2)
a = ver[0]
b = ver[1]
indexa = vertices1.index(a) #提取ab点在i-1单元中的索引值
indexb = vertices1.index(b)
d = [m for m in vertices2 if m not in ver][0]
#使用列表推导式循环遍历索引值为i时单元面的顶点，并且要求提取的条件为不重合的点，如果为四边，因此增加[0]
refvertice = rs.MeshVertices(xymeshes[i-1]) #获取已经转化为二维单元面i-1的单元顶点
indexc = [c for c in range(0,3) if c != indexa and c!=indexb] #获取i-1单元顶点中ab以外c的索引值
refverticespoint = rs.MirrorObject(rs.AddPoint(refvertice[indexc[0]]),refvertice[indexa],refvertice[indexb])#c'参考a'b',获取cm'点
mirrorpoint = rs.PointCoordinates(refverticespoint) #获取cm'点坐标
xymesh = rs.OrientObject(meshes[i],[a,b,d],[refvertice[indexa],refvertice[indexb],mirrorpoint],1)
#将i单元面转化为二维面，初始参考点为待转化abd，目标为a',b',cm'
xymeshes.append(xymesh)
vertices2=[]
vertices1=[]
ver = []
print(xymeshes)
