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
