def EndingCap(stuff1, stuff2):
plyu = ChainLink(stuff1[0][0], stuff1[0][1])
plyd = ChainLink(stuff1[1][0], stuff1[1][1])
#a = Pts2List(plyu)
#b = Pts2List(plyd)
a = PurgePoly(plyu)
b = PurgePoly(plyd)
#polu = Rhino.Geometry.Polyline(a)
#pold = Rhino.Geometry.Polyline(b)
polu = rs.AddPolyline(a)
pold = rs.AddPolyline(b)
up = rs.AddPlanarSrf([polu])
down = rs.AddPlanarSrf([pold])
#rs.AddPoints([stuff2[0][0][len(stuff2[0][0])-1],stuff1[0][0][0],stuff1[0][1][0],stuff2[0][1][len(stuff2[0][1])-1]])
#rs.AddPoints([stuff2[1][0][len(stuff2[1][0])-1],stuff1[1][0][0],stuff1[1][1][0],stuff2[1][1][len(stuff2[1][1])-1]])
uplink = rs.AddSrfPt([
stuff2[0][0][len(stuff2[0][0]) - 1], stuff1[0][0][0], stuff1[0][1][0],
stuff2[0][1][len(stuff2[0][1]) - 1]
])
downlink = rs.AddSrfPt([
stuff2[1][0][len(stuff2[1][0]) - 1], stuff1[1][0][0], stuff1[1][1][0],
stuff2[1][1][len(stuff2[1][1]) - 1]
])
rs.DeleteObjects([polu, pold])
return [[uplink, up[0]], [downlink, down[0]]]
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 CockpitWindowContours(Height=1.620, Depth=5):
P1 = [0.000, 0.076, Height - 1.620 + 2.194]
P2 = [0.000, 0.852, Height - 1.620 + 2.290]
P3 = [0.000, 0.904, Height + 0.037]
P4 = [0.000, 0.076, Height]
CWC1 = rs.AddPolyline([P1, P2, P3, P4, P1])
rs.SelectObject(CWC1)
rs.Command("_FilletCorners 0.08 ")
P1 = [0.000, 0.951, Height - 1.620 + 2.289]
P2 = [0.000, 1.343, Height - 1.620 + 2.224]
P3 = [0.000, 1.634, Height - 1.620 + 1.773]
P4 = [0.000, 1.557, Height - 1.620 + 1.588]
P5 = [0.000, 1.027, Height - 1.620 + 1.671]
CWC2 = rs.AddPolyline([P1, P2, P3, P4, P5, P1])
rs.SelectObject(CWC2)
rs.Command("_FilletCorners 0.08 ")
CWC3 = act.MirrorObjectXZ(CWC1)
CWC4 = act.MirrorObjectXZ(CWC2)
ExtPathId = rs.AddLine([0, 0, 0], [Depth, 0, 0])
CWC1s = rs.ExtrudeCurve(CWC1, ExtPathId)
CWC2s = rs.ExtrudeCurve(CWC2, ExtPathId)
CWC3s = rs.ExtrudeCurve(CWC3, ExtPathId)
CWC4s = rs.ExtrudeCurve(CWC4, ExtPathId)
rs.DeleteObjects([CWC1, CWC2, CWC3, CWC4, ExtPathId])
return CWC1s, CWC2s, CWC3s, CWC4s
def EltCap(stuff1, stuff2):
plyu = ChainLink(stuff1[0][0], stuff1[0][1])
plyd = ChainLink(stuff1[1][0], stuff1[1][1])
a = PurgePoly(plyu)
b = PurgePoly(plyd)
polu = rs.AddPolyline(a)
pold = rs.AddPolyline(b)
up = rs.AddPlanarSrf([polu])
down = rs.AddPlanarSrf([pold])
uptransition = [
stuff2[0][0][len(stuff2[0][0]) - 1], stuff1[0][0][0], stuff1[0][1][0],
stuff2[0][1][len(stuff2[0][1]) - 1]
]
dntransition = [
stuff2[1][0][len(stuff2[1][0]) - 1], stuff1[1][0][0], stuff1[1][1][0],
stuff2[1][1][len(stuff2[1][1]) - 1]
]
#rs.AddPoints(uptransition)
#rs.AddPoints(dntransition)
uplink = rs.AddSrfPt(uptransition)
downlink = rs.AddSrfPt(dntransition)
rs.DeleteObjects([polu, pold])
return [[uplink, up[0]], [downlink, down[0]]]
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 create_pipe(self, point_n, point_p):
outer_point_n = self.create_scaled_point(point_n, self.PIPE_SCALAR)
outer_point_p = self.create_scaled_point(point_p, self.PIPE_SCALAR)
inner_point_n = self.create_scaled_point(point_n,
self.INNER_PIPE_SCALAR)
inner_point_p = self.create_scaled_point(point_p,
self.INNER_PIPE_SCALAR)
opl = rs.AddPolyline([outer_point_p, self.middle_point, outer_point_n])
ipl = rs.AddPolyline([inner_point_p, self.middle_point, inner_point_n])
o_pipe = rs.AddPipe(opl, 0, self.CIRCLE_WIDTH, 1, 1)
i_pipe = rs.AddPipe(ipl, 0, self.CIRCLE_INNER_WIDTH, 1, 1)
return rs.BooleanUnion([o_pipe, i_pipe])
def genFuncObj_Site(self):
s = site_obj(self.site)
pts = s.getPts()
s.displayPts()
poly_list = []
for i in self.req_obj:
for j in range(i.getNumber()):
obj = i
T = False
k = 0
this_gen_poly = None
while (T == False and k < 50):
x = random.randint(1, len(pts) - 2)
p = pts[x - 1]
q = pts[x]
r = pts[x + 1]
poly = obj.getConfig1(p, q, r)
sum = 0
if (poly is not None and len(poly) > 0):
sum = 0
if (poly_list and len(poly_list) > 0):
for m in poly_list:
polyY = rs.AddPolyline(m)
G = self.checkPoly(poly, polyY)
rs.DeleteObject(polyY)
if (G == False):
sum += 1
break
if (sum == 0):
T = True
if (poly not in poly_list):
this_gen_poly = poly
poly_list.append(poly)
elif (poly is not None and len(poly) > 0):
if (poly not in poly_list):
this_gen_poly = poly
poly_list.append(poly)
k += 1
if (this_gen_poly is not None):
i.setGenPoly(rs.AddPolyline(this_gen_poly))
for i in self.req_obj:
poly = i.getGenPoly()
num_flrs = i.getNumFloors()
num_crvs = len(i.getGenPoly())
fin_num_flrs = int(num_flrs / num_crvs)
i.setNumFloors(fin_num_flrs)
for j in poly:
i.genIntPoly(j)
npoly = i.getReqPoly()
for k in range(fin_num_flrs):
rs.CopyObjects(npoly, [0, 0, 4 * k])
pass
def subd(pol, ratio):
pts = rs.PolylineVertices(pol)
vec = rs.VectorCreate(pts[2], pts[1])
vec = rs.VectorScale(vec, ratio)
midPt = rs.VectorAdd(pts[1], vec)
pts1 = [pts[0], pts[1], midPt, pts[0]]
pts2 = [pts[0], midPt, pts[2], pts[0]]
triangle1 = rs.AddPolyline(pts1)
triangle2 = rs.AddPolyline(pts2)
def StartCap(stuff):
plyu = [stuff[0][0][0],stuff[0][0][1],stuff[0][1][1],stuff[0][1][0]]
plyd = [stuff[1][0][0],stuff[1][0][1],stuff[1][1][1],stuff[1][1][0]]
polu = rs.AddPolyline(plyu)
pold = rs.AddPolyline(plyd)
up = rs.AddPlanarSrf([polu])
down = rs.AddPlanarSrf([pold])
rs.DeleteObjects([polu,pold])
return [[up[0]],[down[0]]]
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 addJoin(lns, nJoins, xThick, yThick):
joins = []
joins_3 = []
points = rs.DivideCurve(lns, nJoins)
lenP = len(points)
for i in range(lenP):
joins.append(rs.AddPoint(points[i]))
joins_2 = rs.CopyObjects(joins, [xThick, yThick, 0])
joins_2.remove(joins_2[0])
joins_2.append([0, 0, 0])
for j in range(0, len(joins), 2):
c = j + 2
addList(joins, joins_2, joins_3, j, c)
joins_3.remove(joins_3[len(joins_3) - 1])
joins_3.remove(joins_3[len(joins_3) - 1])
joined = rs.AddPolyline(joins_3)
rs.DeleteObject(lns)
return joined
def drawEvaluateValue(list_evaluate):
frame = 5000
original_point = 5000
step_x_axis = 100
plane = rs.WorldXYPlane()
xform = rs.XformTranslation([0, 5000, 0])
plane1 = rs.PlaneTransform(plane, xform)
rs.AddRectangle(plane1, frame, frame)
evaluate_sum = []
for i in range(len(list_evaluate)):
evaluate_sum.append(sum(list_evaluate[i]))
max_value = max(evaluate_sum)
min_value = min(evaluate_sum)
# if 1000 > max_value > 100:
#
# if 10000 > max_value >= 1000:
point_list = []
for i in range(len(evaluate_sum)):
value = evaluate_sum[i]
# print("evaluate_sum", evaluate_sum[i])
new_value = remap(value, max_value, 0, 5000, 0)
# print("new_value", new_value)
pt = rs.AddPoint(i * step_x_axis, original_point + new_value, 0)
point_list.append(pt)
rs.AddPolyline(point_list)
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 get_pocket_entry(self, z_level, translation, pocket_list):
revised_list = []
last_obj = None
for obj in pocket_list:
if obj != "sec_plane":
revised_list.append(rs.CopyObject(obj, translation))
else:
if last_obj != obj:
revised_list.append(obj)
last_obj = obj
pocket_list = revised_list
for i in range(0, len(pocket_list)):
crv = pocket_list[i]
if crv == "sec_plane": #Cambio intermedio
pep = rs.CurveEndPoint(pocket_list[i - 1])
try:
nsp = rs.CurveStartPoint(pocket_list[i + 1])
except:
npt = rs.CurveStartPoint(self.cut_curve)
nsp = (npt[0], npt[1], z_level)
points = [
rs.CurveEndPoint(pocket_list[i - 1]),
(pep[0], pep[1], self.general_input["sec_plane"]),
(nsp[0], nsp[1], self.general_input["sec_plane"]), nsp
]
travel_line = rs.AddPolyline(points)
rs.ObjectColor(travel_line, color_palette["cut"])
pocket_list[i] = travel_line
return pocket_list
def wave_line(values, r, in_d):
### interpolation dist
# inter_dist = 4 * 0.5
inter_dist = in_d
for i in xrange(len(values)):
tmp_pt = rs.AddPoint(values[i], i * r, 0)
tmp_pt_m = rs.MirrorObject(tmp_pt, (0, 0, 0), (0, 10, 0), True)
# zigzag
if i % 2 == 0:
tmp_pt_0 = rs.CopyObject(tmp_pt)
tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0))
tmp_pt_1 = rs.CopyObject(tmp_pt)
tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0))
zigzag.append(tmp_pt_0)
zigzag.append(tmp_pt_1)
else:
tmp_pt_0 = rs.CopyObject(tmp_pt_m)
tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0))
tmp_pt_1 = rs.CopyObject(tmp_pt_m)
tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0))
zigzag.append(tmp_pt_0)
zigzag.append(tmp_pt_1)
tmp_polyline = rs.AddPolyline(zigzag)
return zigzag, tmp_polyline
def tool_visualization(origin_coords, mesh, planes, i):
""" Visualize example tool motion. """
i = min(i,
len(planes) -
1) # make sure i doesn't go beyond available number of planes
passed_path = None
assert planes[0], 'The planes you have provided are invalid.'
origin = [
float(origin_coords[0]),
float(origin_coords[1]),
float(origin_coords[2])
]
o = rg.Point3d(origin[0], origin[1], origin[2])
x = rg.Vector3d(1, 0, 0)
y = rg.Vector3d(0, -1, 0)
# z = rg.Vector3d(0, 0, -1)
ee_frame = rg.Plane(o, x, y)
target_frame = planes[i]
T = rg.Transform.PlaneToPlane(ee_frame, target_frame)
mesh = rs.TransformObject(rs.CopyObject(mesh), T)
passed_path = rs.AddPolyline([plane.Origin for plane in planes[:i + 1]])
return mesh, passed_path
def taxicab_midnormal(Point_1=P3(0, 0, 0), Point_2=P3(0, 0, 0), leng=10000):
dx = abs(Point_1.X - Point_2.X)
dy = abs(Point_1.Y - Point_2.Y)
C = P3((Point_1.X + Point_2.X) / 2, (Point_1.Y + Point_2.Y) / 2,
(Point_1.Z + Point_2.Z) / 2)
""" MPQN, in which M is on the lengeft(X-) or bottom(Y-) """
P = P3(0, 0, C.Z)
Q = P3(0, 0, C.Z)
M = P3(0, 0, C.Z)
N = P3(0, 0, C.Z)
if dx > dy:
P.Y = C.Y + dy / 2
Q.Y = C.Y - dy / 2
M.Y = P.Y + leng
N.Y = Q.Y - leng
if bool(Point_1.Y > Point_2.Y) ^ bool(Point_1.X > Point_2.X):
P.X = C.X + dy / 2
Q.X = C.X - dy / 2
else:
P.X = C.X - dy / 2
Q.X = C.X + dy / 2
M.X = P.X
N.X = Q.X
else:
if dx < dy:
P.X = C.X + dx / 2
Q.X = C.X - dx / 2
M.X = P.X + leng
N.X = Q.X - leng
if bool(Point_1.Y > Point_2.Y) ^ bool(Point_1.X > Point_2.X):
P.Y = C.Y + dx / 2
Q.Y = C.Y - dx / 2
else:
P.Y = C.Y - dx / 2
Q.Y = C.Y + dx / 2
M.Y = P.Y
N.Y = Q.Y
else:
if bool(Point_1.Y > Point_2.Y) ^ bool(Point_1.X > Point_2.X):
P.Y = C.Y - dx / 2
Q.Y = C.Y + dx / 2
P.X = C.X - dy / 2
Q.X = C.X + dy / 2
M.Y = P.Y - leng
M.X = P.X - leng
N.Y = Q.Y + leng
N.X = Q.X + leng
else:
P.Y = C.Y - dx / 2
Q.Y = C.Y + dx / 2
P.X = C.X + dy / 2
Q.X = C.X - dy / 2
M.Y = P.Y - leng
M.X = P.X + leng
N.Y = Q.Y + leng
N.X = Q.X - leng
return rs.AddPolyline([M, P, Q, N])
def SaveNClean(defject, vertices, i, content):
#save all there is to run from current iteration and clean up proper
rs.Command("_SelNone")
rs.Command("_SelPolysrf")
index = i
if index < 10:
j = "0" + str(index)
if index >= 10:
j = index
#Quite probably there is a purely scripted way of writing the export now
#It would be through the Rhino and scriptcontext
rs.Command("_-Export C:\R3\OffCenter\Walk\Temp\proto2o" + j + ".igs ENTER")
rs.DeleteObject(defject)
for vrtx in vertices:
rs.AddPolyline(vrtx)
#Again
rs.Command("-saveas C:\\R3\OffCenter\Walk\Temp\sth" + j + ".3dm")
objects = rs.AllObjects()
rs.DeleteObjects(objects)
#need a place to write our polies to!!!
History.WritePolies(tempfolder + "\polies" + j + ".txt", content)
def drawRect( side, location, angle_degrees ):
"""画一个2D方块
参数:
side(double): 方块的长度, double
locaiton(tuple(double, double,double)): 方块中心的位置
angle_degrees(double): 旋转角度degree
Returns:
guid
"""
p0 = (-side/2,-side/2,0)
p1 = (side/2,-side/2,0)
p2 = (side/2,side/2,0)
p3 = (-side/2,side/2,0)
obj = rs.AddPolyline([p0,p1,p2,p3,p0])
xform = rs.XformRotation2(angle_degrees, (0,0,1), (0,0,0))
obj = rs.TransformObject( obj, xform, False )
xform = rs.XformTranslation( location)
obj = rs.TransformObject( obj, xform, False )
return obj
def drawTriTab(self, net):
holeRadius = net.holeRadius
mesh = net.mesh
flatVerts = net.flatVerts
flatFaces = net.flatFaces
minArea = (holeRadius**2.0) * math.pi * 30
# print "minArea: " + str(minArea)
flatFace = self.getConnectToFace(flatFaces, mesh)
area = flatFace.getArea(flatVerts)
pntA, pntC = self.get_coordinates(island)
pntB = self.tabFaceCenter
points = [pntA, pntB, pntC]
polyline = Rhino.Geometry.PolylineCurve([pntA, pntB, pntC, pntA])
props = Rhino.Geometry.AreaMassProperties.Compute(polyline)
if area > minArea:
centerPnt = props.Centroid
else:
rs.AddTextDot("o", pntB)
centerPnt = flatFaces[self.fromFace].getCenterPoint(
flatVerts, True)
hole = rs.AddCircle(centerPnt, holeRadius)
polyGuid = rs.AddPolyline(points)
self.geom.append(polyGuid)
self.geom.append(hole)
return polyGuid
def create_end_caps(self, corners, vector):
srf = rs.AddPolyline(
[corners[0], corners[1], corners[2], corners[3], corners[0]])
curve = rs.AddCurve(
[corners[0],
rs.PointAdd(corners[0], rs.VectorScale(vector, 3))])
return rs.AddSweep1(curve, [srf])
def drawQuadTab(self, island):
pntA, pntD = self.get_coordinates(island)
vecA = geom.Vector3d(pntA)
vecD = geom.Vector3d(pntD)
alpha = self.tabAngles[0]
beta = self.tabAngles[1]
lenI = self.tabWidth / math.sin(alpha * math.pi / 180.0)
lenJ = self.tabWidth / math.sin(beta * math.pi / 180.0)
if not self.tabOnLeft:
alpha = -1 * alpha
beta = -1 * beta
vec = vecD.Subtract(vecD, vecA)
vecUnit = rs.VectorUnitize(vec)
vecI = rs.VectorScale(vecUnit, lenI)
vecJ = rs.VectorScale(vecUnit, -lenJ)
vecI = rs.VectorRotate(vecI, alpha, [0, 0, 1])
vecJ = rs.VectorRotate(vecJ, -beta, [0, 0, 1])
vecB = vecA + vecI
vecC = vecD + vecJ
pntB = geom.Point3d(vecB)
pntC = geom.Point3d(vecC)
points = [pntA, pntB, pntC, pntD]
polyGuid = rs.AddPolyline(points)
self.geom.append(polyGuid)
return polyGuid
def drawTruncatedTab(self, island):
flatVerts = island.flatVerts
tabLen = self.tabWidth
I, J = self.get_coordinates(island)
K = self.tabFaceCenter
if self.tabFaceCenter is None: # this is ahack: TODO: if a new cut edge is created, give it a tabFaceCenter
return
diagA = Rhino.Geometry.Line(I, K)
diagB = Rhino.Geometry.Line(J, K)
offsetLine, vecA = getOffset((I, J), K, tabLen, True)
resultI, aI, bI = Rhino.Geometry.Intersect.Intersection.LineLine(
offsetLine, diagA)
resultJ, aJ, bJ = Rhino.Geometry.Intersect.Intersection.LineLine(
offsetLine, diagB)
if resultI and resultJ:
intersectPntI = offsetLine.PointAt(aI)
intersectPntJ = offsetLine.PointAt(aJ)
shorterThanTab = self.checkIfShortTab(flatVerts)
if shorterThanTab == 1:
# flip order to avoid self-intersction
points = [I, K, J]
elif shorterThanTab == 0:
points = [I, K, J]
elif shorterThanTab == -1:
points = [I, intersectPntI, intersectPntJ,
J] # order is as expected
else:
points = [I, K, J]
polyGuid = rs.AddPolyline(points)
self.geom.append(polyGuid)
return polyGuid
def meshSwipPolyAlongPoly(profile, rail):
profile = rs.CopyObject(profile)
pts = rs.CurveEditPoints(rail)
baseVect = Rhino.Geometry.Point3d(0, 1, 0)
meshes = []
for i in range(0, len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
rv1 = rs.VectorUnitize(p0 - p1)
vect = p1 - p0
mid = rs.VectorUnitize((rv1 + v2) / 2)
np = p1 + mid
up = p1 + Rhino.Geometry.Point3d(0, 0, 1)
pln = rs.PlaneFromPoints(p1, np, up)
mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln)
meshes.append(mesh)
rs.DeleteObject(profile)
profile = rs.AddPolyline(pjpts)
mesh = rs.JoinMeshes(meshes, True)
rs.DeleteObject(profile)
return mesh
def update(self):
print('update')
#delete last generated objects
try:
rs.DeleteObjects(self.generatedObjs)
self.generatedObjs = []
except:
print('exception in delete generated object')
divWidth = 600
crv = self.baseCrv
if not rs.IsObject(crv):
print('crv is not an object')
return
if not rs.IsPolyline(crv):
pts = rs.DivideCurveEquidistant(crv, divWidth)
rail = rs.AddPolyline(pts)
else:
rail = rs.CopyObject(crv)
pts = rs.CurveEditPoints(rail)
if len(pts) < 3:
print('too little points')
return
#find vectors to move and orient the profile
vect = pts[1] - pts[0]
vect = rs.VectorUnitize(vect)
a = rs.VectorAngle(vect, (0, 1, 0)) - 90
#load the component
path = self.loadPath
component = None
try:
component = importComponent(path)
except:
print('exception on importing module')
if component is None:
print('component is None')
return None
#rs.MoveObjects(component.breps,pts[0])
#rs.RotateObjects(component.breps,pts[0],a)
for b in component.breps:
self.generatedObjs.append(b)
oriented = orientObjAlongPolyPts(b, pts)
print('pts count:', len(pts), ' num gen:', len(oriented))
rs.MoveObjects(component.polys, pts[0])
rs.RotateObjects(component.polys, pts[0], a)
for c in component.polys:
self.generatedObjs.append(c)
mesh = meshSwipPolyAlongPoly(c, rail)
self.generatedObjs.append(mesh)
rs.DeleteObject(rail)
print('generated obj count:', len(self.generatedObjs))
rs.AddGroup('gen')
rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def crackpolygon(pls, count):
temppls = pls
pls = []
if count == 0:
return 1
else:
for pl in temppls:
if rs.CloseCurve(pl) == False:
print
"Not a closed curve"
else:
# print "Cool"
centroid = rs.CurveAreaCentroid(pl)
centpt = rs.AddPoint(centroid[0])
curves = rs.ExplodeCurves(pl)
for crv in curves:
# print crv
pt1 = rs.CurveStartPoint(crv)
pt2 = rs.CurveEndPoint(crv)
pts = []
pts.append(pt1)
pts.append(pt2)
pts.append(centpt)
pts.append(pt1)
newpl = rs.AddPolyline(pts)
pls.append(newpl)
rs.DeleteObject(crv)
cleanup = []
cleanup.append(centpt)
# cleanup.append(curves)
rs.DeleteObjects(cleanup)
count = count - 1
return crackpolygon(pls, count)
def plot(self):
points = []
for i in range(len(self.gaussKernel)):
x = i * self.gStepSize
y = self.gaussKernel[i]
points.append([x, y, 0])
#rs.AddPoint(x,y,0)
rs.AddPolyline(points)
def EndingCap(stuff1,stuff2):
plyu = ChainLink(stuff1[0][0],stuff1[0][1])
plyd = ChainLink(stuff1[1][0],stuff1[1][1])
polu = rs.AddPolyline(plyu)
pold = rs.AddPolyline(plyd)
up = rs.AddPlanarSrf([polu])
down = rs.AddPlanarSrf([pold])
uplink = rs.AddSrfPt([stuff2[0][0][len(stuff2[0][0])],stuff1[0][0][0],stuff1[0][1][0],stuff2[0][1][len(stuff2[0][1])]])
downlink = rs.AddSrfPt([stuff2[1][0][len(stuff2[1][0])],stuff1[1][0][0],stuff1[1][1][0],stuff2[1][1][len(stuff2[1][1])]])
rs.DeleteObjects([polu,pold])
return [[uplink,up[0]],[downlink,down[0]]]
def drawTriangle(self, t, vertex):
v1 = vertex[t[0]]
v2 = vertex[t[1]]
v3 = vertex[t[2]]
if len(v1) == 2: v1.append(0)
if len(v2) == 2: v2.append(0)
if len(v3) == 2: v3.append(0)
crv = rs.AddPolyline([v1, v2, v3, v1])
return crv
def addWallRhino(corners, thickness, height):
outWallCrv = rs.AddPolyline(corners)
inWallCrv = rs.OffsetCurve(outWallCrv, [0,1,0], thickness, [0,0,1], CurveOffsetCornerStyle.Sharp)
objs = [outWallCrv, inWallCrv]
btmWall = rs.AddPlanarSrf(objs)[0]
extrudeLine = rs.AddLine(corners[0],map(sum, zip(corners[0],[0,0,height])))
allWalls = rs.ExtrudeSurface(btmWall, extrudeLine, True)
rs.DeleteObjects([outWallCrv,inWallCrv,btmWall,extrudeLine])
return allWalls
