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)