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))