def grid(self, sqr, x, y):
xpldCrv = rs.ExplodeCurves(sqr)
rs.ReverseCurve(xpldCrv[0])
rs.ReverseCurve(xpldCrv[3])
crvPoints = []
for i in range(len(xpldCrv)):
curve = xpldCrv[i]
if i % 2 == 0:
crvPoints.append(rs.DivideCurve(curve, x))
else:
crvPoints.append(rs.DivideCurve(curve, y))
#divide up the curve into points based on x and y
#add the resulting points to the curvePoints List. Each of the resulting points sets are a list themsleves
for p1, p2 in zip(crvPoints[0], crvPoints[2]):
#draw a line between p1, p2
print(p1)
#rs.AddLine(p1,p2)
self.penUp()
self.goto(p1[0], p1[1], p1[2])
self.penDown()
self.goto(p2[0], p2[1], p2[2])
for p1, p2 in zip(crvPoints[1], crvPoints[3]):
self.penUp()
l = self.goto(p1[0], p1[1], p1[2])
self.penDown()
self.goto(p2[0], p2[1], p2[2])
def getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66):
segmentCount = int(math.floor(dist / layer_height)) - 1
tmpList = []
fullHeight = []
for i in range(len(crvList)):
extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist)
fullHeight.append(extendedCrv)
domStart, domEnd = rs.CurveDomain(extendedCrv)
trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0))
tmpList.append(trimmedCrv)
tmp = []
###Smooth Curves###
for i in range(len(tmpList)):
bottomPt = rs.CurveEndPoint(tmpList[i])
zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist))
topPt = rs.CopyObject(bottomPt, zVec)
line = rs.AddLine(bottomPt, topPt)
crvPts = rs.DivideCurve(tmpList[i], segmentCount)
LinePts = rs.DivideCurve(line, segmentCount)
for i in range(segmentCount):
tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1],
crvPts[i])
tmpVec = rs.VectorScale(tmpVec, vecMul)
rs.MoveObject(crvPts[i], tmpVec)
tmp.append(rs.AddInterpCurve(crvPts))
result = []
for crv in tmp:
crvLen = rs.CurveLength(crv)
if crvLen < dist:
tmpExt = dist - crvLen
result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt))
else:
result.append(rs.CopyObject(crv))
return result
def Previewmark(crvs, dict, index):# 線の目印を作る pt_o = rs.DivideCurve(crvs[dict[index][0]], 10) pt_x = rs.DivideCurve(crvs[dict[index][1]], 10) mark_o = [rs.AddCircle(cen, mark) for cen in pt_o] mark_x1 = [rs.AddLine((cen[0] - mark,cen[1],cen[2]), (cen[0] + mark,cen[1],cen[2])) for cen in pt_x] mark_x2 = [rs.AddLine((cen[0],cen[1] - mark,cen[2]), (cen[0],cen[1] + mark,cen[2])) for cen in pt_x] a = mark_o b = mark_x1 + mark_x2 return (a, b)
def squareSect(crv,width,height):
sections=[]
divPts=rs.DivideCurve(crv,10)
keep=True
for i in range(len(divPts)):
param=rs.CurveClosestPoint(crv,divPts[i])
tan=rs.CurveTangent(crv,param)
plane=rs.PlaneFromNormal(divPts[i],tan)
sect=rs.AddRectangle(plane,width,height)
cpt=rs.CurveAreaCentroid(sect)[0]
vec=rs.VectorCreate(divPts[i],cpt)
sect=rs.MoveObject(sect,vec)
if i>0:
if testAlign(sect,oldSect)==False:
sect=align(sect,oldSect,divPts[i],tan)
oldSect=sect
sections.append(sect)
branch=rs.AddLoftSrf(sections,None,None,2,0,0,False)
edges=rs.DuplicateEdgeCurves(branch)
if width>height:
testVal=height
else:
testVal=width
for i in range(len(edges)):
testPt=rs.CurveMidPoint(edges[i])
for j in range(len(edges)):
param=rs.CurveClosestPoint(edges[j],testPt)
pt=rs.EvaluateCurve(edges[j],param)
if rs.Distance(pt,testPt)<testVal/6:
keep=False
rs.DeleteObjects(sections)
rs.DeleteObjects(edges)
return branch
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 centerCrv(crv):
sum = [0, 0, 0]
pts = rs.DivideCurve(crv, 1000)
for i in range(len(pts)):
sum = rs.PointAdd(sum, pts[i])
cnt = sum / len(pts)
return cnt
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 surface_discrete_mapping(srf_guid, discretisation, minimum_discretisation = 5, crv_guids = [], pt_guids = []): """Map the boundaries of a Rhino NURBS surface to planar poylines dicretised within some discretisation using the surface UV parameterisation. Curve and point feautres on the surface can be included. Parameters ---------- srf_guid : guid A surface guid. crv_guids : list List of guids of curves on the surface. pt_guids : list List of guids of points on the surface. discretisation : float The discretisation of the surface boundaries. minimum_discretisation : int The minimum discretisation of the surface boundaries. Returns ------- tuple Tuple of the mapped objects: outer boundary, inner boundaries, polyline_features, point_features. """ srf = RhinoSurface.from_guid(srf_guid) # a boundary may be made of multiple boundary components and therefore checking for closeness and joining are necessary mapped_borders = [] for i in [1, 2]: mapped_border = [] for border_guid in srf.borders(type = i): points = [list(srf.point_xyz_to_uv(pt)) + [0.0] for pt in rs.DivideCurve(border_guid, max(int(rs.CurveLength(border_guid) / discretisation) + 1, minimum_discretisation))] if rs.IsCurveClosed(border_guid): points.append(points[0]) mapped_border.append(points) rs.DeleteObject(border_guid) mapped_borders.append(mapped_border) outer_boundaries, inner_boundaries = [network_polylines(Network.from_lines([(u, v) for border in mapped_borders[i] for u, v in pairwise(border)])) for i in [0, 1]] # mapping of the curve features on the surface mapped_curves = [] for crv_guid in crv_guids: curve = RhinoCurve.from_guid(crv_guid) points = [list(srf.point_xyz_to_uv(pt)) + [0.0] for pt in curve.divide(max(int(curve.length() / discretisation) + 1, minimum_discretisation))] if curve.is_closed(): points.append(points[0]) mapped_curves.append(points) polyline_features = network_polylines(Network.from_lines([(u, v) for curve in mapped_curves for u, v in pairwise(curve)])) # mapping of the point features onthe surface point_features = [list(srf.point_xyz_to_uv(rs.PointCoordinates(pt_guid))) + [0.0] for pt_guid in pt_guids] return outer_boundaries[0], inner_boundaries, polyline_features, point_features
def create_targets(mesh, targets, resolution_mult, path, folder_name,
json_name):
""" Creation of targets for curved slicing. """
avg_face_area = max(rs.MeshArea([mesh])) / rs.MeshFaceCount(mesh)
div_num = max(20, int(resolution_mult * avg_face_area))
pts = []
for target in targets:
print(div_num)
pts.extend(rs.DivideCurve(target, div_num))
vs = rs.MeshVertices(mesh)
vertices = []
vertex_indices = []
for p in pts:
closest_vi = get_closest_point_index(p, vs)
if closest_vi not in vertex_indices:
ds_from_targets = [
distance_of_pt_from_crv(vs[closest_vi], target)
for target in targets
]
if min(ds_from_targets) < 0.5: # hardcoded threshold value
vertices.append(vs[closest_vi])
vertex_indices.append(closest_vi)
save_json_file(vertex_indices, path, folder_name, json_name)
return pts, vertices, vertex_indices
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 ColorObjsRandomRange():
try:
objs = rs.GetObjects("Select objects to color",
1073750077,
preselect=True)
if objs is None: return
print "Select First Color"
firstColor = rs.GetColor()
if firstColor is None: return
print "Select Second Color"
secondColor = rs.GetColor(firstColor)
if secondColor is None: return
rs.EnableRedraw(False)
colorLine = rs.AddLine(firstColor, secondColor)
try:
colors = rs.DivideCurve(colorLine, len(objs) - 1)
shuffle(colors)
for i, obj in enumerate(objs):
rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z))
except:
pass
rs.DeleteObject(colorLine)
rs.EnableRedraw(True)
return True
except:
return False
def tweenCurveOnsurface(m, n, icurves, points0, points1):
print {'def'}
print {m}
for icurve in icurves:
ipoints = rs.DivideCurve(icurve, m + 1)
ipointssnm.append(ipoints)
for i in range(m):
icurvesNew = []
ps = []
puvs = []
p = points1[(i + 1)]
puv = ghc.SurfaceClosestPoint(p, surfObj)[1]
puvs.append(puv)
for j in range(n):
#转换数据类型
p = ipointssnm[j][i + 1]
puv = ghc.SurfaceClosestPoint(p, surfObj)[1]
ps.append(p)
puvs.append(puv)
p = points0[i + 1]
puv = ghc.SurfaceClosestPoint(p, surfObj)[1]
puvs.append(puv)
crv = ghc.CurveOnSurface(surfObj, puvs, False)[0]
icurvesNew.append(crv)
print(crv)
return icurvesNew
def find_devisions(mesh, edge_groups, trg_len):
for edges in edge_groups:
lengths = 0
for u, v in edges:
lengths += mesh.get_edge_attribute((u, v), 'length')
ave_len = lengths / len(edges)
div = max((round(ave_len / trg_len, 0), 1))
for u, v in edges:
crv = mesh.get_edge_attribute((u, v), 'guid')
pts = rs.DivideCurve(crv, div)
mesh.set_edge_attribute((u, v), 'points', pts)
edges = set(mesh.edges())
coons_meshes = []
for fkey in mesh.faces():
if mesh.get_face_attribute(fkey, 'opening'):
continue
h_edges = mesh.face_halfedges(fkey)
# arrange point lists in circular order along edge faces
pts_coon = []
for h_edge in h_edges:
pts = mesh.get_edge_attribute(h_edge, 'points')[:]
if not h_edge in edges:
pts.reverse()
if not mesh.get_edge_attribute(h_edge, 'dir'):
pts.reverse()
pts_coon.append(pts)
# handle triangles correctly based on user input (flag 0 - 2)
if len(h_edges) == 4:
ab, bc, dc, ad = pts_coon
else:
flag = mesh.get_face_attribute(fkey, 'corner')
if flag == 0:
ab, bc, dc, ad = pts_coon[0], pts_coon[1], [], pts_coon[2]
elif flag == 1:
ab, bc, dc, ad = pts_coon[0], [], pts_coon[1], pts_coon[2]
elif flag == 2:
ab, bc, dc, ad = pts_coon[0], pts_coon[1], pts_coon[2], []
# reverse for coons patch (see parameters)
dc.reverse()
ad.reverse()
try: #this try except is a bit of a hack to make the openings work (needs revision)
vertices, faces = discrete_coons_patch(ab, bc, dc, ad)
coons_meshes.append(Mesh.from_vertices_and_faces(vertices, faces))
except:
pass
return coons_meshes
def crv2pts(self, crvList, startLayer=1):
result = []
print(self.resolution, len(crvList))
for i in range(startLayer, len(crvList)):
pts = rs.DivideCurve(crvList[i], self.resolution)
result.extend(pts)
print(len(result))
return result
def divEQCrvToPolyAD(crv,w=900,adjacentCrvs=None):
outpoly=PolyAD()
crvLen=rs.CurveLength(crv)
numDiv=crvLen/w
width=crvLen/round(numDiv)
pts=rs.DivideCurve(crv,numDiv,False,True)
#add to output
outpoly.points=pts
sharedNormals=[None,None]
if adjacentCrvs is not None:
sharedNormals=findSharedbisecNormals(crv,adjacentCrvs)
for i in range(0,len(pts)-2):
up=(0,0,1)
# direct direct_end
# (p0)-v1->(p1)-v2->(p2)
# |n_start |n |n_end
# V V V
p0=pts[i]
p1=pts[i+1]
p2=pts[i+2]
v1=rs.VectorUnitize(p1-p0)
v2=rs.VectorUnitize(p2-p1)
n1=rs.VectorCrossProduct(v1,up)
n2=rs.VectorCrossProduct(v2,up)
mid=rs.VectorAdd(n1,n2)
n=rs.VectorUnitize(mid)
direct=p1-p0
#add to output
outpoly.directions.append(direct)
if i==0:
if sharedNormals[0] is not None: n_start=sharedNormals[0]
else: n_start=rs.VectorCrossProduct(v1,up)
outpoly.normals.append(n_start)
#add to output
outpoly.normals.append(n)
if i==len(pts)-3:
if sharedNormals[1] is not None: n_end=sharedNormals[1]
else: n_end=rs.VectorCrossProduct(v2,up)
outpoly.normals.append(n_end)
direct_end=p2-p1
outpoly.directions.append(direct_end)
return outpoly
def main():
surface_id = rs.GetObject("Select a surface to sample", 8, True)#select surface
if not surface_id: return #if not surface, it will not continue
curve_id = rs.GetObject("Select a curve to measure", 4, True, True)#select curve
if not curve_id: return #if not curve, it will not continue
points = rs.DivideCurve(curve_id, 500) #divide curve in 500 Segments
rs.EnableRedraw(False)
for point in points: evaluatedeviation(surface_id, 5.0, point)#calls evaluatedeviation function
rs.EnableRedraw(True)
def divideCurve(crv):
aRating = rs.GetInteger("What level of accuracy do you want? (1-10)", 1, 1,
10)
divPoints = aRating / 5 * 200
divPoints = int(divPoints)
points = rs.DivideCurve(crv,
divPoints,
create_points=False,
return_points=True)
return points
def curve_discretisation(curve_guid, discretisation_spacing):
points = []
n = int(rs.CurveLength(curve_guid) / discretisation_spacing) + 1
curve_guids = rs.ExplodeCurves(curve_guid, delete_input=True)
if len(curve_guids) == 0:
points += rs.DivideCurve(curve_guid, n)
if rs.IsCurveClosed(curve_guid):
points.append(points[0])
else:
for guid in curve_guids:
points += rs.DivideCurve(guid, n)[:-1]
pts = rs.DivideCurve(curve_guids[-1], n)
points.append(pts[-1])
rs.DeleteObjects(curve_guids)
return rs.AddPolyline(points)
def main():
surface_id = rs.GetObject("Select a surface to sample", 8, True)
if not surface_id: return
curve_id = rs.GetObject("Select a curve to measure", 4, True, True)
if not curve_id: return
points = rs.DivideCurve(curve_id, 500)
rs.EnableRedraw(False)
for point in points: evaluatedeviation(surface_id, 1.0, point)
rs.EnableRedraw(True)
def divide(self, number_of_segments, over_space=False): points = [] rs.EnableRedraw(False) if over_space: space = self.space(number_of_segments + 1) if space: points = [list(rs.EvaluateCurve(self.guid, param)) for param in space] else: points = rs.DivideCurve(self.guid, number_of_segments, create_points=False, return_points=True) points[:] = map(list, points) rs.EnableRedraw(True) return points
def get_boundary_points(crvs_bound,trg_len):
crvs = rs.ExplodeCurves(crvs_bound,True)
if not crvs: crvs = [crvs_bound]
div_pts = []
for crv in crvs:
div = round(rs.CurveLength(crv)/trg_len,0)
if div < 1: div = 1
pts = rs.DivideCurve(crv,div)
div_pts += pts
div_pts = rs.CullDuplicatePoints(div_pts)
if crvs: rs.DeleteObjects(crvs)
return div_pts
def divide_crvs(crvs, div_count):
points_div = []
for i in xrange(len(crvs)):
tmp_pts = rs.DivideCurve(crvs[i], div_count)
points_div.append(tmp_pts)
# print points_div
# print len(points_div)
# print len(points_div[0])
### 2D Array
return points_div
def OffsetCurve(self, level_cut):
check_presision = 10
offset_type = 1
branched_curves = []
main_curve = level_cut
offset_distance = self.general_input["cut_diam"] * self.input_data[
"xy_dist"]
curve_1 = rs.OffsetCurve(main_curve,
rs.CurveAreaCentroid(main_curve)[0], -.1,
None, offset_type)
curve_2 = rs.OffsetCurve(main_curve,
rs.CurveAreaCentroid(main_curve)[0], .1, None,
offset_type)
if curve_1 and curve_2:
if len(curve_1) != 1 or len(curve_2) != 1:
rs.DeleteObjects(curve_1)
rs.DeleteObjects(curve_2)
return branched_curves
mini_test = self.getSmall(curve_1, curve_2)
do_points = rs.DivideCurve(mini_test, check_presision, False)
rs.DeleteObjects([curve_1, curve_2])
do_points.append(rs.CurveAreaCentroid(main_curve)[0])
for i in range(0, len(do_points)):
new_offset_curve = rs.OffsetCurve(main_curve, do_points[i],
offset_distance, None,
offset_type)
try:
if self.isCurveNew(branched_curves,
new_offset_curve) and rs.IsCurveClosed(
new_offset_curve) and self.isSmall(
new_offset_curve, main_curve):
branched_curves.append(new_offset_curve)
else:
rs.DeleteObject(new_offset_curve)
except:
if new_offset_curve:
rs.DeleteObjects(new_offset_curve)
for curve in branched_curves:
rs.ObjectColor(curve, color_palette["cut"])
if not branched_curves or len(branched_curves) > 1:
branched_curves.append("sec_plane")
return branched_curves
def MakeSectionPreview(line, size): arrow = []# 目印を格納するリスト for i in range(len(line)): vec_x = rs.VectorCreate(rs.CurveStartPoint(line[i]), rs.CurveEndPoint(line[i])) vec_y = rs.VectorUnitize(rs.VectorCrossProduct(vec_x, [0,0,1])) pt3 = rs.DivideCurve(line[i], size) seglen = rs.Distance(pt3[0], pt3[1]) tri_s = [rs.AddPoint(pt3[i]) for i in range(3)] tri_e = [rs.AddPoint(pt3[len(pt3) - i]) for i in range(1, 4)] rs.MoveObject(tri_s[1], vec_y * (seglen * sqrt(3))) rs.MoveObject(tri_e[1], vec_y * (seglen * sqrt(3))) arrow.append(rs.AddInterpCurve(rs.coerce3dpointlist(tri_s), 1)) arrow.append(rs.AddInterpCurve(rs.coerce3dpointlist(tri_e), 1)) return arrow
def DivideCurveByNumberAndRatio(curve, n, ratio):
# 根据分段数和比例分段，弧长，含端点
if ratio == 1:
return rs.DivideCurve(curve, n)
n = int(n)
points = []
L = rs.CurveLength(curve)
curveStartPoint = rs.CurveStartPoint(curve)
curveEndPoint = rs.CurveEndPoint(curve)
lengths = []
length0 = L * (1 - ratio) / (1 - ratio**n)
# print "length0,ratio",length0,ratio
lengths = list(
(length0 * (1 - ratio**(i)) / (1 - ratio)) for i in range(n + 1))
return DivideCurveByLengths(curve, lengths)
def resample_curve(self, le):
try:
# rs_poly = rs.AddPolyline(self.polyline.points)
crv = rs.AddInterpCurve(self.polyline.points)
if le <= self.polyline.length:
a = rs.DivideCurveLength(crv, le, False)
div = rs.DivideCurveLength(crv, le, False, False)
new_pts = rs.DivideCurve(crv, len(div), False, True)
new_par = rs.DivideCurve(crv, len(div), False, False)
else:
print('it is a line!')
new_pts = [rs.CurveStartPoint(crv), rs.CurveEndPoint(crv)]
new_par = [0.0, rs.CurveLength(crv)]
out_pts = []
out_vec = []
for idx, pt in enumerate(new_pts):
pt = [pt.X, pt.Y, pt.Z]
v = rs.CurveTangent(crv, new_par[idx])
vec = [v.X, v.Y, v.Z]
# vec = compas.geometry.normalize_vector(vec)
out_pts.append(pt)
out_vec.append(vec)
# print('succesfully resampled')
return out_pts, out_vec
except Exception:
print('Interpolated Curve could not be resampled.')
return None, None
def extractCrvs(crvs, reso, dir):
f = open(dir, 'w')
for i in range(len(crvs)):
divPts = rs.DivideCurve(crvs[i], reso)
for j in range(len(divPts)):
pt = divPts[j]
f.write(str(pt[0]))
f.write(',')
f.write(str(pt[1]))
f.write(',')
f.write(str(pt[2]))
if j < len(divPts) - 1:
f.write(' ')
if i < len(crvs) - 1:
f.write('\n')
f.close()
def __init__(self, O):
self.site = O
self.add_pts = []
self.pts = rs.DivideCurve(O, 100)
b = rs.BoundingBox(self.site)
poly = rs.AddPolyline([b[0], b[1], b[2], b[3], b[0]])
div = 10
u = int((b[1][0] - b[0][0]) / div)
v = int((b[2][1] - b[1][1]) / div)
for i in range(int(b[0][0]), int(b[1][0]), u):
for j in range(int(b[1][1]), int(b[2][1]), v):
p = [i, j, 0]
if (rs.PointInPlanarClosedCurve(p, self.site) != 0):
#self.add_pts.append(p)
self.pts.append(p)
rs.DeleteObject(poly)
def getExtendedTP(self, crvList, dist=50, layer_height=2.5):
result = []
ptsList = []
lenList = []
segmentCount = math.floor(dist / layer_height)
for crv in crvList:
tmp = rs.DivideCurve(crv, segmentCount)
lenList.append(len(tmp))
ptsList.append(tmp)
for i in range(min(lenList)):
tmp = []
for j in range(len(ptsList)):
tmp.append(ptsList[j][i])
tmp.append(ptsList[0][i])
tmpCrv = rs.AddInterpCurve(tmp, knotstyle=3)
result.append(tmpCrv)
result.reverse()
return result
def DivideCurves(curves, NumberOfPoints, treeOut):
# gorbe felosztasa, pontok listaba es faba rendezese
pathNum = 0
for i in range(curves.BranchCount):
treeBranch = curves.Branch(i)
treePath = curves.Path(i)
for j in range(len(treeBranch)):
PointsPerCurve = rs.DivideCurve(treeBranch[j],
NumberOfPoints, True, True)
NumOfPtCrv = len(PointsPerCurve)
path = ghpath(treePath.AppendElement(j))
loopNum = 0
while (loopNum < NumOfPtCrv):
treeOut.Add(PointsPerCurve[loopNum], path)
loopNum = loopNum + 1
