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
