def makeEngraves(m, obj): tool_id = m.group(1) operation = m.group(2) z_pos = m.group(3) #restore view cplane p1 = rs.WorldXYPlane() rs.ViewCPlane(None, p1) subtracts = [] if operation == 'Engrave': # return sweepVolume(obj, tool_id, z_pos) subcurves = rs.ExplodeCurves(obj, True) if subcurves: for crv in subcurves: vol = sweepVolume(crv, tool_id, z_pos) if vol: subtracts += vol result = rs.BooleanUnion(subtracts) return result
def create_pipe(self, point_n, point_p): outer_point_n = self.create_scaled_point(point_n, self.PIPE_SCALAR) outer_point_p = self.create_scaled_point(point_p, self.PIPE_SCALAR) inner_point_n = self.create_scaled_point(point_n, self.INNER_PIPE_SCALAR) inner_point_p = self.create_scaled_point(point_p, self.INNER_PIPE_SCALAR) opl = rs.AddPolyline([outer_point_p, self.middle_point, outer_point_n]) ipl = rs.AddPolyline([inner_point_p, self.middle_point, inner_point_n]) o_pipe = rs.AddPipe(opl, 0, self.CIRCLE_WIDTH, 1, 1) i_pipe = rs.AddPipe(ipl, 0, self.CIRCLE_INNER_WIDTH, 1, 1) return rs.BooleanUnion([o_pipe, i_pipe])
def main(): to_delete = [] rs.ProjectOsnaps(False) positive_object = rs.GetObject("select positive object", 16) negative_object = rs.GetObject("select negative object", 16) rs.HideObject(negative_object) polysurface, face = GetSubSurface("select tenon surface") to_delete.append(face) normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5))) plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal) rs.ViewCPlane(plane=plane) rs.ProjectOsnaps(True) tenon_rects = rs.GetObjects(message="select tenon curves", filter=4) tenon_faces = [] for rect in tenon_rects: tenon_faces.append(rs.AddPlanarSrf(rect)[0]) rs.ShowObject(negative_object) rs.ProjectOsnaps(False) height_pt = rs.GetPoint("enter height point") # compule a vector normal to plane of the desired height extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5) dist = rs.DistanceToPlane(plane, height_pt) extrude_vec_b = [dist * el for el in normal] extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b) extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b)) to_delete.append(extrude_curve) tenons = [] for tenon_face in tenon_faces: tenon = rs.ExtrudeSurface(tenon_face, extrude_curve) tenons.append(tenon) rs.BooleanUnion([positive_object] + tenons, delete_input=False) rs.BooleanDifference([negative_object], tenons, delete_input=False) to_delete.append(positive_object) to_delete.append(negative_object) rs.DeleteObjects(to_delete) rs.DeleteObjects(tenon_faces) rs.DeleteObjects(tenons)
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 __init__(self, current_point, next_point_up, next_point_down, prev_point_up, prev_point_down): self.middle_point = current_point extrusion_nu = self.create_pipe(next_point_up, prev_point_down) extrusion_nd = self.create_pipe(next_point_down, prev_point_up) self.brep = rs.BooleanUnion([extrusion_nu, extrusion_nd])
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
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 make_hinge(num_knuckles, knuckle_height, knuckle_radius, thickness, leaf_length, gap, add_vents): origin = [0, 0, 0] hinge_height = num_knuckles * knuckle_height ###################################################################### # Make pin with caps cap_radius = knuckle_radius - 0.5 * thickness - gap cap_height = thickness cap_bottom = rs.AddCylinder(origin, cap_height, cap_radius) cap_top = rs.AddCylinder([0, 0, hinge_height - cap_height], cap_height, cap_radius) pin_radius = knuckle_radius - (gap + thickness) pin = rs.AddCylinder(origin, hinge_height, pin_radius) pin = rs.BooleanUnion([pin, cap_bottom, cap_top]) ###################################################################### # Make knuckle and holes right_knuckle = rs.AddCylinder(origin, hinge_height, knuckle_radius) knuckle_pin_hole = rs.AddCylinder(origin, hinge_height, knuckle_radius - thickness) knuckle_bottom_hole = rs.AddCylinder(origin, cap_height + gap, cap_radius + gap) knuckle_top_hole = rs.AddCylinder([0, 0, hinge_height - cap_height - gap], cap_height + gap, cap_radius + gap) ###################################################################### # Make leaves right_p0 = (0, knuckle_radius, 0) right_p1 = (leaf_length, knuckle_radius - thickness, hinge_height) right_leaf = rs.AddBox(mz.box_verts_from_corners(right_p0, right_p1)) right_leaf = rs.BooleanUnion([right_knuckle, right_leaf]) right_leaf, = rs.BooleanDifference( [right_leaf], [knuckle_pin_hole, knuckle_bottom_hole, knuckle_top_hole]) mirror_leaf = rs.XformMirror(origin, (1, 0, 0)) left_leaf = rs.TransformObject(right_leaf, mirror_leaf, True) ###################################################################### # Cut out alternating knuckles z0 = 0 sz = knuckle_radius + gap left_boxes = [] right_boxes = [] vent_height = knuckle_height - 4 * thickness for stage in range(num_knuckles): z1 = z0 + knuckle_height if stage == 0: cur_z0 = z0 else: cur_z0 = z0 - 0.5 * gap if stage == num_knuckles - 1: cur_z1 = z1 else: cur_z1 = z1 + 0.5 * gap knuckle_box = rs.AddBox( mz.box_verts_from_corners((-sz, -sz, cur_z0), (sz, sz, cur_z1))) if stage % 2 == 0: left_boxes.append(knuckle_box) else: right_boxes.append(knuckle_box) if add_vents: zmid = z0 + 0.5 * knuckle_height za = zmid - 0.5 * vent_height zb = zmid + 0.5 * vent_height mid_box = rs.AddBox( mz.box_verts_from_corners((-sz, -pin_radius - gap, za), (sz, pin_radius + gap, zb))) if stage % 2 == 0: right_boxes.append(mid_box) else: left_boxes.append(mid_box) z0 += knuckle_height left_leaf, = rs.BooleanDifference([left_leaf], left_boxes) right_leaf, = rs.BooleanDifference([right_leaf], right_boxes) rs.SelectObjects([left_leaf, right_leaf, pin]) rs.Command('MergeAllFaces')
def main(): rectangle = rs.GetObject("Select rectangle to create mortise and tenon from", rs.filter.curve, True, True) errorCheck = curveErrorCheck(rectangle) if errorCheck == True: return lines = rs.ExplodeCurves(rectangle) errorCheck = lineErrorCheck(lines) if errorCheck == True: return face = rs.GetObject("Select tenon surface", rs.filter.surface, False, True, None, True) length = rs.GetReal("Enter tenon length", number=None) if length and length != 0: x = 0 else: print "Failed....No length was entered" return depth = rs.GetReal("Enter mortise depth", number=length+0.05) if depth and depth != 0: x = 0 else: print "Failed....No depth was entered" return fit = rs.GetReal("Enter mortise fit", number=0.01) line1 = rs.AddLine(rs.CurveStartPoint(lines[0]),rs.CurveEndPoint(lines[0])) line2 = rs.AddLine(rs.CurveStartPoint(lines[1]),rs.CurveEndPoint(lines[1])) line3 = rs.AddLine(rs.CurveStartPoint(lines[2]),rs.CurveEndPoint(lines[2])) line4 = rs.AddLine(rs.CurveStartPoint(lines[3]),rs.CurveEndPoint(lines[3])) rs.DeleteObjects(lines) lines = line1, line2, line3, line4 if rs.CurveLength(lines[0]) > rs.CurveLength(lines[1]): smallside = rs.CurveLength(lines[1]) longside1 = lines[0] longside2 = lines[2] else: smallside = rs.CurveLength(lines[0]) longside1 = lines[1] longside2 = lines[3] filletRadius = smallside/2 fillet1 = rs.CurveFilletPoints (lines[0], lines[1]) fillet2 = rs.CurveFilletPoints (lines[1], lines[2]) fillet3 = rs.CurveFilletPoints (lines[2], lines[3]) fillet4 = rs.CurveFilletPoints (lines[3], lines[0]) arc1 = rs.AddFilletCurve(lines[0],lines[1], radius = filletRadius) arc2 = rs.AddFilletCurve(lines[1],lines[2], radius = filletRadius) arc3 = rs.AddFilletCurve(lines[2],lines[3], radius = filletRadius) arc4 = rs.AddFilletCurve(lines[3],lines[0], radius = filletRadius) arcs = arc1, arc2, arc3, arc4 arcs = rs.JoinCurves(arcs) arcEnd1 = rs.CurveEndPoint(arcs[0]) arcStart1 = rs.CurveStartPoint(arcs[0]) arcEnd2 = rs.CurveEndPoint(arcs[1]) arcStart2 = rs.CurveStartPoint(arcs[1]) if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2): temp = arcEnd2 arcEnd2 = arcStart2 arcStart2 = temp line1 = rs.AddLine(arcEnd1, arcEnd2) line2 = rs.AddLine(arcStart1, arcStart2) curves = line1, arcs[0], arcs[1], line2 tenonOut = rs.JoinCurves(curves) tenonSurf = rs.AddPlanarSrf(tenonOut) point = rs.SurfacePoints(face) param = rs.SurfaceClosestPoint(face, point[0]) normal = rs.SurfaceNormal(face, param) normal = normal * length vect = rs.AddLine( arcEnd1, arcEnd1 + normal ) tenon = rs.ExtrudeSurface(tenonSurf, vect, cap=True) rs.DeleteObjects(curves) arcs = arc1, arc2, arc3, arc4 rs.DeleteObjects(arcs) rs.DeleteObject(rectangle) rs.ExtendCurveLength(longside1, 0, 0, fit) rs.ExtendCurveLength(longside1, 0, 1, fit) rs.ExtendCurveLength(longside2, 0, 0, fit) rs.ExtendCurveLength(longside2, 0, 1, fit) if rs.Distance(rs.CurveEndPoint(longside1), rs.CurveEndPoint(longside2)) < rs.Distance(rs.CurveStartPoint(longside1), rs.CurveEndPoint(longside2)): line1Start = rs.CurveEndPoint(longside1) line1End = rs.CurveEndPoint(longside2) line2Start = rs.CurveStartPoint(longside1) line2End = rs.CurveStartPoint(longside2) else: line1Start = rs.CurveStartPoint(longside1) line1End = rs.CurveEndPoint(longside2) line2Start = rs.CurveEndPoint(longside1) line2End = rs.CurveStartPoint(longside2) shortside1 = rs.AddLine(line1Start, line1End) shortside2 = rs.AddLine(line2Start, line2End) arc1 = rs.AddFilletCurve(longside1, shortside1, radius = filletRadius) arc2 = rs.AddFilletCurve(shortside1, longside2, radius = filletRadius) arc3 = rs.AddFilletCurve(longside2, shortside2, radius = filletRadius) arc4 = rs.AddFilletCurve(shortside2, longside1, radius = filletRadius) arcs = arc1, arc2, arc3, arc4 arcs = rs.JoinCurves(arcs) arcEnd1 = rs.CurveEndPoint(arcs[0]) arcStart1 = rs.CurveStartPoint(arcs[0]) arcEnd2 = rs.CurveEndPoint(arcs[1]) arcStart2 = rs.CurveStartPoint(arcs[1]) if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2): temp = arcEnd2 arcEnd2 = arcStart2 arcStart2 = temp line1 = rs.AddLine(arcEnd1, arcEnd2) line2 = rs.AddLine(arcStart1, arcStart2) curves = line1, arcs[0], arcs[1], line2 mortiseOut = rs.JoinCurves(curves) mortiseSurf = rs.AddPlanarSrf(mortiseOut) param = rs.SurfaceClosestPoint(face, point[0]) normal = rs.SurfaceNormal(face, param) normal = normal * depth vect = rs.AddLine( arcEnd1, arcEnd1 + normal ) mortise = rs.ExtrudeSurface(mortiseSurf, vect, cap=True) rs.DeleteObject(shortside1) rs.DeleteObject(shortside2) rs.DeleteObject(mortiseOut) rs.DeleteObject(mortiseSurf) rs.DeleteObjects(curves) rs.DeleteObjects(lines) arcs = arc1, arc2, arc3, arc4 rs.DeleteObjects(arcs) rs.DeleteObject(rectangle) rs.DeleteObject(tenonOut) rs.DeleteObject(tenonSurf) mortiseSide = rs.GetObject("Select part to mortise", rs.filter.polysurface, False, False) tenonSide = rs.GetObject("Select part to tenon", rs.filter.polysurface, False, False) tenonUnion = tenonSide, tenon rs.BooleanDifference(mortiseSide, mortise, delete_input = True) rs.BooleanUnion(tenonUnion, delete_input = True) return
# Part 0: Base if BUILD_TARGET == 'all' or 'base' in BUILD_TARGET: base_btm_origin = (BEAM_HALF_LENGTH, BEAM_HALF_LENGTH, 0) base_btm_pts = quad_rotate_point(base_btm_origin) base_top_pts = quad_rotate_point(rss.PointAdd( base_btm_origin, (-BEAM_HEIGHT * tan(pi/3), -BEAM_HEIGHT * tan(pi/3), BEAM_HEIGHT)) ) base = rss.BooleanUnion(( rss.JoinSurfaces( [rss.AddSrfPt(base_btm_pts), rss.AddSrfPt(base_top_pts)] + quad_rotate_object(rss.AddSrfPt(( base_btm_pts[0], base_btm_pts[1], base_top_pts[0], base_top_pts[1] ))), delete_input=True ), rss.AddCylinder((0, 0, 0), 107.5, CORE_RADIUS) )) # Part 1: Layer 1 # PLANE_HEIGHT: Height where the layer is placed PLANE_HEIGHT = 62.5 if BUILD_TARGET == 'all' or 'layer1' in BUILD_TARGET: beam_origin = (BEAM_HALF_LENGTH, CORE_RADIUS, PLANE_HEIGHT)
def handle_GENBLOCK_bt_view_srf(self, sender, e): self.suspendInteraction() rs.EnableRedraw(False) try: layername = get_layer_name('MASSING') tolerance = 0.0001 self.isolateLayer(layername) sel = rs.ObjectsByLayer(layername) print('sel from MASSING layer:', sel) self.deleteObjectsByGuid(sel) rs.CurrentLayer(layername) #blocks=rs.ObjectsByLayer(get_layer_name('BLOCK')) cons = [('phase', 'BLOCK')] obj_blocks = self.data.find_all(cons) print('flag_1') rhi_blocks = self.data.find_all_guids(cons) print('flag_2', rhi_blocks) cblocks = rs.CopyObjects(rhi_blocks) ublocks = rs.BooleanUnion(cblocks, True) splitedSrfs = [] horzSrfs = [] vertSrfs = [] #找出union block里的横竖面 print('Sparate horz and vert srfs') for b in ublocks: os = rs.ExplodePolysurfaces(b, True) print('os', os) #先把水平面分走 horzSrfs = [] vertSrfs = [] for s in os: print('line 740') if s is None: continue if not rs.IsObject(s): continue isHor, direct = isHorizonalSrf(s, True) if isHorizonalSrf(s): if direct < 0: rs.ObjectColor(s, (255, 0, 0)) else: rs.ObjectColor(s, COLOR_SET_01[5]) horzSrfs.append(s) else: vertSrfs.append(s) blockedSrf = [] parentDic = {} wheel = 0 print('assign parent objects') #Union block的横竖面找parent for po in obj_blocks: srfs = rs.ExplodePolysurfaces(po.guid, False) for vsrf in vertSrfs: pts2 = rs.SurfaceEditPoints(vsrf) for s in srfs: pts1 = rs.SurfaceEditPoints(s) if listsEqual(pts1, pts2): parentDic[vsrf] = po rs.DeleteObjects(srfs) print(parentDic) print('split irregular polygons') for s in vertSrfs: parent = parentDic[s] if parent is None: print('parent is None') rs.SelectObject(s) continue #rs.EnableRedraw(True) phaseIndex = 'MASSING' typeIndex = parent.typeIndices[0] boundary = rs.DuplicateSurfaceBorder(s) pts = rs.CurveEditPoints(boundary) if len(pts) > 5: #print('splitting polygon') #rs.EnableRedraw(False) srfs = splitIrregularPolygon(s) #print('splitIregPoly srfs=',srfs) if srfs is None: continue splitedSrfs += srfs for ss in srfs: #print(shortGuid(parent.guid)) o = self.addObject(ss, phaseIndex, typeIndex, parent) if o is None: continue self.setObjectType(o, typeIndex) #rs.EnableRedraw(True) else: splitedSrfs.append(s) o = None try: o = self.addObject(s, phaseIndex, typeIndex, parent) except Exception as e: print(e, s, phaseIndex, typeIndex, parent) if o is None: continue #print('o=',o) self.setObjectType(o, typeIndex) #self.logDataTree() rs.DeleteObject(boundary) except Exception as e: print('exception:', e) #PrintException() rs.EnableRedraw(True) self.resumeInteraction() rs.EnableRedraw(True)