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
