def DrawForeground(self, e):
draw_dot = e.Display.DrawDot
draw_arrows = e.Display.DrawArrows
a = self.mouse.p1
b = self.mouse.p2
ab = subtract_vectors(b, a)
Lab = length_vector(ab)
if not Lab:
return
for index, vertex in enumerate(self.force_vertex_xyz):
c = self.force_vertex_xyz[vertex]
D = length_vector(
cross_vectors(subtract_vectors(a, c), subtract_vectors(b, c)))
if D / Lab < self.tol:
point = Point3d(*c)
draw_dot(point, str(index), self.dotcolor, self.textcolor)
lines = List[Line](len(self.force_vertex_edges[vertex]))
for u, v in self.force_vertex_edges[vertex]:
lines.Add(
Line(Point3d(*self.force_vertex_xyz[u]),
Point3d(*self.force_vertex_xyz[v])))
draw_arrows(lines, self.linecolor)
lines = List[Line](len(self.form_face_edges[vertex]))
for u, v in self.form_face_edges[vertex]:
lines.Add(
Line(Point3d(*self.form_vertex_xyz[u]),
Point3d(*self.form_vertex_xyz[v])))
draw_arrows(lines, self.linecolor)
break
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
xyz = _volmesh_compute_dependent_face_intersections(
volmesh, hfkey, cp, target_normal)
seen = set()
for fkey in dep_hfkeys + [hfkey]:
hf_edges = volmesh.halfface_halfedges(fkey)
for edge in hf_edges:
u = edge[0]
v = edge[1]
pair = frozenset([u, v])
if pair not in seen:
init_u = volmesh.vertex_coordinates(u)
init_u_xyz = Point3d(*init_u)
u_xyz = Point3d(*xyz[u])
v_xyz = Point3d(*xyz[v])
e.Display.DrawLine(Line(u_xyz, v_xyz), black, 4)
e.Display.DrawArrow(Line(init_u_xyz, u_xyz), arrow_color,
12, 0)
# e.Display.DrawDottedLine(init_u_xyz, u_xyz, feedback_color)
seen.add(pair)
for u, v in volmesh.edges_iter():
if frozenset([u, v]) not in seen:
sp = volmesh.vertex_coordinates(u)
ep = volmesh.vertex_coordinates(v)
if u in xyz:
sp = xyz[u]
if v in xyz:
ep = xyz[v]
e.Display.DrawLine(Line(Point3d(*sp), Point3d(*ep)), black, 2)
def Cremona2(no, nomes, Linhas, countPF, dicPF):
ptos1 = []
dicUp = {}
for i in range(countPF):
if i == 0:
Spt = dicPF[nomes[i]].PointAt(0)
Ept = dicPF[nomes[i]].PointAt(1)
else:
if i == 1:
cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(1), Tol)
cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(0), Tol)
if cond1 or cond2:
pAux3 = Spt
Spt = Ept
Ept = pAux3
if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol):
ptAux1 = dicPF[nomes[i]].PointAt(1)
ptAux2 = dicPF[nomes[i]].PointAt(0)
else:
ptAux1 = dicPF[nomes[i]].PointAt(0)
ptAux2 = dicPF[nomes[i]].PointAt(1)
Ept += (ptAux2 - ptAux1)
vAux1 = Line(rs.CurveStartPoint(Linhas[-2]), Ept)
vAux2 = Line(rs.CurveStartPoint(Linhas[-1]), Spt)
F1 = gh.Move(rs.coerceline(Linhas[-2]), vAux1)[0]
F2 = gh.Move(rs.coerceline(Linhas[-1]), vAux2)[0]
inter = gh.LineXLine(F1, F2)[2]
F1 = rs.AddLine(Ept, inter)
F2 = rs.AddLine(inter, Spt)
dicUp[nomes[-2]] = rs.coerceline(F1)
dicUp[nomes[-1]] = rs.coerceline(F2)
#-cargas e nomenclatura
#teste de tração e compressão
sin1 = TraComp(no, F1, rs.coerceline(Linhas[-2]), nomes[-2])
sin2 = TraComp(no, F2, rs.coerceline(Linhas[-1]), nomes[-1])
#valores das cargas
carga1 = rs.CurveLength(F1) * sin1 / Escala
carga2 = rs.CurveLength(F2) * sin2 / Escala
#teste de tensão admissivel
cor1 = teste_elemento(nomes[-2], carga1, Linhas[-2])
cor2 = teste_elemento(nomes[-1], carga2, Linhas[-1])
#nomenclatura do FG
txt1 = nomes[-2] + ' = ' + str('%.2f' % carga1)
txt2 = nomes[-1] + ' = ' + str('%.2f' % carga2)
pt1 = rs.coerceline(Linhas[-2]).PointAt(.5)
pt2 = rs.coerceline(Linhas[-1]).PointAt(.5)
ptos1 += [pt1, txt1, cor1]
ptos1 += [pt2, txt2, cor2]
#nimenclatura do PF
pt1 = rs.coerceline(F1).PointAt(.5)
pt2 = rs.coerceline(F2).PointAt(.5)
txt1 = nomes[-2]
txt2 = nomes[-1]
ptos1 += [pt1, txt1, cor1]
ptos1 += [pt2, txt2, cor2]
return dicUp, ptos1
def DrawForeground(self, e):
lines = List[Line](self.lines_count)
for i, j in self.lines:
sp = self.points[i]
ep = self.points[j]
lines.Add(Line(Point3d(*sp), Point3d(*ep)))
e.Display.DrawLines(lines, self.color, self.thickness)
for i, (u, v) in enumerate(self.splines):
sp = self.points[u]
ep = self.points[v]
th = self.spline_thickness[i]
e.Display.DrawLine(Line(Point3d(*sp), Point3d(*ep)),
self.spline_color, th)
def drawside(crv, sim):
for i in xrange(len(crv)):
t = [[], [], [], []]
for j in xrange(len(crv[i])):
t[j] = Curve.DivideByCount(crv[i][j], 29, True)
for k in xrange(len(t[j])):
pt0 = Curve.PointAt(crv[i][0], t[0][k])
pt1 = Curve.PointAt(crv[i][1], t[1][k])
pt2 = Curve.PointAt(crv[i][2], t[2][k])
pt3 = Curve.PointAt(crv[i][3], t[3][k])
sim.append(Line(pt0, pt1))
sim.append(Line(pt2, pt3))
return sim
def _conduit_volmesh_edges(volmesh, e):
for u, v in volmesh.edges():
sp = volmesh.vertex_coordinates(u)
ep = volmesh.vertex_coordinates(v)
e.Display.DrawPoint(Point3d(*sp), 0, 4, white)
e.Display.DrawPoint(Point3d(*ep), 0, 4, white)
e.Display.DrawLine(Line(Point3d(*sp), Point3d(*ep)), white, 1)
def DrawForeground(self, e):
try:
if self.color:
draw = e.Display.DrawLine
if self.thickness:
for i, (start, end) in enumerate(self.lines):
draw(Point3d(*start), Point3d(*end), self.color[i], self.thickness[i])
else:
for i, (start, end) in enumerate(self.lines):
draw(Point3d(*start), Point3d(*end), self.color[i], self._default_thickness)
elif self.thickness:
draw = e.Display.DrawLine
if self.color:
for i, (start, end) in enumerate(self.lines):
draw(Point3d(*start), Point3d(*end), self.color[i], self.thickness[i])
else:
for i, (start, end) in enumerate(self.lines):
draw(Point3d(*start), Point3d(*end), self._default_color, self.thickness[i])
else:
lines = List[Line](len(self.lines))
for start, end in self.lines:
lines.Add(Line(Point3d(*start), Point3d(*end)))
e.Display.DrawLines(lines, self._default_color, self._default_thickness)
except Exception as e:
print(e)
def DrawForeground(self, e):
lines = List[Line](self.n)
for i, j in self.pairs:
start = self.points[i]
end = self.points[j]
lines.Add(Line(Point3d(*start), Point3d(*end)))
e.Display.DrawLines(lines, self.color, self.thickness)
def draw_lines(lines):
"""Draw lines.
Parameters
----------
lines : list of dict
The line definitions.
Returns
-------
list of :class:`Rhino.Geometry.Line`
Notes
-----
.. code-block:: python
Schema({
'start': lambda x: len(x) == 3),
'end': lambda x: len(x) == 3),
})
"""
rg_lines = []
for line in iter(lines):
sp = line['start']
ep = line['end']
rg_lines.append(Line(Point3d(*sp), Point3d(*ep)))
return rg_lines
def drawsilk(self):
t1 = Curve.DivideByCount(self.flow[0].retrail, 99, True)
t2 = Curve.DivideByCount(self.flow[1].retrail, 99, True)
for i in xrange(99):
pt1 = Curve.PointAt(self.flow[0].retrail, t1[i])
pt2 = Curve.PointAt(self.flow[1].retrail, t2[i])
self.silks.append(Line(pt1, pt2))
def base_profile(self):
# * *
# * *
# * *
# static variable lists
val_list = [(1,1), (1, -1), (-1, -1), (-1, 1)]
# generating the points
pts = []
for i in range(4):
pts.append(Point3d(
self.l_half*val_list[i][0],
self.w_half*val_list[i][1],
0.0
))
if i==0:
pts.append(Point3d(self.l_half+self.w_half, 0, 0))
elif i == 2:
pts.append(Point3d(-(self.l_half+self.w_half), 0, 0))
# creating the segments
poly_crv=PolyCurve()
for i in range(2):
p0, p1, p2, p3 = [pts[j+i*3] for j in range(-1, 3, 1)]
line = Line(p0, p1)
poly_crv.Append(line)
crv = Arc(p1, p2, p3)
poly_crv.Append(crv)
return poly_crv
def DrawForeground(self, e):
draw_line = e.Display.DrawLine
draw_lines = e.Display.DrawLines
if self.color:
if self.thickness:
for i, start, end in self.lines:
draw_line(start, end, self.color[i], self.thickness[i])
else:
for i, start, end in self.lines:
draw_line(start, end, self.color[i],
self._default_thickness)
elif self.thickness:
if self.color:
for i, start, end in self.lines:
draw_line(start, end, self.color[i], self.thickness[i])
else:
for i, start, end in self.lines:
draw_line(start, end, self._default_color,
self.thickness[i])
else:
lines = List[Line](self.mesh.number_of_edges())
for i, start, end in self.lines:
lines.Add(Line(start, end))
draw_lines(lines, self._default_color, self._default_thickness)
def _conduit_network_edges(network, e):
for u, v in network.edges():
sp = network.vertex_coordinates(u)
ep = network.vertex_coordinates(v)
e.Display.DrawPoint(Point3d(*sp), 0, 4, white)
e.Display.DrawPoint(Point3d(*ep), 0, 4, white)
e.Display.DrawLine(Line(Point3d(*sp), Point3d(*ep)), white, 1)
def DrawForeground(self, e):
edges = list(self.mesh.wireframe())
lines = List[Line](len(edges))
for u, v in edges:
sp = self.mesh.vertex_coordinates(u)
ep = self.mesh.vertex_coordinates(v)
lines.Add(Line(Point3d(*sp), Point3d(*ep)))
e.Display.DrawLines(lines, self.color)
def DrawForeground(self, e):
lines = List[Line](len(self.lines))
for start, end in self.lines:
lines.Add(
Line(Point3d(start[0], start[1], 0),
Point3d(end[0], end[1], 0)))
e.Display.DrawLines(lines, self._default_color,
self._default_thickness)
def estendeFG(linha,corda,ponto):
linnha = rs.coerceline(linha)
ponto = rs.coerce3dpoint(ponto)
if not gh.CurveXCurve(linha,corda)[0]:
pt =gh.EndPoints(linha)[0]
construc_aux.append(Line(pt,ponto))
return True
else:
return False
def xdraw_lines(lines):
"""Draw lines.
"""
rg_lines = []
for l in iter(lines):
sp = l['start']
ep = l['end']
rg_lines.append(Line(Point3d(*sp), Point3d(*ep)))
return rg_lines
def copy(self):
sup_dir_copy = []
for dir in self.sup_dir:
dir = dir.ToNurbsCurve()
start_copy = dir.PointAtStart
end_copy = dir.PointAtEnd
dir_copy = Line(start_copy, end_copy)
sup_dir_copy.append(dir_copy)
sup_copy = Support(sup_dir_copy)
return sup_copy
def transform(self, trans):
sup_dir_trans = []
for dir in self.sup_dir:
dir = dir.ToNurbsCurve()
start_trans = dir.PointAtStart
end_trans = dir.PointAtEnd
start_trans.Transform(trans)
end_trans.Transform(trans)
dir_trans = Line(start_trans, end_trans)
sup_dir_trans.append(dir_trans)
sup_trans = Support(sup_dir_trans)
return sup_trans
def copy(self):
if self.transformable == True:
values_copy = []
for val in self.values:
val_copy = None
if type(val) == Point3d:
val_copy = Point3d(val)
elif type(val) == Plane:
val_copy = Plane(val)
elif type(val) == Line:
val_copy = Line(val.From, val.To)
else:
val_copy = val.Duplicate()
values_copy.append(val_copy)
attr_copy = Attribute(self.name, values_copy, self.transformable)
else:
attr_copy = Attribute(self.name, self.values, self.transformable)
return attr_copy
def transform(self, trans):
if self.transformable == True:
values_trans = []
for val in self.values:
val_trans = None
## !!!! add try..except.. block for other geometry types (?)
if type(val) == Point3d:
val_trans = Point3d(val)
elif type(val) == Plane:
val_trans = Plane(val)
elif type(val) == Line:
val_trans = Line(val.From, val.To)
else:
val_trans = val.Duplicate()
val_trans.Transform(trans)
values_trans.append(val_trans)
attr_trans = Attribute(self.name, values_trans, self.transformable)
else:
attr_trans = Attribute(self.name, self.values, self.transformable)
return attr_trans
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
plane = (cp, f_normal)
new_pt_list = []
for u in f_vkeys:
v = edges[u]
u_xyz = cell.vertex_coordinates(u)
v_xyz = cell.vertex_coordinates(v)
line = (u_xyz, v_xyz)
it = intersection_line_plane(line, plane)
xyz_dict[u] = it
new_pt_list.append(it)
e.Display.DrawDottedLine(Point3d(*u_xyz), Point3d(*it), black)
for vkey in cell.vertex:
xyz = cell.vertex_coordinates(vkey)
e.Display.DrawPoint(Point3d(*xyz), 0, 5, black)
# old normal and area --------------------------------------------------
e.Display.DrawDot(Point3d(*f_center), str(round(f_area, 3)), gray,
white)
# draw original face ---------------------------------------------------
for i in range(-1, len(f_vkeys) - 1):
vkey1 = f_vkeys[i]
vkey2 = f_vkeys[i + 1]
sp = Point3d(*cell.vertex_coordinates(vkey1))
np = Point3d(*cell.vertex_coordinates(vkey2))
e.Display.DrawDottedLine(sp, np, black)
# get current face info ------------------------------------------------
areas = {}
normals = {}
for fkey in cell.faces():
face_coordinates = [
xyz_dict[vkey] for vkey in cell.face_vertices(fkey)
]
areas[fkey] = polygon_area_oriented(face_coordinates)
normals[fkey] = polygon_normal_oriented(face_coordinates)
# draw new face areas / vectors ----------------------------------------
for fkey in cell.faces():
area = areas[fkey]
normal = normals[fkey]
value = area / max(areas.values())
color = i_to_rgb(value)
color = FromArgb(*color)
# draw vectors -----------------------------------------------------
scale = 0.25
center = datastructure_centroid(cell)
sp = Point3d(*center)
vector = scale_vector(normal, area * scale)
ep = Point3d(*add_vectors(center, vector))
e.Display.DrawArrow(Line(sp, ep), color, 20, 0)
# draw face --------------------------------------------------------
face_coordinates = [
xyz_dict[vkey] for vkey in cell.face_vertices(fkey)
]
face_coordinates.append(face_coordinates[0])
polygon_xyz = [Point3d(*xyz) for xyz in face_coordinates]
e.Display.DrawPolyline(polygon_xyz, black, 2)
if fkey == face:
e.Display.DrawPolyline(polygon_xyz, black, 4)
e.Display.DrawPolygon(polygon_xyz, color, filled=True)
# display force magnitudes -----------------------------------------
vector = add_vectors(vector,
scale_vector(normalize_vector(normal), 0.75))
xyz = add_vectors(center, vector)
if fkey == face:
color = black
e.Display.DrawDot(Point3d(*xyz), str(round(area, 2)), color, white)
def estendeCorda(linha, ponto, indice):
pto1 = linha.PointAt(indice)
return Line(pto1, ponto)
def PF_funic(pto_inicial, polo, carreg, nomes_cargas):
raios = []
ptos = []
dicUp = {}
PF = []
resultante = []
funicular = []
## -- Desenhando o poligono de forças -- ##
pAux = rs.coerce3dpoint(pto_inicial)
# polo do PF do Shed
polo = rs.coerce3dpoint(polo)
#primeiro raio polar
raios.append(Line(polo, pAux))
ptos += [polo, 'polo', cornode]
#desenhando carregamentos no PF e os raios polares
for i in range(len(carreg)):
v = carreg[i]
#carregamento no FG
vAux1 = rs.coerceline(v)
#vetor auxiliar para mover o carregamento para a posição de soma
vAux2 = pAux - v.PointAt(0)
# carregamento no PF
vAux3 = gh.Move(vAux1, vAux2)[0]
#Nomenclatura - texto da reação Pi
nome = nomes_cargas[i]
#Nomenclatua - posição do texto
txtPt = vAux3.PointAt(.5)
# Nomenclatura do PF
ptos += [txtPt, nome, corcargas]
# colocando carregamento na lista do PF
PF.append(vAux3)
# olocando carregamento no dicionario do PF
dicUp[nome] = vAux3
# ponto da posição de soma para o proximo carregamento
pAux = vAux3.PointAt(1)
#desenhando raio polar
r = Line(polo, pAux)
#colocando raio polar na lista de raios
raios.append(r)
#desenhando a resultante no PF
#ponto final da resultante R1
pto_R1 = pAux
#resultante r1 no PF
R1PF = Line(rs.coerce3dpoint(pto_inicial), pto_R1)
#colocando R1 na lista de resultantes
resultante.append(R1PF)
#R1 no dicionario do PF
dicUp['R1'] = R1PF
#Desenhando o funicular
for i in range(len(raios)):
r = rs.coerceline(raios[i])
#caso da primeira corda
if i == 0:
pAux = (rs.coerceline(carreg[0]).PointAt(0))
vAux1 = Line(r.PointAt(0), pAux)
corda = gh.Move(r, vAux1)[0]
corda = rs.coerceline(corda)
#cordas intermediarias
elif i < len(raios) - 1:
vAux1 = Line(r.PointAt(1), pAux)
crdAux = gh.Move(r, vAux1)[0]
crdAux = rs.coerceline(crdAux)
pAux2 = pAux
pAux = gh.LineXLine(crdAux, carreg[i])[-1]
corda = Line(pAux2, pAux)
#caso da ultima corda
else:
vAux1 = Line(r.PointAt(1), pAux)
corda = gh.Move(r, vAux1)[0]
corda = rs.coerceline(corda)
#adicionando corda na lista do funicular
funicular.append(corda)
#resesenhando as cordas extremas
return dicUp, raios, funicular, resultante, ptos
def DrawForeground(self, e):
lines = List[Line](len(self.lines))
for start, end in self.lines:
lines.Add(Line(Point3d(*start), Point3d(*end)))
e.Display.DrawLines(lines, self.color, self.thickness)
#Calcula a distãncia entre duas retas paralelas
def distParalela(reta1,reta2):
pt1 = gh.EndPoints(reta1)[0]
pt2 = reta2.ClosestPoint(pt1,False)
return gh.Length(Line(pt1,pt2))
# Desenhando o poligono de forças
pAux = rs.coerce3dpoint(pto_inicial)
polo = rs.coerce3dpoint(polo)
#primeiro raio polar
raios.append(Line(polo,pAux))
for v in vetores:
vAux1 = rs.coerceline(v)
vAux2 = pAux - v.PointAt(0)
vAux3 = gh.Move(vAux1,vAux2)[0]
pAux = vAux3.PointAt(1)
PF.append(vAux3)
r=Line(polo,pAux)
raios.append(r)
#desenhando a resultante
result=Line(rs.coerce3dpoint(pto_inicial),pAux)
def estendeCorda(linha,ponto,indice):
pto1 = gh.EndPoints(linha)[indice]
return Line(pto1,ponto)
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,
def distParalela(reta1,reta2):
pt1 = gh.EndPoints(reta1)[0]
pt2 = reta2.ClosestPoint(pt1,False)
return gh.Length(Line(pt1,pt2))