def add_triangulo(self, v1, v2, v3):
a1 = Arista(v1, v2)
a2 = Arista(v2, v3)
a3 = Arista(v3, v1)
self.triangulacion.agregar_arista(a1)
self.triangulacion.agregar_arista(a2)
self.triangulacion.agregar_arista(a3)
def removeV(self, v):
siguiente = self.siguiente(v)
anterior = self.anterior(v)
self.vertices.remove(v)
#if self.orientacion == 1:
self.aristas.remove(Arista(v, siguiente))
self.aristas.remove(Arista(anterior, v))
self.aristas.append(Arista(anterior, siguiente))
def getVConvexo(self):
'''Determina un vertice convexo en P, un vertice convexo es aquel cuyo angulo interior es menor o igual a 180 grados'''
for v in self.vertices:
u = self.siguiente(v)
w = self.anterior(v)
a = Arista(w, v)
if a.lado_p_arista(u) == 'der':
return v
return False
def addVertice_XY(self, x1, y1): '''agrega un vertice nuevo, a partir de sus coordenadas x, y, a la lista de vertices del poligono''' v = Punto(x1, y1) if self.checaInterseccion(v): return False else: if self.esVacio(): self.vertices = self.vertices + [Punto(x1, y1)] elif self.cierraPoligono(v): self.aristas = self.aristas + [Arista(self.vertices[-1], self.vertices[0])] else: self.aristas = self.aristas + [Arista(self.vertices[-1], Punto(x1, y1))] self.vertices = self.vertices + [Punto(x1, y1)] return True
def cerrar(self):
'''Cierra el poligono uniendo el primer y el ultimo vertice'''
self.aristas = self.aristas + [
Arista(self.vertices[-1], self.vertices[0])
]
self.cerrado = True
self.calculaOrientacion()
def addV(self, v):
'''Inserta un vertice en el poligono sin hacer ninguna verificacion'''
if self.esVacio():
self.vertices = self.vertices + [v]
else:
self.aristas = self.aristas + [Arista(self.vertices[-1], v)]
self.vertices = self.vertices + [v]
def addConexion(self,nodo1,nodo2,distancia=0,edad=0):
if nodo1 in [i[0] for i in nodo2.vecinos] or nodo1==nodo2:
#print ("Denegado: ",nodo1.id,nodo2.id)
return
arista=Arista(nodo1,nodo2,edad,distancia)
nodo1.vecinos.append((nodo2,arista))
nodo2.vecinos.append((nodo1,arista))
self.aristas.append(arista)
def ubica_pto_inicio(self, recta_dir, lista):
''' '''
# se crea una arista con los puntos que definen a recta_dir para utilizar el metodo lado_p_a_arista
a = Arista(recta_dir.a, recta_dir.b)
derecha = False
re_ordenados = []
i = 0
for p in lista:
if (a.lado_p_a_arista(p) == 'izq' and derecha):
re_ordenados = lista[i:] + re_ordenados
return re_ordenados
else:
if (a.lado_p_a_arista(p) == 'der'):
derecha = True
re_ordenados.append(p)
i += 1
return re_ordenados
def checaInterseccion(self, v):
'''checa si la nueva arista construida con el vertice v intersecta a las aristas ya definidas'''
if self.esVacio():
return False
else:
b = Arista(self.vertices[-1], v)
for a in self.aristas:
if a.intersecta(b):
print("interseccion")
return True
return False
def addVertice(self, v): '''agrega un vertice nuevo a la lista de vertices del poligono''' if self.checaInterseccion(v): return False else: if self.esVacio(): self.vertices = self.vertices + [v] else: self.aristas = self.aristas + [Arista(self.vertices[-1],v)] self.vertices = self.vertices + [v] return True
def triangular(self):
ordenados = self.ordena_puntos()
self.add_triangulo(ordenados[0], ordenados[1], ordenados[2])
visitados = [ordenados[0], ordenados[1], ordenados[2]]
for i in range(len(ordenados) - 3):
#print("--------------------------------------------")
#print("punto: "+ordenados[i+3].toString())
aristas_triang = self.triangulacion.get_aristas()
for v in visitados:
#print(self.triangulacion.toString())
arista = Arista(ordenados[i + 3], v)
interseccion = False
for a in aristas_triang:
if arista.intersecta(a):
#print(arista.toString()+" y "+a.toString()+" se intersectan")
interseccion = True
else:
#print(arista.toString()+" y "+a.toString()+" no se intersectan")
continue
if not (interseccion):
self.triangulacion.agregar_arista(arista)
visitados.append(ordenados[i + 3])
self.dcel_triangulacion.construir(self.triangulacion)
def get_oreja(self, poligono):
t = Poligono()
vertices = poligono.getVertices()
es_oreja = True
for v in vertices:
t.limpiaPoligono()
print("-------------------------------------------------------")
print("analizando el vertice " + v.toString())
v_i = poligono.anterior(v)
v_j = poligono.siguiente(v)
t.addV(v)
t.addV(v_i)
t.addV(v_j)
t.cerrar()
#print("v: "+v.toString()+" v_i: "+v_i.toString()+" v_j: "+v_j.toString())
s = Segmento(v_i, v)
if poligono.getOrientacion() == 1:
lado_interior = "der"
else:
lado_interior = "izq"
if s.lado_p(v_j) == lado_interior or s.lado_p(v_j) == "col":
continue
else:
v_restantes = vertices[:]
v_restantes.remove(v)
v_restantes.remove(v_i)
v_restantes.remove(v_j)
es_oreja = True
for u in v_restantes:
print(t.isInterior(u))
if t.isInterior(u):
print("el punto " + u.toString() +
" esta en el interior interior del triangulo: " +
t.toString() + " :(")
es_oreja = False
if es_oreja:
return (t, Arista(v_i, v_j), v)
return False
def agregaarista(self, source, target):
id = str(source) + " -- " + str(target)
idx = id
# Si no es dirigido comprobar que no existe la arista en ambos sentidos
if not self.dirigido:
idx = str(target) + " -- " + str(source)
if self.existearista(id) == 1 or self.existearista(idx) == 1:
# print(" ya existe arista " + id + " or " + idx)
agregada = 0
else:
# Si no existe la arista, verificar que sí existen los nodos
if self.existenodo(source) == 0 or self.existenodo(target) == 0:
# print(" no existe el nodo " + str(source) + " o el nodo " + str(target))
agregada = 0
else:
# Crear la arista y agregarla al conjunto de aristas del grafo
nuevaarista = Arista(id, str(source), str(target))
self.aristas.add(nuevaarista)
agregada = 1
# Incrementar el grado de los vértices de la arista
self.incrementagradoalnodo(source)
self.incrementagradoalnodo(target)
# Devolver si la arista fue o no agregada
return agregada
def vm_connect(self):
self.vm_handle = Arista(self.neigh_vm, None, self.test_args)
self.vm_handle.connect()
class SadPath(object):
def __init__(self, oper_type, vm_list, portchannel_ports, vm_dut_map,
test_args):
self.oper_type = oper_type
self.vm_list = vm_list
self.portchannel_ports = portchannel_ports
self.vm_dut_map = vm_dut_map
self.test_args = test_args
self.neigh_vm = None
self.neigh_name = None
self.vm_handle = None
self.neigh_bgp = None
self.dut_bgp = None
self.log = []
self.fails = dict()
self.fails['dut'] = set()
def cmd(self, cmds):
process = subprocess.Popen(cmds,
shell=False,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = process.communicate()
return_code = process.returncode
return stdout, stderr, return_code
def select_vm(self):
self.vm_list.sort()
# use the day of the month to select a VM from the list for the sad pass operation
vm_index = datetime.datetime.now().day % len(self.vm_list)
self.neigh_vm = self.vm_list.pop(vm_index)
def get_neigh_name(self):
for key in self.vm_dut_map.keys():
if self.vm_dut_map[key]['mgmt_addr'] == self.neigh_vm:
self.neigh_name = key
break
def down_neigh_port(self):
# extract ptf ports for the selected VM and mark them down
for port in self.vm_dut_map[self.neigh_name]['ptf_ports']:
self.portchannel_ports.remove(port)
def vm_connect(self):
self.vm_handle = Arista(self.neigh_vm, None, self.test_args)
self.vm_handle.connect()
def __del__(self):
self.vm_disconnect()
def vm_disconnect(self):
self.vm_handle.disconnect()
def setup(self):
self.select_vm()
self.get_neigh_name()
self.down_neigh_port()
self.vm_connect()
self.neigh_bgp, self.dut_bgp = self.vm_handle.get_bgp_info()
self.fails[self.neigh_vm] = set()
self.log.append('Neighbor AS: %s' % self.neigh_bgp['asn'])
self.log.append('BGP v4 neighbor: %s' % self.neigh_bgp['v4'])
self.log.append('BGP v6 neighbor: %s' % self.neigh_bgp['v6'])
self.log.append('DUT BGP v4: %s' % self.dut_bgp['v4'])
self.log.append('DUT BGP v6: %s' % self.dut_bgp['v6'])
def retreive_test_info(self):
return self.vm_list, self.portchannel_ports, self.neigh_vm
def retreive_logs(self):
return self.log, self.fails['dut'], self.fails[self.neigh_vm]
def agregarArista(self, nodo1, nodo2, peso): arista = Arista(nodo1, nodo2, peso) self.adyacencias[nodo1].append(arista)
def getAristasIncidentes(self, v):
'''Regresa las aristas que incide el vertice v '''
a = (Arista(self.anterior(v), v), Arista(v, self.siguiente(v)))
return a
if __name__ == '__main__':
a = Punto(2, 4)
b = Punto(5, 2)
c = Punto(5, 1)
d = Punto(7, 3)
u = Punto(2, 2)
v = Punto(4, 4)
l1 = Recta(v, u)
l2 = Recta(c, d)
s = Arista(a, b)
print("Intersccion debe ser verdadera")
print("Recta l1" + l1.toString())
i_1 = l1.interseccion_segm(s)
print(i_1)
print("Interseccion debe ser falsa")
print("Recta l2 =" + l2.toString())
i_2 = l2.interseccion_segm(s)
print(i_2)
print("punto pendiente:")
print(Recta(Punto(3, 7), Punto(6, 4)).punto_pendiente())
l3 = Recta(Punto(4, 3), Punto(1, 6))
def addVertice_i(self, x, y, i): """Sobreescribe el vertice en la posicion i por el creado con las coordenadas x, y """ if i >= len(self.vertices) or i<0: return False v = Punto(x, y) print(i) if self.cerrado: if i == 0: a1 = Arista(self.vertices[-1], v) a2 = Arista(v, self.vertices[1]) elif i == len(self.vertices)-1: a1 = Arista(self.vertices[i-1], v) a2 = Arista(v, self.vertices[0]) else: a1 = Arista(self.vertices[i-1], v) a2 = Arista(v, self.vertices[i+1]) aristas_tmp = self.aristas[:] self.aristas[i-1] = a1 self.aristas[i] = a2 if self.checaInterseccionArista(a1) or self.checaInterseccionArista(a2): self.aristas = aristas_tmp return False else: self.vertices[i] = v return True else: aristas_tmp = self.aristas[:] if i == 0: #a1 = Arista(self.vertices[-1], v) a = Arista(v, self.vertices[1]) self.aristas[i] = a if self.checaInterseccionArista(a): self.aristas = aristas_tmp return False else: self.vertices[i] = v return True elif i == len(self.vertices)-1: a = Arista(self.vertices[i-1], v) self.aristas[-1] = a if self.checaInterseccionArista(a): self.aristas = aristas_tmp return False else: self.vertices[-1] = v return True else: a1 = Arista(self.vertices[i-1], v) a2 = Arista(v, self.vertices[i+1]) self.aristas[i-1] = a1 self.aristas[i] = a2 if self.checaInterseccionArista(a1) or self.checaInterseccionArista(a2): self.aristas = aristas_tmp return False else: self.vertices[i] = v return True
def vm_connect(self):
for neigh_vm in self.neigh_vms:
self.vm_handles[neigh_vm] = Arista(neigh_vm, None, self.test_args)
self.vm_handles[neigh_vm].connect()
def agregarArista(self, nodo1, nodo2, peso=1):
arista = Arista(self.vertices[nodo1], self.vertices[nodo2], peso)
self.aristas.append(arista)