def ArcToPlineCurve(segment): pline = segment if type(segment) == rc.Geometry.ArcCurve: if segment.AngleDegrees < 180: ptA1 = segment.PointAtStart + segment.TangentAtStart ptB1 = segment.PointAtEnd + segment.TangentAtEnd lineA = rc.Geometry.Line(segment.PointAtStart, ptA1) lineB = rc.Geometry.Line(segment.PointAtEnd, ptB1) result, paramA, paramB = rc.Geometry.Intersect.Intersection.LineLine( lineA, lineB) if result: ptC = lineA.PointAt(paramA) pline = rc.Geometry.PolylineCurve( [segment.PointAtStart, ptC, segment.PointAtEnd]) elif type(segment) == rc.Geometry.NurbsCurve: if segment.IsArc(rs.UnitAbsoluteTolerance()): result, arc = segment.TryGetArc(rs.UnitAbsoluteTolerance()) if result: if arc.AngleDegrees < 180: ptA0 = arc.StartPoint ptB0 = arc.EndPoint paramA0 = arc.ClosestParameter(ptA0) paramB0 = arc.ClosestParameter(ptB0) ptA1 = ptA0 + arc.TangentAt(paramA0) ptB1 = ptB0 + arc.TangentAt(paramB0) lineA = rc.Geometry.Line(ptA0, ptA1) lineB = rc.Geometry.Line(ptB0, ptB1) result, paramA, paramB = rc.Geometry.Intersect.Intersection.LineLine( lineA, lineB) if result: ptC = lineA.PointAt(paramA) pline = rc.Geometry.PolylineCurve([ptA0, ptC, ptB0]) return pline
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 TrimUnderSrfsWithSides(underSrfs, leftSide, rightSide, thickness): finalUnderSrfs = [] for eachUnderSrf in underSrfs: srf1 = eachUnderSrf.Trim(rightSide, rs.UnitAbsoluteTolerance())[0] srf2 = srf1.Trim(leftSide, rs.UnitAbsoluteTolerance()) finalSrf = srf2[0] finalSrf.Translate(rc.Geometry.Vector3d(0, 0, -thickness)) finalUnderSrfs.append(finalSrf) return finalUnderSrfs
def JoinTopSrfs(riserSrfs, treadSrfs, leftSide, rightSide): allGeo = riserSrfs + treadSrfs brep = rc.Geometry.Brep.JoinBreps(allGeo, rs.UnitAbsoluteTolerance()) sc.doc.Objects.AddBrep(brep[0]) rightSideTrimmed0 = rightSide.Trim(brep[0], rs.UnitAbsoluteTolerance()) leftSideTrimmed0 = leftSide.Trim(brep[0], rs.UnitAbsoluteTolerance()) sc.doc.Objects.Add(rightSideTrimmed0[0]) sc.doc.Objects.Add(leftSideTrimmed0[0]) print
def OffsetBothDir(segments, width): """ Offsets a list of segements in both directions. """ normal = rc.Geometry.Vector3d(0, 0, 1) dist = width / 2 tol = rs.UnitAbsoluteTolerance() offsetSegmentsLeft = [] offsetSegmentsRight = [] #Get offset segments for i, segment in enumerate(segments): if segment is None: continue startVec = segment.TangentAtStart startVec.Rotate(math.pi / 2, normal) startPt = segment.PointAtStart offsetPtLeft = startPt.Add(startPt, startVec) offsetSegmentsLeft += segment.Offset(offsetPtLeft, normal, dist, tol, 0) offsetSegmentsRight += segment.Offset(offsetPtLeft, normal, -dist, tol, 0) return [offsetSegmentsLeft, offsetSegmentsRight]
def geodesiccurve(): surface_id = rs.GetObject("Select surface for geodesic curve solution", 8, True, True) if not surface_id: return vertices = getr2pathonsurface(surface_id, 10, "Start of geodesic curve", "End of geodesic curve") if not vertices: return tolerance = rs.UnitAbsoluteTolerance() / 10 length = 1e300 newlength = 0.0 while True: print("Solving geodesic fit for %d samples" % len(vertices)) vertices = geodesicfit(vertices, surface_id, tolerance) newlength = polylinelength(vertices) if abs(newlength - length) < tolerance: break if len(vertices) > 1000: break vertices = subdividepolyline(vertices) length = newlength rs.AddPolyline(vertices) print "Geodesic curve added with length: ", newlength
def IntersectBrepPlane(obj, plane): tolerance = rs.UnitAbsoluteTolerance() #BREP brep = rs.coercebrep(obj) intersectionCrvs = [] if brep is None: return None x = rc.Geometry.Intersect.Intersection.BrepPlane(brep, plane, tolerance) if x is None: return xCurves = x[1] if xCurves is None: return None try: newCurves = rc.Geometry.Curve.JoinCurves(xCurves) except: newCurves = xCurves finalCurves = [] for curve in newCurves: finalCurve = sc.doc.Objects.AddCurve(curve) utils.SafeMatchObjectAttributes(finalCurve, obj) finalCurves.append(finalCurve) return finalCurves
def RandomPtOnSrf(srf): if srf is None: print "Not a surface" return dom_u = rs.SurfaceDomain(srf, 0) dom_v = rs.SurfaceDomain(srf, 1) counter = 0 while True: pt_u = random.uniform(dom_u[0], dom_u[1]) pt_v = random.uniform(dom_v[0], dom_v[1]) pt = rs.EvaluateSurface(srf, pt_u, pt_v) if type(srf ) == rc.DocObjects.ObjectType.Extrusion: #If extrusion objects temp = rs.coercesurface(srf) testSrf = temp.ToBrep() else: testSrf = srf testPt = testSrf.ClosestPoint(pt) d = rs.Distance(testPt, pt) if d > rs.UnitAbsoluteTolerance(): return pt else: counter += 1
def AlignAngles(pts, angles, srf, spacing): spacing = spacing * 2 #rhsrf = rs.coercebrep(srf) test = srf.ToBrep() edges = test.DuplicateNakedEdgeCurves(True, False) boundary = rc.Geometry.Curve.JoinCurves(edges)[0] tol = rs.UnitAbsoluteTolerance() plane = boundary.TryGetPlane()[1] for i, pt in enumerate(pts): currentAngleVec = AngleToVec(angles[i]) #PTS TO COMPARE AGAINST closest = None for j, comparePt in enumerate(pts): distance = pt.DistanceTo(comparePt) if distance == 0: continue if closest is None or distance < closest[0]: closest = distance, comparePt, j if closest is None: continue neighborAngleVec = rc.Geometry.Vector3d( math.cos(math.radians(angles[closest[2]])), math.sin(math.radians(angles[closest[2]])), 0) newVec = (currentAngleVec + currentAngleVec + neighborAngleVec) / 3 angles[i] = VecToAngle(newVec) return angles
def ExtendTangents(segment1, segment2, dir=True): """ dir = True: For previous segment """ #dir = True tol = rs.UnitAbsoluteTolerance() #if dir: seg1EndPt = segment1.PointAtEnd line1EndPt = seg1EndPt.Add(seg1EndPt, segment1.TangentAtEnd) line1 = rc.Geometry.Line(seg1EndPt, line1EndPt) seg2StPt = segment2.PointAtStart line2EndPt = seg2StPt.Add(seg2StPt, -segment2.TangentAtStart) line2 = rc.Geometry.Line(seg2StPt, line2EndPt) #sc.doc.Objects.AddLine(line1) #sc.doc.Objects.AddLine(line2) intersections = rc.Geometry.Intersect.Intersection.LineLine( line1, line2, tol, False) testLen1 = intersections[1] testLen2 = intersections[2] if dir: newEndPt = line1.PointAtLength(intersections[1]) finalLine = rc.Geometry.Line(seg1EndPt, newEndPt) else: newEndPt = line2.PointAtLength(intersections[1]) finalLine = rc.Geometry.Line(seg2StPt, newEndPt) #sc.doc.Objects.AddLine(finalLine) return finalLine
def MakeTreadSurfaces(leftSegments, rightSegments, landings, allTreads, preview=True): tol = rs.UnitAbsoluteTolerance() #Make tread surfaces treadSrfs = [] for i, each in enumerate(leftSegments): edge1 = allTreads[i][0] edge2 = allTreads[i][-1] edge3 = each edge4 = rightSegments[i] boundary = rc.Geometry.Curve.JoinCurves([edge1, edge3, edge2, edge4])[0] if boundary.ClosedCurveOrientation( ) == rc.Geometry.CurveOrientation.Clockwise: boundary.Reverse() planarSrf = rc.Geometry.Brep.CreatePlanarBreps(boundary, tol)[0] treadSrf = planarSrf.Faces[0].Split(allTreads[i], tol) treadSrfs.append(treadSrf) if preview: sc.doc.Objects.AddBrep(treadSrf) #Create Landing Surfaces landingSrfs = [] for each in landings: planarSrf = rc.Geometry.Brep.CreatePlanarBreps([each], tol)[0] landingSrfs.append(planarSrf) if preview: sc.doc.Objects.AddBrep(planarSrf) return treadSrfs, landingSrfs
def TrimOffsets(origLines): """ Trim the end off of intersecting curves input: origLines = Curves return: Trimmed curves """ tol = rs.UnitAbsoluteTolerance() trimmedCurves = [] elbowCurves = [] pitPoints = [] #for each in origLines: # sc.doc.Objects.Add(each) for i, each in enumerate(origLines): if i == 0: #Dont intersect prev segment if first segment lowerParam = each.Domain.T0 else: #Intersection with previous segment intersections = rc.Geometry.Intersect.Intersection.CurveCurve( origLines[i - 1], origLines[i], tol, tol) if intersections.Count == 0: #No intersection with prev segment lowerParam = each.Domain.T0 #So, lowerParam = start of this segment #ITS AN ELBOW elbowCurves.append( ExtendTangents(origLines[i - 1], origLines[i])) pitPoints.append(None) else: lowerParam = intersections.Item[ 0].ParameterB #There was intersectino with prev segment, so lowerparam = intersection param #ITS A PIT elbowCurves.append(None) pitPoints.append(intersections.Item[0].PointA) if i == len( origLines) - 1: #Dont intersect next segment if last segment higherParam = each.Domain.T1 else: #Intersection with Next segment intersections = rc.Geometry.Intersect.Intersection.CurveCurve( origLines[i + 1], origLines[i], tol, tol) if intersections.Count == 0: #No intersection with prev segment higherParam = each.Domain.T1 #So, lowerParam = end of this segment #Its an elbow elbowCurves.append( ExtendTangents(origLines[i], origLines[i + 1], False)) pitPoints.append(None) else: higherParam = intersections.Item[ 0].ParameterB #There was intersectino with prev segment, so lowerparam = intersection param #Its a pit elbowCurves.append(None) pitPoints.append(intersections.Item[0].PointA) domain = rc.Geometry.Interval(lowerParam, higherParam) trimmedCurves.append(each.Trim(domain)) return trimmedCurves, elbowCurves, pitPoints
def get_tolerance(): """Get the absolute tolerance. Returns ------- float The tolerance. """ return rs.UnitAbsoluteTolerance()
def IsObjIntersectingPlane(obj, plane): if isinstance(obj, rc.Geometry.Brep): intersection = rc.Geometry.Intersect.Intersection.BrepPlane( obj, plane, rs.UnitAbsoluteTolerance()) if intersection is not None: if intersection[1] is not None: if len(intersection[1]) > 0: return True else: return False else: return False else: return False if isinstance(obj, rc.Geometry.Curve): intersection = rc.Geometry.Intersect.Intersection.CurvePlane( obj, plane, rs.UnitAbsoluteTolerance()) if intersection is None: return False else: return True
def MakeStair_Button(): tol = rs.UnitAbsoluteTolerance() objs = rs.GetObjects("Select guide path") if objs is None: return height = rs.GetReal("Stair Height", number=120) if height is None: return width = rs.GetReal("Stair Width", number=30) if width is None: return for obj in objs: MakeStair(obj, width, height)
def SplitBREPwithCurve(brep, plane): interCrvs = rc.Geometry.Intersect.Intersection.BrepPlane( brep, plane, rs.UnitAbsoluteTolerance())[1] if interCrvs is None: testPt = brep.Vertices[0].Location dist = plane.DistanceTo(testPt) print dist if dist < 0: print "Side A" #sc.doc.Objects.AddBrep(brep) else: print "Side B" for numFaces, each in enumerate(brep.Faces): pass numFaces += 1 for i in range(0, numFaces): brep = brep.Faces[i].Split(interCrvs, rs.UnitAbsoluteTolerance()) print "" sc.doc.Objects.AddBrep(brep)
def IntersectGeo(obj, level): tolerance = rs.UnitAbsoluteTolerance() plane = rc.Geometry.Plane(rs.coerce3dpoint((0, 0, level)), rs.coerce3dvector((0, 0, 1))) finalCurves = [] #BLOCKS if rs.IsBlockInstance(obj): matrix = rs.BlockInstanceXform(obj) blockObjs = rs.BlockObjects(rs.BlockInstanceName(obj)) for eachBlockObj in blockObjs: newCopy = rs.CopyObject(eachBlockObj) xformedObj = rs.TransformObject(newCopy, matrix) #EXTRUSIONS if isinstance(xformedObj, rc.Geometry.Extrusion): temp = sc.doc.Objects.AddBrep(xformedObj.ToBrep(False)) xformedObj = rs.coercebrep(temp) rs.DeleteObject(temp) #BREPS IN BLOCK result = IntersectBrepPlane(xformedObj, plane) if result is None: continue for each in result: if each is not None: finalCurves.append(each) rs.DeleteObject(xformedObj) #MESHES IN BLOCK <---This code might not be necessary result = IntersectMeshPlane(xformedObj, plane) if result is None: continue for each in result: if each is not None: finalCurves.append(each) rs.DeleteObject(xformedObj) #BREPS elif rs.IsBrep(obj): result = IntersectBrepPlane(obj, plane) if result is None: return None for each in result: if each is not None: finalCurves.append(each) #MESHES elif rs.IsMesh(obj): result = IntersectMeshPlane(obj, plane) if result is None: return None for each in result: if each is not None: finalCurves.append(each) return finalCurves
def surfaceIrradiance_fixed(towerIn, sunIn, intensityIn): sunUnit = rs.VectorUnitize(sunIn) for floor in range(len(towerIn)): numPoints = len(towerIn[floor]) for i in range(numPoints): p1 = towerIn[floor][i] p2 = towerIn[floor][(i + 1) % numPoints] v1 = rs.VectorSubtract(p2, p1) v2 = [0, 0, 1] n = rs.VectorCrossProduct(v1, v2) if rs.VectorLength(n) > rs.UnitAbsoluteTolerance(10**(-3), True): cosTheta = rs.VectorDotProduct(rs.VectorUnitize(n), sunUnit) if cosTheta > 0: factor = intensityIn * cosTheta / 200 #200 is just to shorten the vector to something manageable v = rs.VectorScale(n, factor) AddVector(v, p1)
def GeodesicCurve(surface_id, vertices): tolerance = rs.UnitAbsoluteTolerance() / 10 length = 1e300 while True: print("Solving geodesic fit for %d samples" % len(vertices)) vertices = GeodesicFit(vertices, surface_id, tolerance) newlength = PolylineLength(vertices) if abs(newlength - length) < tolerance: break if len(vertices) > 1000: break vertices = SubDividePolyline(vertices) length = newlength geodesicPolyline = rs.AddPolyline(vertices) print "Geodesic curve added with length: ", newlength return geodesicPolyline
def OrientAwayFromEdges(pts, angles, srf, spacing): spacing = spacing #rhsrf = rs.coercebrep(srf) test = srf.ToBrep() edges = test.DuplicateNakedEdgeCurves(True, False) #<---------- boundary = rc.Geometry.Curve.JoinCurves(edges)[0] tol = rs.UnitAbsoluteTolerance() plane = boundary.TryGetPlane()[1] for i, pt in enumerate(pts): closestPt = boundary.ClosestPoint(pt, spacing) if closestPt[0]: distance = rs.Distance(pt, boundary.PointAt(closestPt[1])) if distance < spacing: tangent = boundary.TangentAt(closestPt[1]) tangent.Reverse() angles[i] = VecToAngle(tangent) angles[i] += random.uniform(-120, 120) return angles
def IntersectMeshPlane(obj, plane): tolerance = rs.UnitAbsoluteTolerance() #BREP mesh = rs.coercemesh(obj) intersectionCrvs = [] if mesh is None: return None x = rc.Geometry.Intersect.Intersection.MeshPlane(mesh, plane) if x is None: return #Match attributes finalCurves = [] for curve in x: finalCurve = sc.doc.Objects.AddPolyline(curve) utils.SafeMatchObjectAttributes(finalCurve, obj) #rs.MatchObjectAttributes(finalCurve, obj) BROKEN finalCurves.append(finalCurve) return finalCurves
def MoveAwayFromEdges(pts, srf, spacing): spacing = spacing * .75 test = srf.ToBrep() edges = test.DuplicateNakedEdgeCurves(True, False) boundary = rc.Geometry.Curve.JoinCurves(edges)[0] tol = rs.UnitAbsoluteTolerance() plane = boundary.TryGetPlane()[1] for i, pt in enumerate(pts): closestPt = boundary.ClosestPoint(pt, spacing) if closestPt[0]: vec = rs.VectorCreate(pt, boundary.PointAt(closestPt[1])) newDist = (spacing) - vec.Length if boundary.Contains(pt, plane, tol) == rc.Geometry.PointContainment.Outside: vec.Reverse() newDist = (spacing) + (vec.Length) vec.Unitize() pts[i] = pt.Add(pt, vec * newDist) return pts
def GetUphillVectorFromPlane(obj, u = 0, v = 0): """Gets the uphill vector from a surface, with optional u, v Parameters: surface (surface): surface to test u (float)[optional]: u parameter v (float)[optional]: v parameter Returns: vector(guid, ...): identifiers of surfaces created on success """ rhobj = rs.coercesurface(obj) frame = rhobj.FrameAt(u,v)[1] pt0 = rhobj.PointAt(u,v) pt1 = rc.Geometry.Point3d.Add(pt0, rc.Geometry.Vector3d(0,0,10)) projPoint = frame.ClosestPoint(pt1) vec = rs.VectorCreate(projPoint, pt0) if rs.VectorLength(vec) < rs.UnitAbsoluteTolerance(): uphillVec = rc.Geometry.Vector3d(0,0,1) else: uphillVec = rs.VectorUnitize(vec) return uphillVec
def __init__(self): self.epsilon = rs.UnitAbsoluteTolerance() self.curve = None #Holds the Rhino pitch curve object self.crvLen = None self.isClosed = None self.isCircle = None self.PD = 1.0 #Pitch diameter = given (propagate to -> MDL, BC, Tc) self.PA = 20.0 #Pressure angle = 14.5, 20.0, 25.0 (propagate to -> minN, BC, DED) self.MDL = 0.0588 #Module = PD / N (propagate to -> ADD, DED, OD, CP) self.N = 17 #Number of teeth (propagate to -> MDL, Tc) self.maxN = 1000 self.minN = 17 #Min number of teeth (depends on pressure angle) -> 2/sin^2(PA*pi/180) self.BC = 0.9397 #Base circle = PD*cos(pi*PA/180). The bigger the pressure angle the further BC is to PD self.ADD = 0.0588 #Addendum = MDL self.DED = 0.0735 #Dedendum = 1.250*MDL use 1.157 for 14.5 PA (propagate to -> RD) self.OD = 1.1176 #Outside diameter = PD+2*MDL self.RD = 0.8529 #Root diameter = PD-2*DED self.Tc = 0.0922 #Chordal thickness = PD*sin(pi/(2*N)) self.CP = 0.1848 #Circular pitch = pi*MDL or crvLen/N (propagate to -> MDL ) self.CA = 0.0 #Cone angle (0 to 90) self.origin = None #Pitch circle origin (world coordinates) self.normal = None #The normal of the plane the gear is on (this 3D point assumes world 0,0,0 as the first vector point) self.plane = None #The local plane where the gear is on. Origin of plane is set at center of gear. self.smpl = 5 #Involute point samples (3 to 40) self.error = False #Setting this to true will cause exit without draw self.show = { "PitchCir": False, "BCcircle": False, "ODcircle": False, "RDcircle": False } self.involute = { "startAngle": None, "endAngle": None, "angleMod": None, "pointsLeft": [], "pointsRight": [], "pointsTop": [], "ptsLeftDed": [], "ptsRightDed": [] } #points are stored in world coordinates
def descent(self, points=None): """""" if not points: points = self.heightfield() tol = rs.UnitAbsoluteTolerance() descent = [] if rs.IsPolysurface(self.guid): rs.EnableRedraw(False) faces = {} for p0 in points: p = p0[:] p[2] -= 2 * tol bcp = rs.BrepClosestPoint(self.guid, p) uv = bcp[1] index = bcp[2][1] try: face = faces[index] except (TypeError, IndexError): face = rs.ExtractSurface(self.guid, index, True) faces[index] = face p1 = rs.EvaluateSurface(face, uv[0], uv[1]) vector = [p1[_] - p0[_] for _ in range(3)] descent.append((p0, vector)) rs.DeleteObjects(faces.values()) rs.EnableRedraw(True) elif rs.IsSurface(self.guid): for p0 in points: p = p0[:] p[2] -= 2 * tol bcp = rs.BrepClosestPoint(self.guid, p) uv = bcp[1] p1 = rs.EvaluateSurface(self.guid, uv[0], uv[1]) vector = [p1[_] - p0[_] for _ in range(3)] descent.append((p0, vector)) else: raise RhinoSurfaceError('object is not a surface') return descent
def geodesicCurve(): #get a surface surface = rs.GetObject("Select Surface to Fit Curve", 8, True, True) if not surface: return #get the vertices for the shortest r2 path with 10 sample points vertices = getr2PathOnSurface(surface, 10, "Start Point for Curve", "End Point for Curve") if not vertices: return #set the tolerence for 1/10 of the tolerence of the model space tolerence = rs.UnitAbsoluteTolerance() * 0.1 #set a big and small starting value for our length tests length = 1e300 newLength = 0.0 #do this recursivly while True: print("Solving for %d samples" % len(vertices)) #run the vertices into the fitting subroutine vertices = geodesicFit(vertices, surface, tolerence) #check our length here, if we are with acceptable tolerence we should go newLength = polylineLength(vertices) if abs(newLength - length) < tolerence: break #if for some reason we still haven't found a solution and have over 1000 #vertices we should also go if len(vertices) > 1000: break #subdivide the polyline to double the number of samples and get ready to #start the fitting again vertices = subdivPolyline(vertices) length = newLength #once we are fit within tolerence, add the line to the document and prompt user rs.AddPolyline(vertices) print("added line")
def convert_to_uv_space(srf,pts): tol = rs.UnitAbsoluteTolerance() uv_pts = [] for pt in pts: #need for issues in cases points lie on a seam if not rs.IsPointOnSurface (srf, pt): pts_dis = [] pts_dis.append((pt[0]+tol,pt[1],pt[2])) pts_dis.append((pt[0]-tol,pt[1],pt[2])) pts_dis.append((pt[0],pt[1]+tol,pt[2])) pts_dis.append((pt[0],pt[1]-tol,pt[2])) pts_dis.append((pt[0],pt[1],pt[2]+tol)) pts_dis.append((pt[0],pt[1],pt[2]-tol)) for pt_dis in pts_dis: data= rs.BrepClosestPoint(srf,pt_dis) if rs.IsPointOnSurface(srf,data[0]): pt = data[0] break u,v = rs.SurfaceClosestPoint(srf,pt) uv_pts.append((u,v,0)) #rs.AddTextDot(str(data[2] ) + " / " + str(rs.IsPointOnSurface (srf, pt)) + " / " + str(u) + " / " + str(v),pt) return uv_pts
def IntersectGeos(objs, plane): tolerance = rs.UnitAbsoluteTolerance() finalGeo = [] for obj in objs: intersectionCrvs = [] brep = rs.coercebrep(obj) if brep is None: continue x = Rhino.Geometry.Intersect.Intersection.BrepPlane( brep, plane, tolerance) xCurves = x[1] if xCurves is None: continue try: rs.JoinCurves(xCurves) except: pass for curve in xCurves: finalCurve = sc.doc.Objects.AddCurve(curve) rs.SetUserText(finalCurve, 'PCPA_floorplan', 'intersect') intersectionCrvs.append(finalCurve) finalGeo.append(intersectionCrvs) rs.MatchObjectAttributes(intersectionCrvs, obj) return finalGeo
def TrimSidesWithUnderSrf(underSrf, leftSide, rightSid): underSrf.Trim(leftSide, rs.UnitAbsoluteTolerance()) sc.doc.Objects.Add(leftSide) #sc.doc.Objects.Add(underSrf) print "HI"
def CreateUnderWedge(landings, landingsLeft, landingsRight, landingSrfs, landingHeights, riserHeight, treadLengths, thickness): wedges = [] for i, landingLeft in enumerate(landingsLeft): rightStartPt = landingsRight[i].PointAtStart rightVec = landingsRight[i].TangentAtStart leftStartPt = landingsLeft[i].PointAtEnd leftVec = landingsLeft[i].TangentAtEnd leftVec.Reverse() riseRatio = riserHeight / treadLengths[i] rightVec.Z = riseRatio leftVec.Z = riseRatio factor = riserHeight / riseRatio directionEndPtRight = rc.Geometry.Point3d.Add(rightStartPt, rightVec * factor) directionEndPtLeft = rc.Geometry.Point3d.Add(leftStartPt, leftVec * factor) diagonalRight = rc.Geometry.LineCurve(rightStartPt, directionEndPtRight) diagonalLeft = rc.Geometry.LineCurve(leftStartPt, directionEndPtLeft) directionEndPtRight.Z = rightStartPt.Z directionEndPtLeft.Z = rightStartPt.Z horizLineRight = rc.Geometry.LineCurve(rightStartPt, directionEndPtRight) horizLineLeft = rc.Geometry.LineCurve(leftStartPt, directionEndPtLeft) horizLineLeft.Reverse() #VERTICAL LINE riseVec = rc.Geometry.Vector3d(0, 0, riserHeight) topPt = rc.Geometry.Point3d.Add(rightStartPt, riseVec) secLine = rc.Geometry.LineCurve(rightStartPt, leftStartPt) vertLine = rc.Geometry.LineCurve(rightStartPt, topPt) treadList = [diagonalRight, diagonalLeft] underSrf = rc.Geometry.Brep.CreateFromLoft(treadList, rc.Geometry.Point3d.Unset, rc.Geometry.Point3d.Unset, rc.Geometry.LoftType.Normal, False)[0] rightSrf = rc.Geometry.SumSurface.Create(horizLineRight, vertLine) rightBrep = rightSrf.ToBrep() leftSrf = rc.Geometry.SumSurface.Create(horizLineLeft, vertLine) leftBrep = leftSrf.ToBrep() rightTriangles = rightBrep.Trim(underSrf, rs.UnitAbsoluteTolerance()) leftTriangles = leftBrep.Trim(underSrf, rs.UnitAbsoluteTolerance()) print geoList = List[rc.Geometry.Brep]() geoList.Add(underSrf) for rightTriangle in rightTriangles: geoList.Add(rightTriangle) for leftTriangle in leftTriangles: geoList.Add(leftTriangle) brep = rc.Geometry.Brep.JoinBreps(geoList, rs.UnitAbsoluteTolerance())[0] brep.Translate( rc.Geometry.Vector3d(0, 0, landingHeights[i] - riserHeight - thickness)) underSrf.Translate( rc.Geometry.Vector3d(0, 0, landingHeights[i] - riserHeight - thickness)) brep.Flip() dupSrf = landingSrfs[i].Duplicate() dupSrf.Translate(rc.Geometry.Vector3d(0, 0, -thickness)) newSrfs = dupSrf.Trim(brep, rs.UnitAbsoluteTolerance()) for newSrf in newSrfs: newSrf.Flip() underSrf.Join(newSrf, rs.UnitAbsoluteTolerance(), True) #sc.doc.Objects.Add(newSrf) sc.doc.Objects.Add(underSrf) wedges.append(brep) return wedges