def meshExtrudePolyToByVectPlane(poly, vect, pln):
extrudeVect = vect
#find far line from vector to be intersected later
farvect = rs.VectorScale(extrudeVect, 1000)
pts = rs.CurveEditPoints(poly)
meshes = []
for i in range(0, len(pts) - 1):
p1 = pts[i]
p2 = pts[i + 1]
line = [p1, p1 + farvect]
p1pj = rs.LinePlaneIntersection(line, pln)
line = [p2, p2 + farvect]
p2pj = rs.LinePlaneIntersection(line, pln)
m = addMeshQuad([p1, p1pj, p2pj, p2])
meshes.append(m)
pjPolyPts = []
for p in pts:
line = [p, p + farvect]
xp = rs.LinePlaneIntersection(line, pln)
pjPolyPts.append(xp)
mesh = rs.JoinMeshes(meshes, True)
return mesh, pjPolyPts
def exportToSvg(x, state='init'):
points = flipY(rs.CurveEditPoints(x))
parsed = [parse(i) + "\n" for i in points]
parsed[-1] = parsed[-1][:-2]
parsed = "".join(parsed)
with open("{}{}.svg".format(state, rs.ObjectName(x)), "w") as f:
f.write(header.format(minPoint(points), maxPoint(points), parsed))
def meshSwipPolyAlongPoly(profile, rail):
profile = rs.CopyObject(profile)
pts = rs.CurveEditPoints(rail)
baseVect = Rhino.Geometry.Point3d(0, 1, 0)
meshes = []
for i in range(0, len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
rv1 = rs.VectorUnitize(p0 - p1)
vect = p1 - p0
mid = rs.VectorUnitize((rv1 + v2) / 2)
np = p1 + mid
up = p1 + Rhino.Geometry.Point3d(0, 0, 1)
pln = rs.PlaneFromPoints(p1, np, up)
mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln)
meshes.append(mesh)
rs.DeleteObject(profile)
profile = rs.AddPolyline(pjpts)
mesh = rs.JoinMeshes(meshes, True)
rs.DeleteObject(profile)
return mesh
def main():
obj = rs.GetObject()
#address_book = ['*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**']
address_book = ['*****@*****.**']
msg = MIMEMultipart()
sender = '*****@*****.**'
subject = "Email sent from Rhino"
body = '<html>'
body += "<p>Here are the points from a polyline: \n" + str(
[(pt.X, pt.Y, pt.Z) for pt in rs.CurveEditPoints(obj)]) + '</p> '
#body += ' <a href="file://datafiles/reference/22_REACH">Link</a>'
body += '</html>'
msg['From'] = sender
msg['To'] = ','.join(address_book)
msg['Subject'] = subject
msg.attach(MIMEText(body, 'html'))
text = msg.as_string()
#print text
# Send the message via our SMTP server
s = smtplib.SMTP('pny-ex.pelli-ny.local')
s.sendmail(sender, address_book, text)
s.quit()
def update(self):
print('update')
#delete last generated objects
try:
rs.DeleteObjects(self.generatedObjs)
self.generatedObjs = []
except:
print('exception in delete generated object')
divWidth = 600
crv = self.baseCrv
if not rs.IsObject(crv):
print('crv is not an object')
return
if not rs.IsPolyline(crv):
pts = rs.DivideCurveEquidistant(crv, divWidth)
rail = rs.AddPolyline(pts)
else:
rail = rs.CopyObject(crv)
pts = rs.CurveEditPoints(rail)
if len(pts) < 3:
print('too little points')
return
#find vectors to move and orient the profile
vect = pts[1] - pts[0]
vect = rs.VectorUnitize(vect)
a = rs.VectorAngle(vect, (0, 1, 0)) - 90
#load the component
path = self.loadPath
component = None
try:
component = importComponent(path)
except:
print('exception on importing module')
if component is None:
print('component is None')
return None
#rs.MoveObjects(component.breps,pts[0])
#rs.RotateObjects(component.breps,pts[0],a)
for b in component.breps:
self.generatedObjs.append(b)
oriented = orientObjAlongPolyPts(b, pts)
print('pts count:', len(pts), ' num gen:', len(oriented))
rs.MoveObjects(component.polys, pts[0])
rs.RotateObjects(component.polys, pts[0], a)
for c in component.polys:
self.generatedObjs.append(c)
mesh = meshSwipPolyAlongPoly(c, rail)
self.generatedObjs.append(mesh)
rs.DeleteObject(rail)
print('generated obj count:', len(self.generatedObjs))
rs.AddGroup('gen')
rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def deleteAlonePoint(self, points, intersectCurve):
editPoint = rs.CurveEditPoints(intersectCurve)
for i in editPoint:
for j in range(len(points)):
if rs.Distance(i, points[j]) == 0.0:
points.pop(j)
return points
def SaveCurveVertices(curve):
vertices = []
if rs.IsArc(curve):
midPt = rs.ArcMidPoint(curve)
stPt = rs.CurveStartPoint(curve)
endPt = rs.CurveEndPoint(curve)
pts = [stPt, midPt, endPt]
else:
pts = rs.CurveEditPoints(curve)
for pt in pts:
vertices.append([pt.X, pt.Y, pt.Z])
return vertices
def travel(self, startPoint, endPoint, surfaceToProject):
travelLine = rs.AddLine(startPoint, endPoint)
projectedTravelLine = rs.ProjectCurveToSurface(travelLine,
surfaceToProject,
(0, 0, 1))
rs.MoveObject(projectedTravelLine,
(0, 0, self.gcoder.getLayerHeight()))
try:
convertedTravelPolyline = rs.ConvertCurveToPolyline(
projectedTravelLine)
except:
print('In Trave, convertCurveToPolyline failed')
print(projectedTravelLine)
return False
travelVertices = rs.CurveEditPoints(convertedTravelPolyline)
rs.DeleteObject(convertedTravelPolyline)
self.gcoder.addGcode("G92 E0\n")
self.gcoder.initEValue()
tmpText = "G1 E{0} F{1}\n".format(self.gcoder.getRetractionDistance(),
1800)
self.gcoder.addGcode(tmpText)
travelLineStartPoint = rs.CurveStartPoint(travelLine)
projectedTravelLineStart = rs.CurveStartPoint(projectedTravelLine)
projectedTravelLineEnd = rs.CurveEndPoint(projectedTravelLine)
if rs.Distance(travelLineStartPoint,
projectedTravelLineStart) > rs.Distance(
travelLineStartPoint, projectedTravelLineEnd):
travelVertices = list(travelVertices)
travelVertices.reverse()
rs.DeleteObject(travelLine)
rs.DeleteObject(projectedTravelLine)
for travelVer in travelVertices:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
travelVer[0], travelVer[1], travelVer[2], 3600)
self.gcoder.addGcode(tmpText)
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(endPoint[0], endPoint[1],
endPoint[2], 3600)
tmpText += "G1 E0.0 F1800\n"
tmpText += "G92 E0\n"
self.gcoder.addGcode(tmpText)
def main():
path = rs.GetObject("Select Ramp Path", rs.filter.curve, True)
if path is None: return
if 'ramp-widthDefault' in sc.sticky:
widthDefault = sc.sticky['ramp-widthDefault']
else:
widthDefault = 36
if 'ramp-slopeDefault' in sc.sticky:
slopeDefault = sc.sticky['ramp-slopeDefault']
else:
slopeDefault = 8.333
width = rs.GetReal("Ramp Clear Width", widthDefault, minimum=36)
if width is None: return
slope = rs.GetReal("Ramp slope (e.g. 8.33%(1:12) is 8.33)", slopeDefault)
if slope is None: return
sc.sticky['ramp-widthDefault'] = width
sc.sticky['ramp-slopeDefault'] = slope
rs.EnableRedraw(False)
rampGeoList = Ramp_HeightSlope(path, width, slope / 100)
try:
layers.AddLayerByNumber(402, False)
layerName = layers.GetLayerNameByNumber(402)
rs.ObjectLayer(rampGeoList[0], layerName)
try:
if rampGeoList[2] is not None:
layers.AddLayerByNumber(106, False)
layerName = layers.GetLayerNameByNumber(106)
rs.ObjectLayer(rampGeoList[2], layerName)
except:
pass
result = True
except:
result = False
utils.SaveFunctionData('Architecture-ramp', [
width, slope,
str([(pt.X, pt.Y, pt.Z) for pt in rs.CurveEditPoints(path)]), result
])
rs.EnableRedraw(True)
print rampGeoList[1]
utils.SaveToAnalytics('architecture-ramp')
def getClamexVerAngle(obj):
vec_y = (0, -10, 0)
pts = rs.CurveEditPoints(obj)
leng = len(pts)
a = pts[leng - 1]
b = pts[leng - 2]
vec1 = b - a
angle = math.degrees(calcAngle(vec1, vec_y))
# round to 0 digits
angle = int(round(angle))
return angle
def AddCoordinateTag(obj):
dots = []
if rs.IsCurve(obj):
pts = rs.CurveEditPoints(obj)
elif rs.IsSurface(obj):
pts = rs.SurfaceEditPoints(obj)
elif rs.IsBrep(obj):
srfs = rs.ExplodePolysurfaces(obj)
pts = []
for srf in srfs:
pts+=rs.SurfaceEditPoints(srf)
rs.DeleteObjects(srfs)
try:
pts
except:
return
for pt in pts:
dots.append(rs.AddTextDot('X: '+str(pt.X)+'\nY: '+str(pt.Y)+'\nZ: ' +str( pt.Z), pt))
return dots
def minBoundingBox(crv):
"""Returns the minimal 2d bounding box of a curve or surface.
Parameters:
crv (curve) = planar curve or surface
Returns:
polylineCurve = min polyline based on area
"""
#Get control points
P = rs.CurveEditPoints(crv)
p = []
for i in range(0, len(P)-1):
p.append(P[i])
#get The convex hull
hull = ConvexHull(p)
convexHull = hull.get_polyline()
minArea = None
minBoundary = None
plane = crv.TryGetPlane()[1]
normal = plane.Normal
#For each edge
for i in range(convexHull.SegmentCount):
edge = convexHull.SegmentAt(i)
segVec = edge.PointAt(0) - edge.PointAt(1)
yVec = rs.VectorCrossProduct(normal, segVec)
plane = rg.Plane(rs.coerce3dpoint((0,0,0)), segVec, yVec)
bbPts = rs.BoundingBox(crv, view_or_plane = plane)
newPts = bbPts[:4]
newPts.append(bbPts[0])
pline = rg.PolylineCurve(newPts)
am = rg.AreaMassProperties.Compute(pline)
area = am.Area
if area < minArea or minArea is None:
minArea = area
minBoundary = pline
return minBoundary
def makeGcodeFromSlicedCurve(self, slicedCurve, layer):
deleteItem = []
tmpText = ""
#it may shit
if rs.IsCurveClosed(slicedCurve) is False:
#slicedCurve = rs.CloseCurve(slicedCurve)
startPoint = rs.CurveStartPoint(slicedCurve)
endPoint = rs.CurveEndPoint(slicedCurve)
curveForFix = rs.AddCurve([startPoint, endPoint])
curves = []
curves.append(slicedCurve)
curves.append(curveForFix)
slicedCurve = rs.JoinCurves(curves)
#dirVec = rs.CurveNormal(slicedCurve)
dirVec = self.normalVec
#shell by shell
#shell inside to outside
for shell in range(self.gcoder.getNumShellOutline()):
nozzleDia = self.gcoder.getExtruderDiameter()
'''
if shell == 0:
offsetCurve = rs.OffsetCurve(slicedCurve, tuple(dirVec), nozzleDia/2.0)
else:
#offsetCurve = rs.OffsetCurve(slicedCurve, tuple(dirVec), self.gcoder.getLayerHeight() * shell)
offsetCurve = rs.OffsetCurve(slicedCurve, tuple(dirVec), nozzleDia/2.0 + nozzleDia*shell)
'''
if shell == self.gcoder.getNumShellOutline() - 1:
##offsetCurve = rs.OffsetCurve(slicedCurve, dirVec, -nozzleDia/2.0)
offsetCurve = rs.OffsetCurve(slicedCurve, dirVec,
nozzleDia / 2.0)
else:
try:
##offsetCurve = rs.OffsetCurve(slicedCurve, dirVec, -(nozzleDia/2.0 + nozzleDia*(self.gcoder.getNumShellOutline()-shell-1)))
offsetCurve = rs.OffsetCurve(
slicedCurve, dirVec,
(nozzleDia / 2.0 + nozzleDia *
(self.gcoder.getNumShellOutline() - shell - 1)))
except:
print('offset failed\nslicedCurve')
print(slicedCurve)
print('dirVec')
print(dirVec)
#skip, when offset fail
if offsetCurve == None:
#print('failed to offset curve')
continue
if isinstance(offsetCurve, list) and len(offsetCurve) > 1:
rs.DeleteObjects(offsetCurve)
continue
#explodedCurve = rs.ExplodeCurves(offsetCurve)
#lines from explodedCurve
#from outline to gcode
#explodCurve is not enough
#you need to convert curve to polyline
#and then get point from editPoint
prePoint = None
currentPoint = None
convertedPolyline = rs.ConvertCurveToPolyline(offsetCurve)
vertices = rs.CurveEditPoints(convertedPolyline)
rs.DeleteObject(convertedPolyline)
flag = True
for ver in vertices:
currentPoint = ver
if flag:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(
currentPoint[0], currentPoint[1], currentPoint[2],
3600)
flag = False
else:
self.gcoder.calcEValue(rs.Distance(currentPoint, prePoint))
tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
currentPoint[0], currentPoint[1], currentPoint[2],
self.gcoder.getEValue(), 1800)
prePoint = currentPoint
self.gcoder.addGcode(tmpText)
#rs.DeleteObjects(explodedCurve)
#from outline to fill gocde
#if shell is last one, it needs to fill layer or infill
#inside to outside
if shell == (self.gcoder.getNumShellOutline() - 1):
rs.DeleteObject(offsetCurve)
##offsetCurveForFill = rs.OffsetCurve(slicedCurve, dirVec, -(nozzleDia/2.0 + nozzleDia*(self.gcoder.getNumShellOutline())))
offsetCurveForFill = rs.OffsetCurve(
slicedCurve, dirVec, (nozzleDia / 2.0 + nozzleDia *
(self.gcoder.getNumShellOutline())))
#newOffsetCurve = rs.OffsetCurve(offsetCurve, tuple(dirVec), self.gcoder.getLayerHeight())
if offsetCurveForFill == None:
#print('failed to offset curve')
break
if isinstance(offsetCurveForFill,
list) and len(offsetCurveForFill) > 1:
rs.DeleteObjects(offsetCurveForFill)
break
'''
offsetCurveForFill = rs.OffsetCurve(offsetCurve, tuple(dirVec), nozzleDia)
#detect failed to offset
if isinstance(offsetCurveForFill, list) and len(offsetCurveForFill) > 1:
continue
'''
#fill for middle paralell layer
for paralellLayer in range(len(
self.paralellIntersectedCurves)):
if layer >= self.indexParalellSurfaces[
paralellLayer] and abs(
layer -
self.indexParalellSurfaces[paralellLayer]
) < self.gcoder.getNumTopLayer():
'''
dirVecForParalell = rs.CurveAreaCentroid(self.paralellIntersectedCurves[paralellLayer])
dirVecForParalell = dirVecForParalell[0]
'''
dirVecForParalell = rs.CurveNormal(
self.paralellIntersectedCurves[paralellLayer])
offsetParalell = rs.OffsetCurve(
self.paralellIntersectedCurves[paralellLayer],
dirVecForParalell,
-(nozzleDia / 2.0 + nozzleDia *
(self.gcoder.getNumShellOutline())))
#debug
'''
#print('layer')
#print(layer)
rs.UnselectAllObjects()
rs.SelectObject(offsetParalell)
rs.Command('Move')
'''
#it needs to debug, it's close
self.setLayerFill(offsetParalell, layer)
continue
#self.setInfill(vec, newOffsetCurve, offsetParalell)
if layer < (self.gcoder.getNumBottomLayer()):
self.setLayerFill(offsetCurveForFill, layer)
rs.DeleteObject(offsetCurveForFill)
elif layer > (
int(self.distancePrinting / self.fixedLayerHeight) -
self.gcoder.getNumTopLayer()):
self.setLayerFill(offsetCurveForFill, layer)
rs.DeleteObject(offsetCurveForFill)
else:
self.setInfill(offsetCurveForFill, layer)
if offsetCurveForFill is not None:
rs.DeleteObject(offsetCurveForFill)
#rs.DeleteObjects(newOffsetCurve)
#DEBUG
rs.DeleteObjects(offsetCurve)
rs.DeleteObject(slicedCurve)
import System
import System.Windows.Forms as Forms
from System.Windows.Forms import *
import System.Drawing as Drawing
from System.Drawing import *
import Rhino
import rhinoscriptsyntax as rs
baseObj = rs.AddLine((0, 0, 0), (0, -200, 0))
poly = rs.GetObject('sel crv', 4, False)
pts = rs.CurveEditPoints(poly)
rs.AddPoints(pts)
def orientObjAlongPolyPts(obj, pts, baseVect=(0, 1, 0)):
up = (0, 0, 1)
for i in range(0, len(pts) - 1):
if i < (len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
n1 = rs.VectorCrossProduct(v1, up)
n2 = rs.VectorCrossProduct(v2, up)
mid = rs.VectorAdd(n1, n2)
n = rs.VectorUnitize(mid)
else:
p0 = pts[i]
def MakeRampRuns(path, width):
topOffset = 12
btmOffset = 12
newPath = rs.CopyObject(path)
segments = rs.ExplodeCurves(newPath, True)
if len(segments) < 1:
segments = [newPath]
stPt1 = rs.CurveStartPoint(segments[0])
stPt2 = rs.CurveStartPoint(segments[0])
vec = rs.CurveTangent(path, 0)
rs.VectorUnitize(vec)
vec = rs.VectorScale(vec, width / 2)
vecSide1 = rs.VectorRotate(vec, 90, (0, 0, 1))
vecSide2 = rs.VectorRotate(vec, -90, (0, 0, 1))
ptSide1 = rs.MoveObject(stPt1, vecSide1)
ptSide2 = rs.MoveObject(stPt2, vecSide2)
offsetCrv1 = rs.OffsetCurve(path, ptSide1, width / 2)
offsetCrv2 = rs.OffsetCurve(path, ptSide2, width / 2)
pts1 = rs.CurveEditPoints(offsetCrv1)
pts2 = rs.CurveEditPoints(offsetCrv2)
del pts1[0]
del pts2[0]
nextSegOffsetStPt = stPt1
landingLines = []
handrailLines = []
#Entering Loop For each segment
for i, segment in enumerate(segments):
beginningPt = rs.EvaluateCurve(
segment, rs.CurveClosestPoint(segment, nextSegOffsetStPt))
crossVec = rs.VectorScale(
rs.VectorCreate(beginningPt, nextSegOffsetStPt), 2)
widthStPt = rs.CopyObject(nextSegOffsetStPt)
widthEndPt = rs.MoveObject(nextSegOffsetStPt, crossVec)
closestPt1Param = rs.CurveClosestPoint(segment, pts1[i])
closestPt1 = rs.EvaluateCurve(path, closestPt1Param)
closestPt2Param = rs.CurveClosestPoint(segment, pts2[i])
closestPt2 = rs.EvaluateCurve(path, closestPt2Param)
if rs.Distance(closestPt2, beginningPt) > rs.Distance(
closestPt1, beginningPt):
nextSegOffsetStPt = pts1[i]
else:
nextSegOffsetStPt = pts2[i]
if rs.Distance(nextSegOffsetStPt, widthStPt) < rs.Distance(
nextSegOffsetStPt, widthEndPt):
stLine = rs.AddLine(widthStPt, widthEndPt)
shortVec = rs.VectorCreate(widthEndPt, widthStPt)
pt4 = rs.CopyObject(nextSegOffsetStPt, shortVec)
endLine = rs.AddLine(nextSegOffsetStPt, pt4)
if i != 0:
longVec = rs.VectorReverse(
rs.VectorCreate(widthStPt, nextSegOffsetStPt))
longVec = rs.VectorScale(rs.VectorUnitize(longVec), btmOffset)
stLine = rs.MoveObject(stLine, longVec)
if i != len(segments) - 1:
longVec = rs.VectorCreate(widthStPt, nextSegOffsetStPt)
longVec = rs.VectorScale(rs.VectorUnitize(longVec), topOffset)
endLine = rs.MoveObject(endLine, longVec)
else:
stLine = rs.AddLine(widthEndPt, widthStPt)
shortVec = rs.VectorCreate(widthStPt, widthEndPt)
pt4 = rs.CopyObject(nextSegOffsetStPt, shortVec)
endLine = rs.AddLine(nextSegOffsetStPt, pt4)
if i != 0:
longVec = rs.VectorReverse(
rs.VectorCreate(widthEndPt, nextSegOffsetStPt))
longVec = rs.VectorScale(rs.VectorUnitize(longVec), btmOffset)
stLine = rs.MoveObject(stLine, longVec)
if i != len(segments) - 1:
longVec = rs.VectorCreate(widthEndPt, nextSegOffsetStPt)
longVec = rs.VectorScale(rs.VectorUnitize(longVec), topOffset)
endLine = rs.MoveObject(endLine, longVec)
#Done
landingLines.append([stLine, endLine])
#Cleanup
rs.DeleteObject(widthStPt)
rs.DeleteObject(pt4)
rs.DeleteObject(widthEndPt)
#Cleanup
rs.DeleteObject(ptSide1)
rs.DeleteObject(ptSide2)
rs.DeleteObjects(segments)
rs.DeleteObject(offsetCrv1)
rs.DeleteObject(offsetCrv2)
return landingLines
def meshExtrudePolyByVect(poly, vect, colorRow=None):
pts = rs.CurveEditPoints(poly)
meshExtrudePtsByVect(pts, vect, colorRow)
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 main():
if (rs.UnitSystem() == 2):
widthDefault = 1800
widthMin = 900
widthMax = 100000
heightDefault = 5000
heightMin = 300
elif (rs.UnitSystem() == 4):
widthDefault = 1.8
widthMin = .9
widthMax = 100.0
heightDefault = 5.0
heightMin = .30
elif (rs.UnitSystem() == 8):
widthDefault = 42
widthMin = 36
widthMax = 1000.0
heightDefault = 120
heightMin = 12
else:
print "Change your units to inches"
return
route = rs.GetObject("Select Stair Guide Curve", rs.filter.curve, True)
if route is None: return
if 'stair-widthDefault' in sc.sticky:
widthDefault = sc.sticky['stair-widthDefault']
if 'stair-heightDefault' in sc.sticky:
heightDefault = sc.sticky['stair-heightDefault']
width = rs.GetReal("Stair Width",
number=widthDefault,
minimum=widthMin,
maximum=widthMax)
if width is None: return
height = rs.GetReal("Stair Height",
number=heightDefault,
minimum=heightMin)
if height is None: return
sc.sticky['stair-widthDefault'] = width
sc.sticky['stair-heightDefault'] = height
try:
stairGeo = stairHeight(route, width, height)
result = True
except:
result = False
try:
layers.AddLayerByNumber(401, False)
layerName = layers.GetLayerNameByNumber(401)
rs.ObjectLayer(stairGeo, layerName)
except:
pass
utils.SaveFunctionData('Architecture-Stair', [
width, height,
str([(pt.X, pt.Y, pt.Z) for pt in rs.CurveEditPoints(route)]), result
])
utils.SaveToAnalytics('Architecture-Stair')
return True
return False
def isHorizontal(crv,tolerance=0.0001):
start=rs.CurveStartPoint(c)
end=rs.CurveEndPoint(c)
if abs(start[2]-end[2])<tolerance:
return True
return False
objs=rs.ObjectsByLayer('GENMASSING')
srf=objs[0]
print(srf)
boundary=rs.DuplicateSurfaceBorder(srf)
pts=rs.CurveEditPoints(boundary)
# rs.AddPoints(pts)
crvs=rs.ExplodeCurves(boundary,True)
hors=[]
for c in crvs:
if isHorizontal(c): hors.append(c)
up=(0,0,100000000)
cutters=[]
for c in hors:
p=rs.CurveStartPoint(c)
start=rs.VectorSubtract(p,up)
end=rs.VectorAdd(p,up)
l=rs.AddLine(start,end)
rs.ObjectName(l,'cutters')
if rs.Distance(points[0], points[1]) < rs.Distance(points[1], points[2]):
distance = rs.Distance(points[0], points[1])
line = rs.AddLine(points[0], points[1])
line2 = rs.AddLine(points[2], points[3])
mid1 = rs.CurveMidPoint(line)
mid2 = rs.CurveMidPoint(line2)
path = rs.AddLine(mid1, mid2)
else:
distance = rs.Distance(points[1], points[2])
line = rs.AddLine(points[1], points[2])
line2 = rs.AddLine(points[3], points[0])
mid1 = rs.CurveMidPoint(line)
mid2 = rs.CurveMidPoint(line2)
path = rs.AddLine(mid1, mid2)
points = rs.CurveEditPoints(line)
radius = distance / 2
rs.DeleteObject(line2)
param = rs.SurfaceClosestPoint(face, points[0])
normal = rs.SurfaceNormal(face, param)
normalVect = distance * rs.VectorReverse(normal)
endPoint = points[0] + normalVect
line2 = rs.AddLine(points[0], endPoint)
param = rs.SurfaceClosestPoint(face, points[1])
normal = rs.SurfaceNormal(face, param)
normalVect = distance * rs.VectorReverse(normal)
endPoint = points[1] + normalVect
def makeGcodeFromSlicedCurve(self, slicedCurve, layer, vec, multiplier):
deleteItem = []
tmpText = ""
editPointsOfIntersectCurve = rs.CurveEditPoints(slicedCurve)
dirVec = [0, 0, 0]
for l in editPointsOfIntersectCurve:
dirVec[0] += l[0]
dirVec[1] += l[1]
dirVec[2] += l[2]
dirVec = [i / len(editPointsOfIntersectCurve) for i in dirVec]
#shell by shell
for shell in range(self.gcoder.getNumShellOutline()):
if shell == 0:
offsetCurve = rs.CopyObject(slicedCurve)
else:
offsetCurve = rs.OffsetCurve(
slicedCurve, tuple(dirVec),
self.gcoder.getLayerHeight() * shell)
#if offsetCurve == None or isinstance(offsetCurve, list) or not rs.IsCurveClosed(offsetCurve):
#if offsetCurve == None or isinstance(offsetCurve, list):
if offsetCurve == None:
#print('failed to offset curve')
continue
if isinstance(offsetCurve, list) and len(offsetCurve) > 1:
rs.DeleteObjects(offsetCurve)
continue
explodedCurve = rs.ExplodeCurves(offsetCurve)
#lines from explodedCurve
#from outline to gcode
prePoint = None
for line in range(len(explodedCurve)):
startPoint = rs.CurveStartPoint(explodedCurve[line])
endPoint = rs.CurveEndPoint(explodedCurve[line])
if line == 0:
tmpText = "G1 X" + str(startPoint[0]) + " Y" + str(
startPoint[1]) + " Z" + str(startPoint[2]) + " F3600\n"
#self.gcoder.calcEValue(startPoint, endPoint)
self.gcoder.calcEValue(rs.Distance(startPoint, endPoint))
tmpText += "G1 X" + str(endPoint[0]) + " Y" + str(
endPoint[1]) + " Z" + str(endPoint[2]) + " E" + str(
self.gcoder.getEValue()) + " F1800\n"
rs.DeleteObjects(explodedCurve)
self.gcoder.addGcode(tmpText)
#from outline to fill gocde
#if shell is last one, it needs to fill layer or infill
if shell == (self.gcoder.getNumShellOutline() - 1):
newOffsetCurve = rs.OffsetCurve(offsetCurve, tuple(dirVec),
self.gcoder.getLayerHeight())
if isinstance(newOffsetCurve,
list) and len(newOffsetCurve) > 1:
continue
if layer < (self.gcoder.getNumBottomLayer()):
self.setLayerFill(vec, newOffsetCurve, layer)
elif layer > (int(self.distancePrinting / multiplier) -
self.gcoder.getNumTopLayer()):
self.setLayerFill(vec, newOffsetCurve, layer)
else:
self.setInfill(vec, newOffsetCurve)
#rs.DeleteObjects(newOffsetCurve)
rs.DeleteObjects(offsetCurve)
rs.DeleteObject(slicedCurve)
newCurve = rs.GetObject('Select Curve')
rs.RebuildCurve(newCurve, 3, point_count=400)
#rate = 0.01 #Adjust rate
throat = rs.RealBox("Enter Initial Diameter",
1,
'Initial Diameter',
minimum=None,
maximum=None) #Adjust initial throat size
initThroat = 0.999
throat = throat / 2
horn = rs.RealBox("Enter Final Diameter",
10,
'Final Diameter',
minimum=None,
maximum=None)
curvePoints = rs.CurveEditPoints(newCurve)
#curvePoints = rs.CurveContourPoints(newCurve, rs.CurveStartPoint(newCurve), rs.CurveEndPoint(newCurve))
numPoints = len(curvePoints)
rate = (math.log((horn / 2) + initThroat - (throat))) / (numPoints - 1)
#cloud = rs.AddPointCloud(curvePoints)
x = 0
offPoints = []
offPoints2 = []
circleProfiles = []
for c in curvePoints:
param = rs.CurveClosestPoint(newCurve, c)
tangent = rs.CurveTangent(newCurve, param)
tempLine = rs.AddLine([0, 0, 0], tangent)
def setLayerFillT1(self, outline, layerIndex):
"""
1. make line from planarBaseSurface
2. project that line to base surface
3. trim projected line by curved surface
4. move to place shoud be, Z-Axis
"""
sliceSurface = rs.CopyObject(
self.contactSurface,
(0, 0, self.gcoder.getLayerHeight() * layerIndex))
#make base fill line from outline
convertedPolyline = rs.ConvertCurveToPolyline(outline)
vertices = rs.CurveEditPoints(convertedPolyline)
rs.DeleteObject(convertedPolyline)
xValue = [i[0] for i in vertices]
yValue = [i[1] for i in vertices]
xValue.sort()
yValue.sort()
basePoint = []
basePoint.append((xValue[0], yValue[0], 0))
basePoint.append((xValue[-1], yValue[0], 0))
basePoint.append((xValue[-1], yValue[-1], 0))
basePoint.append((xValue[0], yValue[-1], 0))
if layerIndex % 2 == 0:
baseLine = rs.AddLine(basePoint[0], basePoint[1])
baseVec = (basePoint[3][0] - basePoint[0][0],
basePoint[3][1] - basePoint[0][1],
basePoint[3][2] - basePoint[0][2])
dist = rs.Distance(basePoint[0], basePoint[3])
elif layerIndex % 2 == 1:
baseLine = rs.AddLine(basePoint[0], basePoint[3])
baseVec = (basePoint[1][0] - basePoint[0][0],
basePoint[1][1] - basePoint[0][1],
basePoint[1][2] - basePoint[0][2])
dist = rs.Distance(basePoint[0], basePoint[1])
# for T0 of Bimatrix
forNormal = math.sqrt(baseVec[0]**2 + baseVec[1]**2 + baseVec[2]**2)
baseVec = [i / forNormal for i in baseVec]
self.gcoder.addGcode("\n \n \n ; layer filling LayerNo:" +
str(layerIndex) + " - T1 (Toolhead 1) \n \n \n")
self.gcoder.addGcode("M135 T1 \n")
self.gcoder.addGcode("T1 \n")
#make gcode of layer filling
for i in range(int(dist / self.gcoder.getExtruderDiameter())):
liens = []
# *2 means every 2 thread for BiMatrix
nextVec = [
v * self.gcoder.getExtruderDiameter() +
v * self.gcoder.getExtruderDiameter() * i * 2 for v in baseVec
]
if layerIndex % 2 == 0:
nextStartPoint = (basePoint[0][0] + nextVec[0],
basePoint[0][1] + nextVec[1],
basePoint[0][2] + nextVec[2])
nextEndPoint = (basePoint[1][0] + nextVec[0],
basePoint[1][1] + nextVec[1],
basePoint[1][2] + nextVec[2])
elif layerIndex % 2 == 1:
nextStartPoint = (basePoint[0][0] + nextVec[0],
basePoint[0][1] + nextVec[1],
basePoint[0][2] + nextVec[2])
nextEndPoint = (basePoint[3][0] + nextVec[0],
basePoint[3][1] + nextVec[1],
basePoint[3][2] + nextVec[2])
nextLine = rs.AddLine(nextStartPoint, nextEndPoint)
projectedLine = rs.ProjectCurveToSurface(nextLine, sliceSurface,
(0, 0, 1))
if projectedLine is None:
rs.DeleteObject(nextLine)
continue
rs.DeleteObject(nextLine)
trimedLine = self.trim(projectedLine, outline)
if trimedLine is None or len(trimedLine) is 0:
if projectedLine is not None:
try:
rs.DeleteObject(projectedLine)
except:
print('deleteObject failed')
print(projectedLine)
continue
rs.DeleteObject(projectedLine)
if i % 2 == 1:
trimedLine.reverse()
for j in trimedLine:
prePoint = None
currentPoint = None
if j is None:
continue
try:
convertedPolyline = rs.ConvertCurveToPolyline(j)
except:
print("hoge")
print(j)
vertices = rs.CurveEditPoints(convertedPolyline)
rs.DeleteObject(convertedPolyline)
flag = True
if i % 2 == 1:
vertices = list(vertices)
vertices.reverse()
for ver in vertices:
currentPoint = ver
if flag:
self.travel(self.travelStartPoint, currentPoint,
sliceSurface)
#tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(currentPoint[0], currentPoint[1], currentPoint[2], 3600)
flag = False
else:
self.gcoder.calcEValue(
rs.Distance(currentPoint, prePoint))
tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
currentPoint[0], currentPoint[1], currentPoint[2],
self.gcoder.getEValue(), 1800)
self.gcoder.addGcode(tmpText)
prePoint = currentPoint
else:
self.travelStartPoint = currentPoint
#bug
if layerIndex != 0:
if trimedLine is not None:
rs.DeleteObjects(trimedLine)
rs.DeleteObject(sliceSurface)
return
def slice(self):
'''
1. intersect with sliceSurface and additiveObj
2. make shells(outline) from each intersected line
[3-1. if bottom, make layer fill from intersected line]
[3-2. if not bottom, make layer infill]
'''
layer = 0
while True:
tmpText = "\n" + "; layer " + str(layer) + "\n" + "\n" + "\n"
#tmpText += "G92 E0\n"
self.gcoder.addGcode(tmpText)
self.gcoder.initEValue()
sliceSurface = rs.CopyObject(
self.contactSurface,
(0, 0, self.gcoder.getLayerHeight() * layer))
#make intersected lines
intersectedLines = rs.IntersectBreps(sliceSurface,
self.additiveObj)
if intersectedLines is None:
#slice is done
rs.DeleteObject(sliceSurface)
print('slicing is done')
return True
#delete unClosed Line from intersectedLines
cullIndex = []
openCurves = []
for i in range(len(intersectedLines)):
if not rs.IsCurveClosed(intersectedLines[i]):
cullIndex.append(i)
for i in range(len(cullIndex)):
cullIndex[i] -= i
for i in cullIndex:
#rs.DeleteObject(intersectedLines[i])
openCurves.append(intersectedLines[i])
del intersectedLines[i]
if layer == 0:
self.travelStartPoint = (0, 0, 200)
#make shell from outline
for outline in intersectedLines:
##debug needs
#tmpText = "G1 Z45 F3600\n"
#self.gcoder.addGcode(tmpText)
prePoint = None
currentPoint = None
convertedPolyline = rs.ConvertCurveToPolyline(outline)
vertices = rs.CurveEditPoints(convertedPolyline)
rs.DeleteObject(convertedPolyline)
flag = True
for ver in vertices:
currentPoint = ver
if flag:
if self.travelStartPoint is None:
print('travelStartPoint is None')
if currentPoint is None:
print('currentPoint is None')
travelResult = self.travel(self.travelStartPoint,
currentPoint, sliceSurface)
if travelResult is False:
tmpText = "G92 E0\nG1 E-2 F3600\n"
tmpText += "G1 Z{0}\n".format(currentPoint[2] + 10)
tmpText += "G1 X{0} Y{1} Z{2}\n".format(
currentPoint[0], currentPoint[1],
currentPoint[2])
tmpText += "G1 E0\n"
self.gcoder.addGcode(tmpText)
flag = False
##traveling end
else:
self.gcoder.calcEValue(
rs.Distance(currentPoint, prePoint))
tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(
currentPoint[0], currentPoint[1], currentPoint[2],
self.gcoder.getEValue(), 1800)
##We don't need to use outer shell for BiMatrix, so I commented out the next line.
##self.gcoder.addGcode(tmpText)
##
prePoint = currentPoint
else:
self.travelStartPoint = currentPoint
self.setLayerFillT0(outline, layer)
self.setLayerFillT1(outline, layer)
'''
for openCurve in openCurves:
#self.gcoder.addGcode("G1 Z45 F3600\n")
prePoint = None
currentPoint = None
convertedPolyline = rs.ConvertCurveToPolyline(openCurve)
vertices = rs.CurveEditPoints(convertedPolyline)
rs.DeleteObject(convertedPolyline)
flag = True
for ver in vertices:
currentPoint = ver
if flag:
tmpText = "G1 X{0} Y{1} Z{2} F{3}\n".format(currentPoint[0], currentPoint[1], currentPoint[2], 3600)
flag = False
else:
self.gcoder.calcEValue(rs.Distance(currentPoint, prePoint))
tmpText = "G1 X{0} Y{1} Z{2} E{3} F{4}\n".format(currentPoint[0], currentPoint[1], currentPoint[2], self.gcoder.getEValue(), 1800)
prePoint = currentPoint
self.gcoder.addGcode(tmpText)
'''
##for zuhan
#rs.DeleteObjects(intersectedLines)
rs.DeleteObjects(openCurves)
#make layer fill
#make layer infil
rs.DeleteObject(sliceSurface)
layer += 1
return True
curvesByLayers[2].append(curve)
elif rs.ObjectLayer(curve)=="4":
curvesByLayers[3].append(curve)
elif rs.ObjectLayer(curve)=="5":
curvesByLayers[4].append(curve)
elif rs.ObjectLayer(curve)=="6":
curvesByLayers[5].append(curve)
print len(curvesByLayers[0])
for idx, pencurves in enumerate(curvesByLayers):
if not pencurves: continue
pen = idx + 1
hpglOut.write('SP'+str(pen)+';\n')
for curve in pencurves:
if rs.CurveDegree (curve) == 1: #polyline or line
points=rs.CurveEditPoints(curve) #works for polyline or line
#print 'line'
elif rs.CurveDegree (curve) == 2 or rs.CurveDegree (curve) == 3: #curvy curve
points = rs.DivideCurveLength(curve, .025)
print 'curvy'
if not points:
#print 'found one very tiny curve, which is not exported'
continue #means skip this iteration of the loop and go right to the next curve
#pen up to the first point on line
x = points[0][0]
y = points[0][1]
hpglOut.write('PU'+str(int(x*1000))+','+str(int(y*1000))+';\n')
#pen down to every subsequent point
i=1
while i<len(points):
x = points[i][0]
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
import rhinoscriptsyntax as rs
import math
newCurves = rs.GetObjects('select curves')
x = 0
polyLines = []
for curve in newCurves:
rad = rs.CurveRadius(curve, rs.CurveStartPoint(curve))
cLength = math.sqrt(((rad*math.cos((math.pi)/4))-rad)**2+(rad*math.cos((math.pi)/4))**2)
points = rs.CurveEditPoints(curve)
polyLine = rs.AddPolyline(points)
polyLines.append(polyLine)
rs.DeleteObjects(newCurves)
rs.AddLoftSrf(polyLines,None, None, loft_type = 2, simplify_method = 0, value=0, closed=False)
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 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)
