def clean_curve(b): """Clean curve geometry 1. Checks if guid or object 2. Simplifiebs 3. Reverse curve dirn 4. Closes curve if not already closed """ if type(b) == type(rs.AddPoint(0, 0, 0)): # already guid pass else: b = sc.doc.Objects.AddCurve(b) rs.SimplifyCurve(b) # reverse curve direction boundarybrep = rs.coercecurve(b) Rhino.Geometry.Curve.Reverse(boundarybrep) sc.doc.Objects.Replace(b, boundarybrep) if rs.IsCurveClosed(b): return b else: return rs.CloseCurve(b)
def Rectify_AngleFirst_Button(): objs = rs.GetObjects("Select polylines to rectify", rs.filter.curve, preselect = True) if objs is None: return if 'geometry-angleMultiple' in sc.sticky: angleDefault = sc.sticky['geometry-angleMultiple'] else: angleDefault = 45 if 'geometry-lengthMultiple' in sc.sticky: lengthDefault = sc.sticky['geometry-lengthMultiple'] else: lengthDefault = 1 angleMultiple = rs.GetReal("Round angle to multiples of", angleDefault) if angleMultiple is None: return sc.sticky['geometry-angleMultiple'] = angleMultiple lengthMultiple = rs.GetReal("Round length to multiples of", lengthDefault) if lengthMultiple is None: return sc.sticky['geometry-lengthMultiple'] = lengthMultiple for obj in objs: try: rs.SimplifyCurve(obj) newLine = Rectify_AngleFirst(obj, angleMultiple, lengthMultiple) rs.MatchObjectAttributes(newLine, obj) utils.SaveToAnalytics('Geometry-Rectify') result = True except: result = False print "Rectify failed" utils.SaveFunctionData('Geometry-Rectify', [angleMultiple, lengthMultiple, str([(pt.X, pt.Y, pt.Z) for pt in rs.CurveEditPoints(obj)]), result]) if result: rs.DeleteObject(obj)
def makeWall(crvs, width): rs.EnableRedraw(False) breps = [] shapes = [] for crv in crvs: rs.SimplifyCurve(crv) shape = offsetBothCrvs(crv, width) if rs.IsPolysurface(shape): surfs = rs.ExplodePolysurfaces(shape) for surf in surfs: shapes.append(surf) if shape: rs.DeleteObjects(shape) else: shapes.append(shape) for shape in shapes: railCurve = addRail(shape) breps.append(rs.ExtrudeSurface(shape, railCurve)) if railCurve: rs.DeleteObjects(railCurve) if shapes: rs.DeleteObjects(shapes) rs.EnableRedraw(False) return breps
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 simplify(objs): for obj in objs: if rs.IsCurve(obj): rs.SimplifyCurve(obj)
def offsetInside(crv, dist): rs.SimplifyCurve(crv) centroid = rs.CurveAreaCentroid(crv) return rs.OffsetCurve(crv, centroid[0], dist)
def rebuildSrfCrv(obj): crv = rs.DuplicateSurfaceBorder(obj, type=0) map(lambda x: rs.SimplifyCurve(x), crv) return crv
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 stairHeight(route, width=48, height=120): """ Makes a stair to specified height. input: route(pline), width (num), height(num) returns: Geo """ try: rs.EnableRedraw(False) rs.SimplifyCurve(route) if route is None: print("ERROR: No path selected") return if (rs.UnitSystem() == 2): #if mm maxRiserHeight = 180 thickness = 200 if (rs.UnitSystem() == 4): #if m maxRiserHeight = .180 thickness = .200 if (rs.UnitSystem() == 8): #if in" maxRiserHeight = 7 thickness = 9 negativeBoo = False if (height < 0): #if the stair negativeBoo = True landingEdges = [] landings = [] segments = rs.ExplodeCurves(route) if len(segments) < 1: segments = [rs.CopyObject(route)] landingHeight = [] geometry = [] #Check that all segments are lines for i in range(0, len(segments)): if not (rs.IsLine(segments[i])): print( "ERROR: This function only accepts lines. No arcs or nurb curves." ) rs.DeleteObjects(segments) return #first landing edge norm = rs.VectorRotate(rs.CurveTangent(segments[0], 0), 90, [0, 0, 1]) norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2) side1Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), norm) side2Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), -norm) landingEdges.append(rs.AddLine(side1Pt, side2Pt)) #middle landing edges for i in range(0, len(segments) - 1): edgeList, landing = rampIntersection(segments[i], segments[i + 1], width) landingEdges.append(edgeList[0]) landingEdges.append(edgeList[1]) landings.append(landing) #last landing edge norm = rs.VectorRotate( rs.CurveTangent(segments[-1], rs.CurveParameter(segments[-1], 1)), 90, [0, 0, 1]) norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2) side1Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), norm) side2Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), -norm) landingEdges.append(rs.AddLine(side1Pt, side2Pt)) #Add risers riserCrvs = [] treadVecs = [] numRisersPerRun = [] numRisers = abs(int(math.ceil(height / maxRiserHeight))) risersSoFar = 0 totalRun = getTotalRun(landingEdges) optTreadDepth = totalRun / (numRisers - 1) #2R+T = 635 riserHeight = height / numRisers if (negativeBoo): curRiserHeight = 0 else: curRiserHeight = riserHeight for i in range(0, len(landingEdges), 2): #find numRisers in each run a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) runDist = rs.Distance(a, b) numRisersThisRun = int(round((runDist / optTreadDepth), 0)) if (numRisersThisRun == 0): numRisersThisRun = 1 if (i == len(landingEdges) - 2): #if last run, add the rest of the risers numRisersThisRun = numRisers - risersSoFar else: risersSoFar = risersSoFar + numRisersThisRun numRisersPerRun.append(numRisersThisRun) #Create Risers on Plan for i in range(0, len(landingEdges), 2): run = [] a = rs.CurveMidPoint(landingEdges[i]) b = rs.CurveMidPoint(landingEdges[i + 1]) centerStringer = rs.AddLine(a, b) runDist = rs.Distance(a, b) numRisersThisRun = numRisersPerRun[int(i / 2)] #risers in this run tarPts = rs.DivideCurve(centerStringer, numRisersThisRun, create_points=False) rs.DeleteObject(centerStringer) for j in range(0, numRisersThisRun + 1): if (j == 0): treadVecs.append(rs.VectorCreate(tarPts[0], tarPts[1])) transVec = rs.VectorCreate(tarPts[0], tarPts[j]) run.append(rs.CopyObject(landingEdges[i], -transVec)) riserCrvs.append(run) print('Flight {0} has {1} risers: {3}" tall, Treads: {2}" deep'. format( int(i / 2) + 1, numRisersThisRun, rs.VectorLength(treadVecs[int(i / 2)]), riserHeight)) #Move riser edges vertically for i in range(0, len(riserCrvs)): triangles = [] if (negativeBoo): for j in range(0, len(riserCrvs[i]) - 1): #if stairs descending rs.MoveObject( riserCrvs[i][j], rs.VectorAdd([0, 0, curRiserHeight], -treadVecs[i])) riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], [0, 0, riserHeight]) treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], treadVecs[i]) stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j])) pt1 = rs.CopyObject( stPt, [0, 0, riserHeight]) #first riser in run pt2 = rs.CopyObject(stPt, treadVecs[i]) #last riser in run triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt]) triangles.append(rs.AddPlanarSrf(triCrv)) geometry.append(riserGeo) #riser geometry.append(treadGeo) #tread curRiserHeight = curRiserHeight + riserHeight rs.MoveObject(riserCrvs[i][j], treadVecs[i]) #cleanup rs.DeleteObject(triCrv) rs.DeleteObject(stPt) rs.DeleteObject(pt1) rs.DeleteObject(pt2) else: for j in range(0, len(riserCrvs[i]) - 1): #if stairs ascend rs.MoveObject(riserCrvs[i][j], [0, 0, curRiserHeight]) stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j])) pt1 = rs.CopyObject( stPt, [0, 0, -riserHeight]) #first riser in run pt2 = rs.CopyObject(stPt, -treadVecs[i]) #last riser in run triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt]) triangles.append(rs.AddPlanarSrf(triCrv)) riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], [0, 0, -riserHeight]) treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j], [0, 0, 0], -treadVecs[i]) geometry.append(riserGeo) #riser geometry.append(treadGeo) #tread curRiserHeight = curRiserHeight + riserHeight #cleanup rs.DeleteObject(triCrv) rs.DeleteObject(stPt) rs.DeleteObject(pt1) rs.DeleteObject(pt2) #Make Stringer if (negativeBoo): firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0])) lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2])) #rs.MoveObject(firstStartPt, [0,0,riserHeight]) #first riser in run rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run rs.MoveObject(lastStartPt, [0, 0, riserHeight]) #last riser in run else: firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0])) lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2])) rs.MoveObject(firstStartPt, [0, 0, -riserHeight]) #first riser in run rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run stringerCrv = rs.AddLine(firstStartPt, lastStartPt) stringerSrf = rs.ExtrudeCurveStraight(stringerCrv, [0, 0, 0], [0, 0, -thickness]) triangles.append(stringerSrf) stringer = makeFace(triangles) stringerVec = rs.VectorCreate(rs.CurveEndPoint(riserCrvs[i][0]), rs.CurveStartPoint(riserCrvs[i][0])) underside = rs.ExtrudeCurveStraight( stringerCrv, rs.CurveStartPoint(riserCrvs[i][0]), rs.CurveEndPoint(riserCrvs[i][0])) geometry.append(rs.MoveObject(underside, [0, 0, -thickness])) geometry.append(rs.CopyObject(stringer, stringerVec)) geometry.append(stringer) #cleanup rs.DeleteObject(firstStartPt) rs.DeleteObject(lastStartPt) rs.DeleteObject(stringerCrv) rs.DeleteObject(stringerSrf) #Move Landings lastLandingHeight = 0 for i in range(0, len(segments) - 1): landingHeight = lastLandingHeight + numRisersPerRun[i] * riserHeight rs.MoveObject(landings[i], [0, 0, landingHeight]) landingTopSrf = rs.AddPlanarSrf(landings[i]) landingBtmSrf = rs.CopyObject(landingTopSrf, [0, 0, -thickness]) geometry.append(landingTopSrf) geometry.append(landingBtmSrf) lastLandingHeight = landingHeight landingEdgesToEx = rs.ExplodeCurves(landings[i]) geometry.append( rs.ExtrudeCurveStraight(landingEdgesToEx[1], [0, 0, 0], [0, 0, -thickness])) geometry.append( rs.ExtrudeCurveStraight(landingEdgesToEx[2], [0, 0, 0], [0, 0, -thickness])) rs.DeleteObjects(landingEdgesToEx) #Create final geometry joinedGeo = rs.JoinSurfaces(geometry, True) holes = rs.DuplicateSurfaceBorder(joinedGeo) cap = rs.AddPlanarSrf(holes) newGeo = rs.ExplodePolysurfaces(joinedGeo, True) for i in cap: newGeo.append(i) FinalGeo = rs.JoinSurfaces(newGeo, True) #cleanup try: rs.DeleteObjects(segments) except: rs.DeleteObject(segments) rs.DeleteObjects(holes) rs.DeleteObjects(landings) rs.DeleteObjects(landingEdges) for i in riserCrvs: rs.DeleteObjects(i) rs.EnableRedraw(True) return FinalGeo except: print "Error" return None
def get_cut_path_closed(self, crv): #crea la curva de corte y la curva de plunge en el nivel original plunge_distance = self.input_data[ "plunge"] if self.compensation != 0 else 10.0 no_entries = self.input_data["entries"] level_depth = self.input_data["depth"] / no_entries crv_domain = rs.CurveDomain(crv) crv_length = rs.CurveLength(crv) if plunge_distance >= crv_length: plunge_distance = crv_length * .8 crv_domain_param = crv_domain[1] - crv_domain[0] trim_domain = (plunge_distance * crv_domain_param) / crv_length planar_plunge_crv, cut_crv = rs.SplitCurve( rs.CopyObject(crv), rs.CurveDomain(crv)[0] + trim_domain) no_points = int(rs.CurveLength(planar_plunge_crv) / POINT_TOL) plunge_pts = rs.DivideCurve(planar_plunge_crv, no_points, create_points=False, return_points=True) plunge_moved_pts = [] z_count = abs(level_depth) z_pass = abs(level_depth / no_points) for pt in plunge_pts: new_point = pt[0], pt[1], pt[2] + z_count plunge_moved_pts.append(new_point) z_count -= z_pass plunge_crv = rs.AddPolyline(plunge_moved_pts) rs.SimplifyCurve(plunge_crv) #Crea la curva de corte para pocketing si se requiere pocketing_crv = None if not self.pocketing else self.finish_pocket_curves( self.make_pocket_curves(crv)) #Lista final de operacion de cortador por curva curves_cut_path = [] #agrega la entrada del cortador entry_end_point = rs.CurveStartPoint(planar_plunge_crv) sec_plane = self.general_input["sec_plane"] in_curve = rs.AddLine( (entry_end_point[0], entry_end_point[1], sec_plane), entry_end_point) rs.ObjectColor(in_curve, color_palette["plunge"]) curves_cut_path.append(in_curve) #general la lista de curvas y las ordena por nivel diferenciando entre plunge y corte por color for entrie in range(1, int(no_entries) + 1): z_level = level_depth * entrie translation = rs.VectorAdd((0, 0, 0), (0, 0, z_level)) level_plunge = rs.CopyObject(plunge_crv, translation) level_cut = rs.CopyObject(cut_crv, translation) rs.ObjectColor(level_plunge, color_palette["plunge"]) rs.ObjectColor(level_cut, color_palette["cut"]) curves_cut_path.append(level_plunge) curves_cut_path.append(level_cut) if self.pocketing: pocketing_curves = self.get_pocket_entry( z_level, translation, pocketing_crv) curves_cut_path += pocketing_curves #agrega la ultima linea de corte como plunge para no generar bote de pieza tan brusco final_cut = rs.CopyObject(planar_plunge_crv, translation) rs.ObjectColor(final_cut, color_palette["plunge"]) curves_cut_path.append(final_cut) #agrega la salida del cortador final_point = rs.CurveEndPoint(final_cut) out_curve = rs.AddLine(final_point, (final_point[0], final_point[1], sec_plane)) rs.ObjectColor(out_curve, color_palette["cut"]) curves_cut_path.append(out_curve) rs.DeleteObjects([planar_plunge_crv, plunge_crv, cut_crv, crv]) if self.pocketing: for po_crv in pocketing_crv: if po_crv != "sec_plane": rs.DeleteObject(po_crv) return curves_cut_path
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 rectify(pline, decPlaces): """ --Uses your current cplane as guides pline: one pline to rectify decPlace: number of decimals to round to (1 = 100mm, 2 = 10mm, 3 = 1mm) """ rs.EnableRedraw(False) #Remove colinear points rs.SimplifyCurve(pline) #orient to world xPt = rs.VectorAdd(rs.ViewCPlane().Origin, rs.ViewCPlane().XAxis) yPt = rs.VectorAdd(rs.ViewCPlane().Origin, rs.ViewCPlane().YAxis) origCplane = [rs.ViewCPlane().Origin, xPt, yPt] world = [[0, 0, 0], [1, 0, 0], [0, 1, 0]] rs.OrientObject(pline, origCplane, world) #get ctrl Pts ctrlPts = rs.CurvePoints(pline) #test if closed closedBool = rs.IsCurveClosed(pline) if closedBool: del ctrlPts[-1] #initial direction stPt = ctrlPts[0] nxtPt = ctrlPts[1] dX = abs(stPt[0] - nxtPt[0]) dY = abs(stPt[1] - nxtPt[1]) if dX > dY: xDir = True else: xDir = False #split into x and y vals xVals = [] yVals = [] xVals.append(ctrlPts[0][0]) yVals.append(ctrlPts[0][1]) if xDir: for i in range(1, len(ctrlPts)): if i % 2 == 1: xVals.append(ctrlPts[i][0]) else: yVals.append(ctrlPts[i][1]) else: for i in range(1, len(ctrlPts)): if i % 2 == 0: xVals.append(ctrlPts[i][0]) else: yVals.append(ctrlPts[i][1]) xVals = roundedDist(xVals, decPlaces) yVals = roundedDist(yVals, decPlaces) #Make points newPts = [] for i in range(0, len(ctrlPts)): if xDir: if i % 2 == 0: newPts.append( rs.coerce3dpoint([xVals[int(i / 2)], yVals[int(i / 2)], 0])) else: newPts.append( rs.coerce3dpoint( [xVals[int(i / 2 + .5)], yVals[int(i / 2 - .5)], 0])) else: if i % 2 == 0: newPts.append( rs.coerce3dpoint([xVals[int(i / 2)], yVals[int(i / 2)], 0])) else: newPts.append( rs.coerce3dpoint( [xVals[int(i / 2 - .5)], yVals[int(i / 2 + .5)], 0])) #Close it if closedBool: if xDir: newPts[-1].X = newPts[0].X else: newPts[-1].Y = newPts[0].Y newPts.append(newPts[0]) #make new Line newLine = rs.AddPolyline(newPts) #Cleanup objectsLay = rs.MatchObjectAttributes(newLine, pline) rs.ObjectColor(pline, (255, 0, 0)) #rs.DeleteObject(pline) #Move back to original cplane rs.OrientObject(newLine, world, origCplane) rs.EnableRedraw(True) return newLine