def fillet_lines(self):
self.lines = []
for i in range(0, len(self.line_lists)):
fillets = []
new_line = []
for j in range(0, len(self.line_lists[i]) - 1):
fillets.append(
rs.AddFilletCurve(self.line_lists[i][j],
self.line_lists[i][j + 1], 1))
for k in range(0, len(self.line_lists[i])):
line = self.line_lists[i][k]
if (k < len(self.line_lists[i]) - 1):
line_domain = rs.CurveDomain(line)
line_intersect = rs.CurveCurveIntersection(
line, fillets[k])[0][5]
line = rs.TrimCurve(self.line_lists[i][k],
(line_domain[0], line_intersect), True)
if (k > 0):
line_domain = rs.CurveDomain(line)
line_intersect = rs.CurveCurveIntersection(
line, fillets[k - 1])
line = rs.TrimCurve(line,
(line_intersect[0][5], line_domain[1]),
True)
new_line.append(line)
if (k < len(self.line_lists[i]) - 1):
new_line.append(fillets[k])
self.lines.append(rs.JoinCurves(new_line))
def createPipe(self, first, mid, last, text):
first_fillet = rs.AddFilletCurve(first, mid, 0.25)
fillet_points = rs.CurveFilletPoints(first, mid, 0.25)
first_circle = rs.AddCircle(fillet_points[2], 0.125)
first_cp = rs.CurveClosestPoint(first, fillet_points[0])
first_domain = rs.CurveDomain(first)
nfirst = rs.TrimCurve(first, (first_domain[0], first_cp), False)
second_cp = rs.CurveClosestPoint(mid, fillet_points[1])
second_domain = rs.CurveDomain(mid)
nmid = rs.TrimCurve(mid, (second_cp, second_domain[1]), False)
second_fillet = rs.AddFilletCurve(mid, last, 0.25)
fillet_points = rs.CurveFilletPoints(mid, last, 0.25)
second_circle = rs.AddCircle(fillet_points[2], 0.125)
first_cp = rs.CurveClosestPoint(mid, fillet_points[0])
first_domain = rs.CurveDomain(mid)
nmid = rs.TrimCurve(nmid, (first_domain[0], first_cp), False)
second_cp = rs.CurveClosestPoint(last, fillet_points[1])
second_domain = rs.CurveDomain(last)
nlast = rs.TrimCurve(last, (second_cp, second_domain[1]), False)
curve = rs.JoinCurves(
[nfirst, first_fillet, nmid, second_fillet, nlast])
print curve
pipe = rs.AddPipe(curve, 0, 0.09375, 0, 1)
points = [
rs.CurveStartPoint(first),
rs.CurveEndPoint(first),
rs.CurveStartPoint(last),
rs.CurveEndPoint(last)
]
self.copyAndMover(first, mid, last, points, text)
def fillet_lines(self):
self.lines = []
for i in range(0, len(self.line_lists)):
fillets = []
new_line = []
for j in range(0, len(self.line_lists[i]) - 1):
first_line = self.line_lists[i][j]
second_line = self.line_lists[i][j + 1]
fillet = rs.AddFilletCurve(first_line, second_line, 0.125)
fillet_points = rs.CurveFilletPoints(first_line, second_line,
0.125)
first_cp = rs.CurveClosestPoint(first_line, fillet_points[0])
first_domain = rs.CurveDomain(first_line)
self.line_lists[i][j] = rs.TrimCurve(
first_line, (first_domain[0], first_cp), True)
second_cp = rs.CurveClosestPoint(second_line, fillet_points[1])
second_domain = rs.CurveDomain(second_line)
self.line_lists[i][j + 1] = rs.TrimCurve(
second_line, (second_cp, second_domain[1]), True)
fillets.append(fillet)
for k in range(0, len(self.line_lists[i])):
new_line.append(self.line_lists[i][k])
if (k < len(self.line_lists[i]) - 1):
new_line.append(fillets[k])
new_curve = self.get_curve_from_segments(new_line)
self.lines.append(new_curve)
def copyAndMover(self, first, mid, last, points, text):
plane = rs.PlaneFromPoints(points[0], points[1], points[2])
uv1 = rs.PlaneClosestPoint(plane, points[1], False)
uv2 = rs.PlaneClosestPoint(plane, points[2], False)
distHor = abs(uv1[0] - uv2[0])
distVert = abs(uv1[1] - uv2[1])
key = 'len{0}{1}'.format(distHor, distVert)
key = re.sub(r'\.', '', key)
if key in self.partsHash:
self.partsHash[key].append(text)
else:
self.partsHash[key] = []
self.partsHash[key].append(text)
ypos = len(self.partsHash.keys()) + len(self.partsHash.keys())
rs.AddText(key, [0, ypos, 0], 0.3)
newPoints = [
rs.AddPoint(0, ypos, 0),
rs.AddPoint(self.FLAT_LENGTH, ypos, 0),
rs.AddPoint(self.FLAT_LENGTH + distHor, ypos + distVert, 0),
rs.AddPoint((self.FLAT_LENGTH * 2) + distHor, ypos + distVert,
0)
]
first = rs.OrientObject(first, points, newPoints, 1)
mid = rs.OrientObject(mid, points, newPoints, 1)
last = rs.OrientObject(last, points, newPoints, 1)
first_fillet = rs.AddFilletCurve(first, mid, 0.09375)
fillet_points = rs.CurveFilletPoints(first, mid, 0.09375)
first_circle = rs.AddCircle(fillet_points[2], 0.09375)
first_cp = rs.CurveClosestPoint(first, fillet_points[0])
first_domain = rs.CurveDomain(first)
first = rs.TrimCurve(first, (first_domain[0], first_cp), True)
second_cp = rs.CurveClosestPoint(mid, fillet_points[1])
second_domain = rs.CurveDomain(mid)
mid = rs.TrimCurve(mid, (second_cp, second_domain[1]), True)
second_fillet = rs.AddFilletCurve(mid, last, 0.09375)
fillet_points = rs.CurveFilletPoints(mid, last, 0.09375)
second_circle = rs.AddCircle(fillet_points[2], 0.09375)
first_cp = rs.CurveClosestPoint(mid, fillet_points[0])
first_domain = rs.CurveDomain(mid)
mid = rs.TrimCurve(mid, (first_domain[0], first_cp), True)
second_cp = rs.CurveClosestPoint(last, fillet_points[1])
second_domain = rs.CurveDomain(last)
last = rs.TrimCurve(last, (second_cp, second_domain[1]), True)
curve = rs.JoinCurves(
[first, first_fillet, mid, second_fillet, last])
rs.AddCircle([0, ypos - 0.125 - 0.09375, 0], 0.09375)
rs.AddCircle([(self.FLAT_LENGTH * 2) + distHor,
ypos + distVert + 0.125 + 0.09375, 0], 0.09375)
def splitLine(line):
#obtain the curve (line) minimum and maximum (domain)
lineDomain = rs.CurveDomain(line)
min = lineDomain[0]
max = lineDomain[1]
OneThird = (max - min) / 3
TwoThird = (max - min) * 2 / 3
StartLine = rs.TrimCurve(line, (min, min + OneThird), False)
EndLine = rs.TrimCurve(line, (min + TwoThird, max))
SplitLine = (StartLine, EndLine)
#return the array of two lines
return SplitLine
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 trimOffsetCurves(crvGuids):
intersectParams = {}
for x in range(0, crvGuids.Count):
intersectParams[x] = []
for x in range(0, crvGuids.Count - 1):
for y in range(x + 1, crvGuids.Count):
if crvGuids[x] != crvGuids[y]:
#Check Intersect Curves
crvA = rs.coercecurve(crvGuids[x])
crvB = rs.coercecurve(crvGuids[y])
intersections = rg.Intersect.Intersection.CurveCurve(
crvA, crvB, sc.doc.ModelAbsoluteTolerance,
sc.doc.ModelAbsoluteTolerance)
if intersections.Count > 0:
intersectParams[x].append(intersections[0].ParameterA)
intersectParams[y].append(intersections[0].ParameterB)
retGuids = []
for x in range(0, crvGuids.Count):
if intersectParams[x][0] > intersectParams[x][1]:
tA = intersectParams[x][1]
tB = intersectParams[x][0]
else:
tA = intersectParams[x][0]
tB = intersectParams[x][1]
guid = rs.TrimCurve(crvGuids[x], (tA, tB))
if guid != None:
retGuids.append(guid)
return retGuids
def draw_hole(grid00, grid01):
grids = [grid00, grid01]
points = []
lists = []
for i in grids:
domain = rs.CurveDomain(i)
domains = [domain[0] + b, domain[1] - b0 * b, domain[1] - b]
lists.append(domains)
for ii in domains:
point = rs.EvaluateCurve(i, ii)
points.append(point)
for i in range(2):
grid = rs.AddCurve([points[i * 3], points[5 - i * 3]])
domain0 = rs.CurveDomain(grid)
domain1 = domain0[1] - c
point = rs.EvaluateCurve(grid, domain1)
#rs.AddPoint(point)
rs.AddCurve([point, points[i * 3 + 1]])
rs.TrimCurve(grids[i], (lists[i][0], lists[i][1]))
rs.TrimCurve(grid, (domain0[0], domain1))
def offsetRow(self, edge, vec, width):
"""
Offset a row depending on the type of width and direction.
need to use self.edges
:return:
"""
# print("edge", rs.CurveLength(edge))
# print("vec", vec)
# print("width", width)
newRow = rs.OffsetCurve(edge, vec, width)
# Magic number
# print("newRow", newRow)
# print("newRowCurve", rs.CurveLength(newRow))
rs.ScaleObject(newRow, rs.CurveMidPoint(newRow), [20, 20, 0])
# print("ScaleNewRowCurve", rs.CurveLength(newRow))
# Problem Below!!
param = []
for e in self.edges:
intersect = rs.CurveCurveIntersection(newRow, e)
# Follows the Rhino api
if intersect is not None:
param.append(intersect[0][5])
# print("param", param)
if param[0] < param[1]:
newRow = rs.TrimCurve(newRow, [param[0], param[1]])
elif param[0] > param[1]:
newRow = rs.TrimCurve(newRow, [param[1], param[0]])
else:
# only one intersection, it's time to stop
newRow = None
# newRow = rs.TrimCurve(newRow, [param[0], param[1]])
# print("TrimNewRowCurve", rs.CurveLength(newRow))
return newRow
def Cargas_Vigas(viga, plD, plB, plC, cob, borda1, borda2, conv):
#
cob = rs.coercecurve(cob)
forces = []
#separando entrada viga em seus elementos (polilinhas)
#bs = banzo superior, diag = diagonais, bi = banzo inferior
bs, diag, bi = viga
#extraindo os nós do banzo superior
nos = rs.PolylineVertices(bs)
# explodindo polilinhas
bs = rs.ExplodeCurves(bs)
diag = rs.ExplodeCurves(diag)
bi = rs.ExplodeCurves(bi)
for i in range(len(nos)):
P = 0
if 0 < i < (len(nos) - 1):
#banzo inferior
P = rs.CurveLength(bi[i]) * plB
#banzo superior
P += (rs.CurveLength(bs[i - 1]) + rs.CurveLength(bs[i])) / 2 * plB
#diagonais
P += (rs.CurveLength(diag[i * 2]) +
rs.CurveLength(diag[(i * 2) + 1])) * plD
#cobertura
bs1 = bs[i - 1]
bs1 = rs.coerceline(bs1)
ptAux1 = bs1.PointAt(.5)
bs2 = bs[i]
bs2 = rs.coerceline(bs2)
ptAux2 = bs2.PointAt(.5)
param1 = rs.CurveClosestPoint(cob, ptAux1)
param2 = rs.CurveClosestPoint(cob, ptAux2)
elif i == 0:
#banzo inferior
P = rs.CurveLength(bi[i]) * plB
#banzo superior
P += (rs.CurveLength(bs[i]) / 2) * plB
#diagonais
P += (rs.CurveLength(diag[i * 2]) +
rs.CurveLength(diag[(i * 2) + 1])) * plD
#cobertura
param1 = 0
bs1 = bs[i]
bs1 = rs.coerceline(bs1)
ptAux = bs1.PointAt(.5)
#teste.append(ptAux)
param2 = rs.CurveClosestPoint(cob, ptAux)
elif i == (len(nos) - 1):
#banzo superior e conector
P = (rs.CurveLength(bs[i - 1]) + rs.CurveLength(borda1)) / 2 * plB
#conector
P += rs.CurveLength(borda2) * plB
#cobertura
bs1 = bs[i - 1]
bs1 = rs.coerceline(bs1)
ptAux1 = bs1.PointAt(.5)
borda1 = rs.coerceline(borda1)
ptAux2 = borda1.PointAt(.5)
param1 = rs.CurveClosestPoint(cob, ptAux1)
param2 = rs.CurveClosestPoint(cob, ptAux2)
if not len(diag) % 2 == 0:
#banzo inferior
P += rs.CurveLength(bi[i]) * plB
#diagonal
P += (rs.CurveLength(diag[i * 2])) * plD
P_viga = P
if not param1 == param2:
cobAux = rs.TrimCurve(cob, [param1, param2], False)
P_cob = rs.CurveLength(cobAux) * plC
P += P_cob
P *= conv
forces.append(P)
return forces, P_viga, P_cob
def EixosVigas(BZ, DiagN, d1, od1, d2, od2):
#----Diagnoais----
#dividir o banzo superior 1 em 2 x (numero de diagonais de v)
ptB1 = rs.DivideCurve(BZ, (2 * DiagN))
#a variável EPcurv armazena o start point do eixo do banzo superior
SPCurv = ptB1[0]
#exclui o primeiro valor da lista (start point da curva do banzo superior)
ptB1 = ptB1[1:]
#pAux é o ponto de partida do eixo do banzo inferior
pAux = gh.Move(Point3d(SPCurv), -d2 * eY)[0]
#Offsets da curva do banzo sup nas distancias d1 e d2
cAux1 = rs.OffsetCurve(BZ, od1, d1, eZ)
cAux2 = rs.OffsetCurve(BZ, od2, d2, eZ)
#-aplicando mascara binária
#ptB1 = lista dos nós do banzo sup
ptB1 = gh.Dispatch(ptB1, [False, True, False, False])[0]
# iniciando lista dos nós do bazo infeirior
apoio = pAux
ptB2 = [pAux]
#-calculando nós do banzo inferior
#contador FOR do primeiro ao penultimo item de ptb1
for i in range(len(ptB1) - 1):
#desenha linhas etrne o ponto atual e próximo ponto de ptB1
linAux = Line(ptB1[i], ptB1[i + 1])
#pAux = ponto médio de linAux
pAux3 = linAux.PointAt(.5)
#calcula ponto em cAux1 mais proximo de pAux
#pAux1 =[(coordenadas do pto),(parametro do pto),(distância pto-crv)]
pAux1 = gh.CurveClosestPoint(pAux3, rs.coercecurve(cAux1))
#idem - cAux2
#pAux2 = idem
pAux2 = gh.CurveClosestPoint(pAux3, rs.coercecurve(cAux2))
#linha entre os pontos equivalentes das curvas cAux1 e cAux2
linAux2 = Line(pAux2[0], pAux1[0])
#cAux3 = cAux1 cortada (trim) no ponto pAux1
cAux3 = rs.TrimCurve(cAux1, (0, pAux1[1]), False)
#razão entre o comprimento da curva cAux1 até o ponto pAux1
#e o compriento total de cAux1
prmt = rs.CurveLength(cAux3) / rs.CurveLength(cAux1)
#ponto que interpola as alturas VH1 e VH2
pAux = linAux2.PointAt(prmt)
#coloca o pto pAux na lista dos nós
ptB2.append(pAux)
#o ponto final do banzo inferior é colocado no final da lista ptB2
ptB2.append(rs.CurveEndPoint(cAux1))
#-ajuste do ultimo ponto da treliça
nosD = gh.Weave([0, 1], ptB2, ptB1)
if DiagN % 2 == 0:
ptB1.append(rs.CurveEndPoint(BZ))
else:
del nosD[-1]
#desenha diagonais
lDiag = rs.AddPolyline(nosD)
#desenha banzo inferior
bzInf = rs.AddPolyline(ptB2)
#desenha banzo superior
bzSup = rs.AddPolyline(ptB1)
return lDiag, bzSup, bzInf, nosD, ptB1, ptB2, apoio
def EixosShed(BZ, DiagN, pto):
#----Shed----
#dividir o banzo superior 1 em 2 x (numero de diagonais de v3)
ptB1 = rs.DivideCurve(BZ, (DiagN))
#exclui o primeiro valor da lista (start point da curva do banzo superior)
if DiagN % 2 == 0:
mask = [True, False]
else:
SPCurv = ptB1[0]
mask = [False, True]
#calcula ponto em cAux1 mais proximo de pAux
#pAux =[(coordenadas do pto),(parametro do pto),(distância pto-crv)]
pAux = gh.CurveClosestPoint(pto, BZ)
#Offsets da curva do banzo sup no ponto pto
cAux1 = rs.OffsetCurve(BZ, pto, pAux[2])
#c.append(rs.coercecurve(cAux1))
#-aplicando mascara binária
#ptB1 = lista dos nós do banzo sup
ptB1 = gh.Dispatch(ptB1, mask)[0]
ptB2 = [pto]
#-calculando nós do banzo inferior
#contador FOR do primeiro ao penultimo item de ptb1
for i in range(len(ptB1) - 1):
#desenha linhas etrne o ponto atual e próximo ponto de ptB1
linAux = Line(ptB1[i], ptB1[i + 1])
#pAux = ponto médio de linAux
pAux3 = linAux.PointAt(.5)
#calcula ponto em cAux1 mais proximo de pAux
#pAux1 =[(coordenadas do pto),(parametro do pto),(distância pto-crv)]
pAux1 = gh.CurveClosestPoint(pAux3, rs.coercecurve(cAux1))
#idem - cAux2
#pAux2 = idem
pAux2 = gh.CurveClosestPoint(pAux3, BZ)
#linha entre os pontos equivalentes das curvas cAux1 e cAux2
linAux2 = Line(pAux1[0], pAux2[0])
#a.append(linAux2)
#cAux2 = cAux1 cortada (trim) no ponto pAux1
cAux2 = rs.TrimCurve(cAux1, (0, pAux1[1]), False)
#razão entre o comprimento da curva cAux1 até o ponto pAux1
#e o compriento total de cAux1
prmt = rs.CurveLength(cAux2) / rs.CurveLength(cAux1)
#ponto que interpola as alturas VH1 e VH2
pAux = linAux2.PointAt(prmt * .75)
#coloca o pto pAux na lista dos nós
ptB2.append(pAux)
#-desenhando diagonais e banzo inf
#combina lista dos nós, inferiores e superiores
#ordenados na sequancia das diagonais
nosD = gh.Weave([0, 1], ptB2, ptB1)
if DiagN % 2 == 0:
del nosD[0]
else:
ptB1.insert(0, SPCurv)
#desenha diagonais
lDiag = rs.AddPolyline(nosD)
#desenha banzo Superior
bzSup = rs.AddPolyline(ptB1)
#desenha banzo inferior
bzInf = rs.AddPolyline(ptB2)
return lDiag, bzSup, bzInf, nosD, ptB1, ptB2,
point = (X, Y, Z)
r = r + 0.3
circle = rs.AddCircle(point, r)
cir.append(circle)
domain = rs.CurveDomain(circle)
dom.append(domain)
plane = rs.AddPlanarSrf(circle)
cplane.append(plane)
#rotate the first curve and intersect the curves with circles
for i in range(1, 30):
curve = rs.AddCurve(points)
rcurve = rs.RotateObject(curve, point, i * 10, vector, copy=True)
hcurve.append(rcurve)
#intersection
for h in xrange(0, 7):
cur, intpoint = rs.CurveBrepIntersect(rcurve, cplane[h])
split.append(intpoint[0])
#make a domain for each trim and trim the curves
domain = rs.CurveDomain(rcurve)
domain[1] /= i * 0.08
domain[0] /= i * 2
tcurve = rs.TrimCurve(rcurve, domain)
epoint = rs.CurveEndPoint(tcurve)
spoint = rs.CurveStartPoint(tcurve)
epoints.append(epoint)
spoints.append(spoint)
ecurve = rs.AddCurve(epoints)
scurve = rs.AddCurve(spoints)
if rs.CurveBooleanUnion([polylines[i], polylines[j]]):
MN = taxicab_midnormal(pts[i], pts[j], l)
ccx = rs.CurveCurveIntersection(polylines[i], MN)
if ccx is None:
continue
if ccx[0][0] == 2:
continue
para_a = [ccx[0][5], ccx[1][5]]
para_b = [ccx[0][7], ccx[1][7]]
if para_b[0] > para_b[1]:
para_b = [para_b[1], para_b[0]]
probable_dash = rs.SplitCurve(polylines[i], para_a)
edge = rs.TrimCurve(MN, para_b, False)
edgepts = rs.CurvePoints(edge)
for crv in probable_dash:
crvpts = rs.CurvePoints(crv)
if rs.PointCompare(crvpts[0], edgepts[0]):
crvpts.reverse()
newpl = rs.AddPolyline(edgepts + crvpts)
if rs.PointInPlanarClosedCurve(pts[i], newpl):
polylines[i] = newpl
break
ccx = rs.CurveCurveIntersection(polylines[j], MN)
if ccx is None:
continue
para_a = [ccx[0][5], ccx[1][5]]
BzSup1 = rs.coercecurve(Curva)
ptX1, prm1, count = gh.CurveXLine(BzSup1, rs.coerceline(Eixo_de_Simetria))
ptAux = gh.Move(ptX1, -eY)[0]
#desenha um seguimento no eixo de simetria da treliça
lAux = rs.coerceline(Eixo_de_Simetria)
cAux = rs.OffsetCurve(BzSup1, ptAux, HV1, eZ)
ptX2 = gh.CurveXLine(rs.coercecurve(cAux), lAux)[0]
#eixo do conector
EixoSimetria = rs.AddLine(ptX1, ptX2)
Eixos_do_Conector.append(EixoSimetria)
#----Linhas auxiliares dos Banzos Superiores----
#Ponto de corte (trim) do banzo sup. de V1
#ptY1 = [ponto,parametro,dist]
ptY1, paramY1, distY1 = gh.CurveClosestPoint(ptX2, BzSup1)
#corte (trim) do banzo sup v1
BS1 = rs.TrimCurve(BzSup1, [0, paramY1], False)
BS1 = rs.coercecurve(BS1)
#-espelhando (mirror) eixo sup de v1
#plano de espelhamento
mirplano = rs.PlaneFromNormal(ptX1, eX, eZ)
#BS2 = eixo banzo sup de v2
BS2 = gh.Mirror(rs.coercecurve(BS1), mirplano)[0]
#cortando a curva incicial no eixo de simetria
BS3 = rs.TrimCurve(BzSup1, [prm1, 0], False)
BS3 = rs.coercecurve(BS3)
#bordas do conector
ptY2 = (rs.CurveEndPoint(BS2))
Nos_do_Conector = [ptX1, ptY1, ptX2, ptY2]
conect = rs.AddPolyline(Nos_do_Conector + Nos_do_Conector[:1])
Eixos_do_Conector.append(conect)
#eixos da viga v1
def trim(self, curve, cutter):
resultLines = []
#when arguments are shit, return empty list
try:
rs.IsCurve(curve)
except:
##Debug needs
print('IsCurve failed')
print(curve)
return resultLines
try:
rs.IsCurve(cutter)
except:
##Debug needs
print('IsCurve failed')
print(cutter)
return resultLines
if rs.IsCurve(curve) is False or rs.IsCurve(cutter) is False:
return resultLines
intersectedPoints = rs.CurveCurveIntersection(curve, cutter)
if intersectedPoints == None:
return resultLines
#when cutter is not planar, tmpSurface will be non
intersectedPoints = [n[1] for n in intersectedPoints]
if len(intersectedPoints) % 2 == 1:
#print("In trim(), there is weird")
return resultLines
#convert point to curve parameter
curveParas = []
for i in intersectedPoints:
curveParas.append(rs.CurveClosestPoint(curve, i))
for i in range(int(len(curveParas) / 2)):
tmp = []
tmp.append(curveParas[i * 2])
tmp.append(curveParas[i * 2 + 1])
try:
resultLines.append(rs.TrimCurve(curve, tmp))
except:
return []
##debug needs
"""
print('trim failed\ncurve,tmp,domain')
print(curve)
print(tmp)
print(rs.IsCurve(curve))
##debug needs
##why this 'curve' isn't curve?
if rs.IsCurve(curve):
print(rs.CurveDomain(curve))
"""
return resultLines
import rhinoscriptsyntax as rs
import random
a = 20
x = random.randint(0,a)
y = random.randint(0,a)
z = random.randint(0,a)
p = (x,y,z)
p1 = (0,0,0)
p2 = (a,a,0)
p3 = (0,0,a)
for i in range(a):
for j in range(a):
point = (0,i,j)
A = rs.AddPoint(point)
rs.HideObject(A)
B = rs.AddLine(point,p)
rs.TrimCurve(B,(1,3),True)