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)