def testeFunicular(vetores,funicular,tolerancia):
prm1 = gh.LineXLine(rs.coerceline(vetores[0]),funicular[0])[0]
prm2 = gh.LineXLine(rs.coerceline(vetores[0]),funicular[-1])[0]
if abs(prm1 - prm2) <= tolerancia :
return True
else:
return False
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 hankins(polylist, contactAngle=60):
""" Provides an islamic star pattern based on the paper of C.S. Kaplan.
(http://www.cgl.uwaterloo.ca/~csk/papers/kaplan_gi2005.pdf)
This is called "Hankin's Method" since he was the first Western scientist to describe these patterns.
For this function to work correctly you need a set of polygons which are touching eachother without any gaps.
"""
segments, midpts, startpts, endpts, vec1, vec2, sdl1, sdl2, lxlPt, innerLines, outerLines = [], [], [], [], [], [], [], [], [], [], []
for item in polylist:
segments.append(item.DuplicateSegments())
for m, seglist in enumerate(segments):
tempMid, tempStart, tempEnd, tempVec1, tempVec2, tl1, tl2, lxl = [], [], [], [], [], [], [], []
# 1) points
for k, seg in enumerate(seglist):
# get the points of the segments
# ! IMPORTANT: you have to use .PointAtNormalizedLength
tempMid.append(seg.PointAtNormalizedLength(0.5))
tempStart.append(seg.PointAtStart)
tempEnd.append(seg.PointAtEnd)
# nested lists
midpts.append(tempMid)
startpts.append(tempStart)
endpts.append(tempEnd)
# 2) vectors
for k, seg in enumerate(seglist):
# Vector: Endpt - Startpt
# also rotate them
tv1 = rg.Vector3d(startpts[m][k] - midpts[m][k])
rg.Vector3d.Rotate(tv1, rm.ToRadians(-contactAngle),
rg.Vector3d.ZAxis)
tempVec1.append(tv1)
tv2 = rg.Vector3d(endpts[m][k] - midpts[m][k])
rg.Vector3d.Rotate(tv2, rm.ToRadians(contactAngle),
rg.Vector3d.ZAxis)
tempVec2.append(tv2)
vec1.append(tempVec1)
vec2.append(tempVec2)
# 3) SDL lines
for k, seg in enumerate(seglist):
tl1.append(rg.Line(midpts[m][k], vec1[m][k], sl / 3))
tl2.append(rg.Line(midpts[m][k], vec2[m][k], sl / 3))
sdl1.append(tl1)
sdl2.append(tl2)
# 4) Line intersections, get points (inner points of a star)
for k, seg in enumerate(seglist):
lxl.append(ghcomp.LineXLine(sdl1[m][k], sdl2[m][k - 1])[2])
lxlPt.append(lxl)
# inner polygons (stars)
# some advanced slicing going on; dont worry, its acutally very pythonic
for l, crv in enumerate(polylist):
# listIn1.append(listIn1.pop(0)) # poor man's list shifting
# shift(listIn1, -1)
resultInner = [None] * (len(lxlPt[l][:]) + len(midpts[l][:]))
resultInner[::2] = lxlPt[l][:]
resultInner[1::2] = midpts[l][:]
resultInner.append(lxlPt[l][0]) # to close the polyline
innerLines.append(rg.Polyline(resultInner).ToNurbsCurve())
# outer polygons
for p, poly in enumerate(polylist):
tl = []
for v in range(len(segments[p])):
resultOuter = [
midpts[p][v], startpts[p][v], midpts[p][v - 1], lxlPt[p][v],
midpts[p][v]
]
tl.append(rg.Polyline(resultOuter).ToNurbsCurve())
outerLines.append(tl)
# for visual clues how this is made
global verbose
verbose = segments, midpts, startpts, endpts, sdl1, sdl2, lxlPt
return innerLines, outerLines
for i in range(j):
r = rs.coerceline(raios[i])
if i == 0:
pAux = (rs.coerceline(vetores[0]).PointAt(.5))
vAux1 = Line(r.PointAt(0),pAux)
corda = gh.Move(r,vAux1)[0]
corda = rs.coerceline(corda)
funicular.append(corda)
elif i < j-1:
vAux1 = Line(r.PointAt(1),pAux)
crdAux = gh.Move(r,vAux1)[0]
crdAux = rs.coerceline(crdAux)
pAux2 = pAux
pAux = gh.LineXLine(crdAux,vetores[i])[-1]
corda = Line(pAux2,pAux)
funicular.append(corda)
estendeFG(vetores[i],corda,pAux)
else:
vAux1 = Line(r.PointAt(1),pAux)
corda = gh.Move(r,vAux1)[0]
corda = rs.coerceline(corda)
funicular.append(corda)
#testando PF ppara equilíbrio de translação
testePF=gh.Length(result)
if testePF <= 0.0001:
eqtrans = True
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
C_aux = gh.Move(rs.coerceline(C_v3[i]), vAux1)[0]
carreg_1.append(C_aux)
FG1 = v3 + carreg_1
carreg_1.pop(0)
nomes_cargas = []
for i in range(len(carreg_1)):
nome = "P" + str(i + 1) + '_v3'
nomes_cargas.append(nome)
dic_1, raios_1, funicular_1, resultante_1, ptos = PF_funic(
pto_inicial_1, polo_1, carreg_1, nomes_cargas)
for i in dic_1.keys():
PF1.append(dic_1[i])
txt_pontos += ptos
# - desenhando a resultante no FG
# ponto de intecessão entre a primeira e ultuma corda
pAux = gh.LineXLine(funicular_1[0], funicular_1[-1])[-1]
#resesenhando as cordas extremas
funicular_1[0] = estendeCorda(funicular_1[0], pAux, 0)
funicular_1[-1] = estendeCorda(funicular_1[-1], pAux, 1)
#vetor auxiliar para mover R1PF para o FG
vAux1 = Line(dic_1['R1'].PointAt(.5), pAux)
#R1FG R1 no FG
R1FG = gh.Move(dic_1['R1'], vAux1)[0]
#coloca R1FG na lista de resultates_1
resultante_1.append(R1FG)
# separando a viga v3 em seus elementos -
#bs3 = lista de barras do banzo supeiro
#nbs3 = lista de nós do bazo superior
#dg3 e ndg3 para diagoains e bi3 e nbi3 para banzo inferior
bs3, nbs3, dg3, ndg3, bi3, nbi3 = Elementos_vigas(v3)
raAux = bi3[0]