def get_bounding_dims(brep): """return bounding box x,y,z dims for a brep or many breps""" bb = rs.BoundingBox(brep) Dimensions = namedtuple('Dimensions', 'X Y Z') dims = Dimensions(rs.Distance(bb[0], bb[1]), rs.Distance(bb[0], bb[3]), rs.Distance(bb[0], bb[4])) return dims
def GetNextEdge(self, baseEdge): smallestAngle = None smallestAngledEdge = None for edge in self.edges: if edge is baseEdge: continue b = self.obj if baseEdge.vertexAtEnd is self: a = baseEdge.vertexAtStart.obj else: a = baseEdge.vertexAtEnd.obj if edge.vertexAtEnd is self: c = edge.vertexAtStart.obj else: c = edge.vertexAtEnd.obj if rs.Distance(a, b) < sc.doc.ModelAbsoluteTolerance or rs.Distance( c, b) < sc.doc.ModelAbsoluteTolerance: continue try: angle = util.AngleABC(a, b, c) except: print "A: {}, B: {}, C: {}".format(a, b, c) ### if angle < smallestAngle or smallestAngle is None: smallestAngle = angle smallestAngledEdge = edge return smallestAngledEdge
def recSplit(self, iniPts, counter=0): p=iniPts vertical=False if(rs.Distance(p[0],p[1])>rs.Distance(p[0],p[3])): vertical=True if(vertical==True): p0,p1=self.verSplit(iniPts) else: p0,p1=self.horSplit(iniPts) poly0=rs.AddPolyline(p0) poly1=rs.AddPolyline(p1) counter+=1 if(counter<3): pts0=self.getIntxCrv(poly0) pts1=self.getIntxCrv(poly1) rs.DeleteObjects([poly0,poly1]) self.recSplit(pts0,counter) self.recSplit(pts1,counter) else: intxCrv0=rs.CurveBooleanIntersection(self.SITECRV,poly0) intxCrv1=rs.CurveBooleanIntersection(self.SITECRV,poly1) for i in intxCrv0: self.FPOLY.append(i) for i in intxCrv1: self.FPOLY.append(i) rs.DeleteObjects([poly0,poly1]) rs.DeleteObject(self.crv)
def bisecNormalAtStart(crv, compare): tolerance = 0.001 print('at start') p0 = rs.CurveStartPoint(crv) n1s = curvePlnrNormalAtEnds(crv) n1 = n1s[0] n2 = None #rs.AddPoint(p0) print('p0:', p0) print('pS:', rs.CurveStartPoint(compare)) print('pE:', rs.CurveEndPoint(compare)) compStart = rs.CurveStartPoint(compare) compEnd = rs.CurveEndPoint(compare) #rs.AddLine(compStart,compStart+Point3d(0,1,0)) #rs.AddLine(compEnd,compEnd+Point3d(0,1,0)) n2s = curvePlnrNormalAtEnds(compare) if rs.Distance(p0, compStart) < tolerance: n2 = n2s[0] print('found startpoint match') elif rs.Distance(p0, compEnd) < tolerance: n2 = n2s[1] print('found endpoint match') else: print('match not found') return None # rs.AddLine(p0,p0+n2) # rs.AddLine(p0,p0+n1) n = (n1 + n2) / 2 #rs.AddLine(p0,p0+n) return n
def grow(self, side): newBranches = [] if len(self.branches) == 0: self.startBranch() for i in range(len(self.branches)): self.pullBranch(self.branches[i]) axis01 = self.findAxis(self.branches[i].end01) axis02 = self.findAxis(self.branches[i].end02) if rs.VectorAngle(self.branches[i].axis, axis01) < 60 and side == 1: param = rs.CurveClosestPoint(self.path, self.branches[i].end01) dist = rs.Distance(self.branches[i].end01, rs.EvaluateCurve(self.path, param)) tan = rs.CurveTangent(self.path, param) newBranches.append( branch(self.branches[i].end01, self.branches[i].vec01, self.ang, axis01)) if rs.VectorAngle(self.branches[i].axis, axis02) < 60 and side == 2: param = rs.CurveClosestPoint(self.path, self.branches[i].end02) dist = rs.Distance(self.branches[i].end02, rs.EvaluateCurve(self.path, param)) tan = rs.CurveTangent(self.path, param) vecAng = rs.VectorAngle(self.branches[i].vec02, tan) vec = rs.VectorRotate(self.branches[i].vec02, -vecAng / 5, axis02) newBranches.append( branch(self.branches[i].end02, self.branches[i].vec02, self.ang, axis02)) self.branches = [] self.branches.extend(newBranches) return self.branches
def get_dist(pt,poly): # find closest point on axis curve param = rs.CurveClosestPoint(axis, pt) # get plane perpendicular to curve ck,pl = axis.PerpendicularFrameAt(param) # part responsible for flat end caps # if distance from point to plane is bigger than 0, # return that distance pp = rs.PlaneClosestPoint(pl,pt) d2 = rs.Distance(pt,pp) if d2>0.01: return d2 # else change the basis of the polygon from world xy # to that plane to check for distance and inside/outside pm = (param-axis.Domain[0])/(axis.Domain[1]-axis.Domain[0]) wxy = rs.WorldXYPlane() tf = rg.Transform.PlaneToPlane(wxy,pl) ang = sa + pm*(ea-sa) tr = rg.Transform.Rotation(ang, pl.Normal, pl.Origin) tpts = rs.CurvePoints(poly) for p in tpts: p.Transform(tf) p.Transform(tr) ply = rs.AddPolyline(tpts) prm = rs.CurveClosestPoint(ply,pt) cp = rs.EvaluateCurve(ply,prm) d = rs.Distance(pt,cp) # if the point is inside the curve, reverse the distance bln = rs.PointInPlanarClosedCurve(pt,ply,pl) if bln: d *= -1 return d
def connect(objects): points = [] c = rs.GetPoint("inclusion radius - center") if not c: sys.exit("no center point specified") r = rs.GetPoint("inclusion radius - distance") if not c: sys.exit("no distance specified") maxradius = rs.Distance(c, r) blen = len(objects) print "before: ", blen, " objects" for i in range(len(objects) - 1): if rs.IsPoint(objects[i]): points.append(objects[i]) alen = len(points) print "after: ", alen, " objects" for j in range(len(points) - 1): # for each point, for k in range(len(points) - 1): # go through each of the other objects: p1 = points[j] p2 = points[k] if p1 != p2: if rs.Distance(p1, p2) < maxradius: rs.AddLine(p1, p2)
def depressCrvs(crvs, paths, startPt, radius, sd): newCrvs = [] for i in range(len(crvs)): divPts = rs.DivideCurve(crvs[i], 100) if i < len(crvs) - 1: cntPt01 = centerCrv(crvs[i]) cntPt02 = centerCrv(crvs[i + 1]) horVec = rs.VectorCreate(cntPt01, cntPt02) for j in range(len(divPts)): path = rs.PointClosestObject(divPts[j], paths)[0] param = rs.CurveClosestPoint(path, divPts[j]) close = rs.EvaluateCurve(path, param) dist = rs.Distance(close, divPts[j]) tan = rs.CurveTangent(crvs[i], param) vec = [0, 0, -1] #rs.VectorCrossProduct(horVec,tan) testVec = rs.VectorCreate(cntPt01, divPts[j]) if rs.VectorDotProduct(vec, testVec) < 0: rs.VectorReverse(vec) vec = rs.VectorUnitize(vec) border = 1 entry = 1 if j > len(divPts) / 2: border = rs.Distance(rs.CurveEndPoint(crvs[i]), divPts[j]) else: border = rs.Distance(rs.CurveStartPoint(crvs[i]), divPts[j]) if border < sd * 3: border = border / (sd * 3) entryDist = rs.Distance(startPt, divPts[j]) if entryDist < sd * 10: entry = entryDist / (sd * 10) if dist < sd * 2: val = radius * (bellCrv(dist, sd)) divPts[j] = rs.PointAdd(divPts[j], vec * val * border * entry) newCrvs.append(rs.AddCurve(divPts)) return divPts
def isShareEdge(srf1, srf2): border1 = rs.DuplicateSurfaceBorder(srf1) border2 = rs.DuplicateSurfaceBorder(srf2) edges1 = rs.ExplodeCurves(border1, True) edges2 = rs.ExplodeCurves(border2, True) shareMid = [] threshold = 0.001 flag = False for e1 in edges1: for e2 in edges2: mid1 = rs.CurveMidPoint(e1) mid2 = rs.CurveMidPoint(e2) if rs.Distance(mid1, mid2) < threshold: s1 = rs.CurveStartPoint(e1) s2 = rs.CurveStartPoint(e2) e1 = rs.CurveEndPoint(e1) e2 = rs.CurveEndPoint(e2) if rs.Distance(s1, s1) < threshold: flag = True break if rs.Distance(s1, e1) < threshold: flag = True break rs.DeleteObjects(edges1) rs.DeleteObjects(edges2) return flag
def face_distance(face): dist1 = rs.Distance(points[face.A], points[face.B]) dist2 = rs.Distance(points[face.B], points[face.C]) dist3 = rs.Distance(points[face.C], points[face.A]) maxDist = max(dist1, dist2, dist3) if (maxDist <= threshold): newMesh.append(face)
def depressCrvs(srf, crvs, paths, startPt, radius, sd): newCrvs = [] for i in range(len(crvs)): divPts = rs.DivideCurve(crvs[i], 400) for j in range(len(divPts)): path = rs.PointClosestObject(divPts[j], paths)[0] param = rs.CurveClosestPoint(path, divPts[j]) close = rs.EvaluateCurve(path, param) srfParam = rs.SurfaceClosestPoint(srf, close) vec = rs.SurfaceNormal(srf, srfParam) dist = rs.Distance(close, divPts[j]) vec = rs.VectorUnitize(vec) border = 1 entry = 1 if j > len(divPts) / 2: border = rs.Distance(rs.CurveEndPoint(crvs[i]), divPts[j]) else: border = rs.Distance(rs.CurveStartPoint(crvs[i]), divPts[j]) if border < sd * 3: border = border / (sd * 3) else: border = 1 entryDist = rs.Distance(startPt, divPts[j]) if entryDist < sd * 10: entry = entryDist / (sd * 10) else: entry = 1 if dist < sd * 2: val = radius * (bellCrv(dist, sd)) divPts[j] = rs.PointAdd(divPts[j], vec * val * border * entry) newCrvs.append(rs.AddCurve(divPts)) return divPts
def SortCurves(curves, torrent=0.001): """将多条曲线组成的闭合环线,按照首尾相连的顺序重新排列 """ newCurves = [] newCurves.append(curves[0]) crvs = curves[:] del crvs[0] startP0 = rs.CurveStartPoint(newCurves[-1]) for i in range(len(curves) - 1): endP0 = rs.CurveEndPoint(newCurves[-1]) # if (rs.Distance(startP0,endP0)<torrent): # break flag = False for crv in crvs: sp = rs.CurveStartPoint(crv) ep = rs.CurveEndPoint(crv) if (rs.Distance(sp, endP0) < torrent): flag = True crvs.remove(crv) break if (rs.Distance(ep, endP0) < torrent): crvObj = rs.coercerhinoobject(crv).Geometry crvs.remove(crv) crv = ghc.FlipCurve(crvObj)[0] print('flip') flag = True break if not flag: print('erro:出现孤立的线') return None newCurves.append(crv) return newCurves
def genHalfPlanes(site_crv, int_crv): B = rs.BoundingBox(site_crv) polyBB = rs.AddPolyline([B[0], B[1], B[2], B[3], B[0]]) diagB = 2 * rs.Distance(B[0], B[2]) rays = [] int_pts = rs.CurvePoints(int_crv) bsp_tree = [] bsp_tree.append(site_crv) for i in range(len(int_pts) - 1): a = int_pts[i] b = int_pts[i + 1] m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, 0] p = [ m[0] + (a[0] - m[0]) * diagB / (rs.Distance(a, m)), m[1] + (a[1] - m[1]) * diagB / (rs.Distance(a, m)), 0 ] q = [ m[0] + (b[0] - m[0]) * diagB / (rs.Distance(b, m)), m[1] + (b[1] - m[1]) * diagB / (rs.Distance(b, m)), 0 ] u = [q[0] - p[0], q[1] - p[1], 0] v = [-u[1], u[0], 0] r = [p[0] + v[0], p[1] + v[1], 0] s = [q[0] + v[0], q[1] + v[1], 0] w = [u[1], -u[0], 0] R = [p[0] + w[0], p[1] + w[1], 0] S = [q[0] + w[0], q[1] + w[1], 0] polyA = rs.AddPolyline([p, q, s, r, p]) polyB = rs.AddPolyline([p, q, S, R, p]) used_crv = [] new_crv = [] for bsp_crv in bsp_tree: sum = 0 try: crvA = rs.CurveBooleanIntersection(bsp_crv, polyA) new_crv.append(crvA) sum += 1 except: pass try: crvB = rs.CurveBooleanIntersection(bsp_crv, polyB) new_crv.append(crvB) sum += 1 except: pass if (sum > 0): used_crv.append(bsp_crv) for crv in new_crv: bsp_tree.append(crv) for crv in used_crv: bsp_tree.remove(crv) rs.DeleteObject(crv) rs.DeleteObject(polyA) rs.DeleteObject(polyB) rs.DeleteObject(polyBB) return bsp_tree
def distance(self): Udomain = rs.SurfaceDomain(self.strsrf, 0) Vdomain = rs.SurfaceDomain(self.strsrf, 1) stepU = (Udomain[1] - Udomain[0]) / self.intu stepV = (Vdomain[1] - Vdomain[0]) / self.intv #PLOT POINTS ON SURFACE) for i in range(self.intu + 1): for j in range(self.intv + 1): #define u and v in terms of step values and i and j u = Udomain[0] + stepU * i v = Vdomain[0] + stepV * j point = rs.EvaluateSurface(self.strsrf, u, v) crvParam = rs.CurveClosestPoint(self.Crv, point) crvPoints = rs.EvaluateCurve(self.Crv, crvParam) if rs.Distance(point, crvPoints) < 400: self.dis[(i, j)] = rs.Distance(point, crvPoints) else: self.dis[(i, j)] = 1300 return self.dis
def CreateLandings(segmentsLeft, elbowsLeft, pitsLeft, segmentsRight, elbowsRight, pitsRight): """ returns: polyline (list): Closed planar landing curves """ allLandings = [] leftLandings = [] rightLandings = [] for i in range(0, len(segmentsLeft) - 1): #CONSTRUCT LANDING pt0 = segmentsLeft[i].PointAtEnd pt1 = segmentsRight[i].PointAtEnd pt2 = segmentsRight[i + 1].PointAtStart pt3 = segmentsLeft[i + 1].PointAtStart if pitsLeft[i * 2] is None: #Its turning right ptA = pitsRight[i * 2] ptB = elbowsLeft[i * 2].PointAt(1) else: ptB = pitsLeft[i * 2] ptA = elbowsRight[i * 2].PointAt(1) pts = [] ptsLeft = [] ptsRight = [] pts.append(pt0) pts.append(pt1) ptsRight.append(pt1) if rs.Distance(pt1, ptA) > rs.UnitAbsoluteTolerance(): pts.append(ptA) ptsRight.append(ptA) if rs.Distance(pts[-1], pt2) <= rs.UnitAbsoluteTolerance(): del pts[-1] del ptsRight[-1] pts.append(pt2) ptsRight.append(pt2) pts.append(pt3) ptsLeft.append(pt3) if rs.Distance(pt3, ptB) > rs.UnitAbsoluteTolerance(): pts.append(ptB) ptsLeft.append(ptB) if rs.Distance(pts[-1], pt0) > rs.UnitAbsoluteTolerance(): pts.append(pt0) ptsLeft.append(pt0) allLandings.append(rc.Geometry.PolylineCurve(pts)) #LANDING EDGES if len(ptsRight) > 1: rightLandings.append(rc.Geometry.PolylineCurve(ptsRight)) else: rightLandings.append(None) if len(ptsLeft) > 1: leftLandings.append(rc.Geometry.PolylineCurve(ptsLeft)) else: leftLandings.append(None) return allLandings, leftLandings, rightLandings
def RunCommand(): rc, corners = Rhino.Input.RhinoGet.GetRectangle() if rc <> Rhino.Commands.Result.Success: return rc plane = Rhino.Geometry.Plane(corners[0], corners[1], corners[2]) u_dir = rs.Distance(corners[0], corners[1]) v_dir = rs.Distance(corners[1], corners[2]) rs.AddPlaneSurface(plane, u_dir, v_dir)
def findHOffset(prevCrv, currentCrv): #The offset is equal to the width of the previous footprint's bounding box plus 1/8 of the width of the current footprint's bounding box. Returns the x-transformation amount. prevBox = rs.BoundingBox(prevCrv, in_world_coords=True) currentBox = rs.BoundingBox(currentCrv, in_world_coords=True) prevSpacing = rs.Distance(prevBox[0], prevBox[1]) currentSpacing = rs.Distance(currentBox[0], currentBox[1]) currentSpacing = currentSpacing * 0.25 offset = prevSpacing + currentSpacing return offset
def drawOpening(distance, length, block=0): if block == 1 and rs.IsBlock("window") == False: util.initWindowBlock() if block == 2 and rs.IsBlock("door") == False: util.initDoorBlock() if not rs.IsLayer("Axis"): util.initCaadLayer("Axis") twoLines = findTwoParallelLines() if not twoLines: return 0 pi, linei, linej = twoLines if not linej: return 0 pj = linej.CurveGeometry.Line.ClosestPoint(pi, False) oldLockMode = rs.LayerLocked("Axis", True) # side=0 start from startPoint , side=1 start from endPoint if rs.Distance(linei.CurveGeometry.Line.From, pi) <= rs.Distance( pi, linei.CurveGeometry.Line.To): side = 0 else: side = 1 # direct: # 0 | 1 # ------- # 2 | 3 vji = rs.VectorCreate(pj, pi) vi = linei.CurveGeometry.Line.Direction angle = rs.Angle((0, 0, 0), rs.VectorRotate(vji, -rs.Angle((0, 0, 0), vi)[0], (0, 0, 1))) if abs(angle[0] - 90) < sc.doc.ModelAbsoluteTolerance: line0 = linei line1 = linej if side == 0: direct = 2 else: direct = 3 elif abs(angle[0] + 90) < sc.doc.ModelAbsoluteTolerance: line0 = linej line1 = linei if side == 0: direct = 0 else: direct = 1 dl = DoubleLine(line0.CurveGeometry.Line, line1.CurveGeometry.Line) newLayer = rs.ObjectLayer(line0.Id) oldLayer = rs.CurrentLayer(newLayer) dl.drawOpening(distance, length, side, block, direct) rs.DeleteObject(line0.Id) rs.DeleteObject(line1.Id) rs.CurrentLayer(oldLayer) rs.LayerLocked("Axis", oldLockMode)
def GetMaxLength(rect): # find long side rs.ObjectColor(rect, Color.Blue) tempPt = rs.PolylineVertices(rect) tempPt = PointsReorder(tempPt, 1) if rs.Distance(tempPt[0], tempPt[1]) > rs.Distance(tempPt[1], tempPt[2]): rs.ObjectColor(rect, Color.Orange) return rs.Distance(tempPt[0], tempPt[1]) else: rs.ObjectColor(rect, Color.Orange) return rs.Distance(tempPt[1], tempPt[2])
def Orthographic_Cplane(): cpln_current = rs.ViewCPlane() Bool_Osnap = rs.Osnap() point = cpln_current.Origin if Bool_Osnap: rs.Osnap(False) rs.Command("_Circle 0,0,0 ") # rs.EnableRedraw(False) # Circle = rs.LastCreatedObjects() if Bool_Osnap: rs.Osnap(True) if Circle is None: # rs.EnableRedraw(True) # return if not rs.IsObject(Circle): rs.EnableRedraw(True) return rs.Command("_Point 0,0,1 ") pt_pos = rs.LastCreatedObjects() rs.Command("_Point 0,0,-1 ") pt_neg = rs.LastCreatedObjects() pt_cam = rs.ViewCamera() dist_pos = rs.Distance(pt_cam,pt_pos) dist_neg = rs.Distance(pt_cam,pt_neg) print pt_cam Disk = rs.AddPlanarSrf(Circle) rs.UnselectAllObjects() rs.SelectObjects(Disk) if dist_pos>dist_neg: rs.Command("OrientCameraToSrf _f 0,0,0 _pause") else: rs.Command("OrientCameraToSrf 0,0,0 _pause") rs.DeleteObjects((pt_pos,pt_neg,Circle,Disk)) rs.ViewProjection(None,1)
def postProcess(self): REDO=False ar=0.0 for i in self.FPOLY: rs.RotateObject(i, CP, -ANGLE) for i in self.FPOLY: try: ar+=rs.CurveArea(i)[0] except: pass mean_ar=ar/len(self.FPOLY) min_ar_per=0.2*mean_ar j=0 for i in self.FPOLY: pts=rs.CurvePoints(i) if(rs.CurveArea(i)[0]<min_ar_per): REDO=True break p=rs.BoundingBox(pts) max_poly=rs.AddPolyline([p[0],p[1],p[2],p[3],p[0]]) max_poly_ar=rs.CurveArea(max_poly)[0] actual_poly_ar=rs.CurveArea(i)[0] if((max_poly_ar/actual_poly_ar)>2): REDO=True rs.DeleteObject(max_poly) break else: rs.DeleteObject(max_poly) ab=int(rs.Distance(p[0],p[1])) ad=int(rs.Distance(p[0],p[3])) if((ab>ad) and (ab/ad)>5): REDO=True break elif((ab<ad) and (ab/ad)<0.2): REDO=True break j+=1 if(REDO==True and self.counter<MAX_REC): self.counter+=1 print("Redo %s" %(self.counter)) rs.DeleteObjects(self.FPOLY) self.start() self.recSplit(bsp.BBpts, 0) self.postProcess() else: j=0 for i in self.FPOLY: c=rs.CurveAreaCentroid(i)[0] rs.AddTextDot(str(j), c) j+=1
def ConvertToUVW(srf_id, xyz_points): uvw_points = [] for point in xyz_points: Suv = rs.SurfaceClosestPoint(srf_id, point) Sxyz = rs.EvaluateSurface(srf_id, Suv) Snormal = rs.SurfaceNormal(srf_id, Suv) dirPos = rs.PointAdd(Sxyz, Snormal) dirNeg = rs.PointSubtract(Sxyz, Snormal) Sdist = rs.Distance(Sxyz, point) if rs.Distance(point, dirPos) > rs.Distance(point, dirNeg): Sdist = -Sdist uvw_points.append((Suv(0), Suv(1), Sdist)) return uvw_points
def XYZ_To_UVW(srf_id, pXYZ): pUVW = [] for point in pXYZ: uvClosest = rs.SurfaceClosestPoint(srf_id, point) ptClosest = rs.EvaluateSurface(srf_id, uvClosest) srfNormal = rs.SurfaceNormal(srf_id, uvClosest) pPositive = rs.PointAdd(ptClosest, srfNormal) pNegative = rs.PointSubtract(ptClosest, srfNormal) fDistance = rs.Distance(ptClosest, point) if rs.Distance(point,pPositive) > rs.Distance(point, pNegative): fDistance = -fDistance pUVW.append( (uvClosest[0], uvClosest[1], fDistance) ) return pUVW
def RunCommand(): rc, corners = Rhino.Input.RhinoGet.GetRectangle() if rc != Rhino.Commands.Result.Success: return rc print(corners) plane = Rhino.Geometry.Plane(corners[0], corners[1], corners[2]) beam_frame = Frame(plane[0], plane[1], plane[3]) u_dir = rs.Distance(corners[0], corners[1]) v_dir = rs.Distance(corners[1], corners[2]) print(beam_frame) print(u_dir) print(v_dir) return beam_frame
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 planeexample(): origin = rs.GetPoint("Plane origin") if not origin: return ptX = rs.GetPoint("Plane X-axis", origin) if not ptX: return ptY = rs.GetPoint("Plane Y-axis", origin) if not ptY: return x = rs.Distance(origin, ptX) y = rs.Distance(origin, ptY) plane = rs.PlaneFromPoints(origin, ptX, ptY) rs.AddPlaneSurface(plane, 1.0, 1.0) rs.AddPlaneSurface(plane, x, y)
def GroupMove(rectOutlineList, objects, objCenter, rotatedAngle, movingCenter): for objs, rect, center, rotAngle, centerStart in zip( objects, rectOutlineList, objCenter, rotatedAngle, movingCenter): # rotate everything by center with rotatedAngle rs.RotateObjects(objs, center, rotAngle) # find vector to move from obj location to rectangle(obj center to rect center) boxCenter = rs.CurveAreaCentroid(rect)[0] moveVector = rs.VectorCreate(boxCenter, center) # check if object is in box rectPt = rs.PolylineVertices(rect) rectPt = PointsReorder(rectPt, 1) if rs.Distance(rectPt[0], rectPt[1]) > rs.Distance( rectPt[1], rectPt[2]): rs.RotateObjects(objs, center, 90) rs.MoveObjects(objs, moveVector)
def SillHeight(): # Find mid point of sill line midpointSill = rs.CurveMidPoint(window_sillLine[1]) #midpointSill = rs.AddPoint(midpointSill) # Find closest point in curve parameterSill = rs.CurveClosestPoint(window_sillLine[1], midpointSill) # Find curve Tangent sill_Tangent = rs.CurveTangent(window_sillLine[1], parameterSill) # find normal plane sill_plane = rs.PlaneFromNormal(midpointSill, sill_Tangent) # find start and end points of ground line points_gl = [] start_gl = rs.CurveStartPoint(groundLine[1]) end_gl = rs.CurveEndPoint(groundLine[1]) points_gl.append(start_gl) points_gl.append(end_gl) #find point on ground line pointGroundLine = rs.LinePlaneIntersection(points_gl, sill_plane) #pointGroundLine = rs.AddPoint(pointGroundLine) sill_Height = rs.Distance(midpointSill, pointGroundLine) return sill_Height
def HorizontalLines(): #Course = rs.OffsetCurve(,bbox[3],sill_remain) Surf_Height = rs.Distance(bbox[0], bbox[3]) #number of horizontal cources hori_no = Surf_Height / ipHeight #convert to intiger hori_no = int(hori_no) Course_All = [] Course = rs.AddLine(bbox[0], bbox[1]) Course_start = rs.ExtendCurveLength(Course, 0, 0, ipThick) Course_end = rs.ExtendCurveLength(Course, 0, 1, ipThick) Course = rs.JoinCurves((Course_start, Course, Course_end), True) Course1 = Course Course_All.append(Course) for index in range(0, hori_no, 1): Course = rs.OffsetCurve(Course, bbox[3], ipHeight) Course_All.append(Course) Course = rs.OffsetCurve(Course1, bbox[3], Surf_Height) Course_All.append(Course) rs.ObjectColor(Course_All, [255, 0, 0]) return Course_All
def WindowLeftDistance(): # Find midpoint of window left line midpoint_windowLeft = rs.CurveMidPoint(window_leftLine[1]) # Find closest point in curve window left parameterLeftLine = rs.CurveClosestPoint(window_leftLine[1], midpoint_windowLeft) # Find curve window left Tangent windowLeft_Tangent = rs.CurveTangent(window_leftLine[1], parameterLeftLine) # find window left normal plane windowLeft_plane = rs.PlaneFromNormal(midpoint_windowLeft, windowLeft_Tangent) # find start and end points of ground line points_ll = [] start_ll = bbox[0] end_ll = bbox[3] points_ll.append(start_ll) points_ll.append(end_ll) #find point on Surface Left line point_SurfLeftLine = rs.LinePlaneIntersection(points_ll, windowLeft_plane) #point_SurfLeftLine = rs.AddPoint(point_SurfLeftLine) Window_leftDistance = rs.Distance(midpoint_windowLeft, point_SurfLeftLine) return Window_leftDistance