def adjacentes(catalogo, vertice):
adjacentes = None
listapaises = lt.newList("ARRAY_LIST")
if m.contains(catalogo["capitales"], vertice):
adjacentes = gr.adjacents(catalogo["conexiones"], vertice)
elif m.contains(catalogo["invertices"], vertice):
adjacentes = gr.adjacents(
catalogo["conexiones"],
m.get(catalogo["invertices"], vertice)["value"])
if adjacentes != None:
for x in range(lt.size(adjacentes)):
elemento = lt.getElement(adjacentes, x)
if m.contains(catalogo["capitales"], elemento):
if not lt.isPresent(
listapaises,
m.get(catalogo["capitales"],
elemento)["value"]["CountryName"]):
lt.addLast(
listapaises,
m.get(catalogo["capitales"],
elemento)["value"]["CountryName"])
else:
data = m.get(catalogo["vertices"],
elemento)["value"]["name"].split(",")
if not lt.isPresent(listapaises, data[-1].strip(" ")):
lt.addLast(listapaises, data[-1].strip(" "))
return listapaises
def findCountriesFromAdjacents(graph, landingPoint):
list_adjacents = gr.adjacents(graph, landingPoint)
countries = []
for vertex in lt.iterator(list_adjacents):
adjacents_vertex = gr.adjacents(graph, vertex)
for adjacent in lt.iterator(adjacents_vertex):
countries.append(adjacent)
if landingPoint in adjacent:
otra_variable = gr.adjacents(graph, adjacent)
for otro_adjacente in lt.iterator(otra_variable):
countries.append(otro_adjacente)
return countries
def req6(analyzer, pais, cable):
vertices = gr.vertices(analyzer["connections_capacity"])
ciudad_cap = mp.get(analyzer["countries"],
pais)["value"]["CapitalName"].lower()
vertice_ciudad = (ciudad_cap, 0)
adyacentes_ciudad_cable = adyacentes_ciudad_cabl(analyzer, vertice_ciudad,
cable)
mapa_adyacentestotales = mp.newMap()
i = 1
while i <= lt.size(vertices):
vertice = lt.getElement(vertices, i)
if vertice[1] == cable:
pais_adyacente2 = mp.get(analyzer["landing_points_country"],
vertice[0])["value"]
poblacion = float(
mp.get(analyzer["countries"],
pais_adyacente2)["value"]["Population"].replace(
".", ""))
ii = 1
while ii <= lt.size(
gr.adjacents(analyzer["connections_capacity"], vertice)):
inicio2 = lt.getElement(
gr.adjacents(analyzer["connections_capacity"], vertice),
ii)
if inicio2[1] == cable:
inicio = inicio2
break
ii += 1
capacity_mbps = float(
gr.getEdge(analyzer["connections_capacity"], inicio,
vertice)["weight"]) * 1000000
valor = capacity_mbps / poblacion
if pais_adyacente2 != pais:
if mp.contains(mapa_adyacentestotales, pais_adyacente2):
valor_ant = mp.get(mapa_adyacentestotales,
pais_adyacente2)["value"]
if valor_ant < valor:
mp.put(mapa_adyacentestotales, pais_adyacente2, valor)
else:
mp.put(mapa_adyacentestotales, pais_adyacente2, valor)
i += 1
return mapa_adyacentestotales
def req5(catalog, lp):
grafo = catalog["connections"]
landing_points = catalog["landing_points"]
traductor = catalog["traduccion"]
try:
lp = lt.getElement(mp.get(traductor, lp)["value"], 1)
paises = mp.newMap(numelements=11, maptype="PROBING", loadfactor=0.3)
mp.put(paises, mp.get(landing_points, lp)["value"][2], None)
cables = mp.keySet(mp.get(landing_points, lp)["value"][1])
for cable in lt.iterator(cables):
vertice = lp + "|" + cable
adjacents = gr.adjacents(grafo, vertice)
for adjacent in lt.iterator(adjacents):
try:
id = adjacent.split("|")[0]
pais = mp.get(landing_points, id)["value"][2]
mp.put(paises, pais, None)
except TypeError:
pass
except TypeError:
paises = mp.newMap(numelements=11, maptype="PROBING", loadfactor=0.3)
adjacents = gr.adjacents(grafo, lp)
for adjacent in lt.iterator(adjacents):
try:
id = adjacent.split("|")[0]
pais = mp.get(landing_points, id)["value"][2]
mp.put(paises, pais, None)
except TypeError:
pass
return paises
def req4(citibike, resis, inicio):
"William Mendez"
pendientes = [] #str del id
encontrados = {} #{llegada: (origen, duracion)}
primeros = gr.adjacents(citibike['graph'], inicio)
iterator = it.newIterator(primeros)
while it.hasNext(iterator):
element = it.next(iterator)
# print(element)
durac = ed.weight(gr.getEdge(citibike['graph'], inicio, element)) / 60
if durac <= resis:
encontrados[element] = (inicio, round(durac, 2))
pendientes.append(element)
while len(pendientes) > 0:
for i in pendientes:
adya = gr.adjacents(citibike['graph'], i)
if adya['size'] != 0:
# print(adya)
iterator = it.newIterator(adya)
while it.hasNext(iterator):
element = it.next(iterator)
# print(element)
if element not in encontrados.keys() and \
element not in pendientes and element != inicio:
durac = 0
llega = i
# print(i, element)
while llega != inicio:
# print(durac)
durac += encontrados[llega][1]
llega = encontrados[llega][0]
# print(durac)
relativ = ed.weight(
gr.getEdge(citibike['graph'], i, element)) / 60
# print(durac, relativ, durac + relativ, resis)
if (durac + relativ) <= resis:
encontrados[element] = (i, round(relativ, 2))
pendientes.append(element)
pendientes.remove(i)
# print(len(pendientes))
# print(encontrados)
return encontrados
def req5(analyzer, inputLP):
"""Recibe un LP de interés. Retorna una lista de los países (adyacentes) ordenados descendentemente según su distancia.
Args:
analyzer
inputLP (str): Landing Point de interés del usuario.
Returns:
sorted_list (ARRAY_LIST): Lista ordenada.
"""
verticesConectados = gr.adjacents(
analyzer['landingPoints'],
inputLP) # Se obtienen los adyacentes del LP que entra por parámetro.
numeros = '0123456789'
listaPaisesAfectados = lt.newList('ARRAY_LIST')
for lp in lt.iterator(verticesConectados):
if lp[0] not in numeros:
pais = {
'nombre':
lp.split('-')[1],
'weight':
gr.getEdge(analyzer['landingPoints'], inputLP, lp)['weight']
}
lt.addLast(listaPaisesAfectados,
pais) # Se agregan los LP adyacentes en una lista.
return sortMenorDistancia(listaPaisesAfectados)
def getCountriesInLp(analyzer, lp):
lpId = None
lpCountry = None
countries = []
for landingpoint in lt.iterator(analyzer['landingPointsGeo']):
location = landingpoint['name'].split(', ')
if location[0] == lp:
lpId = landingpoint['landing_point_id']
lpCountry = location[-1]
break
entry = m.get(analyzer['landingPoints'], lpId)
lstroutes = entry['value']
for route in lt.iterator(lstroutes):
vertex = lpId + '-' + route
adjacents = gr.adjacents(analyzer['connections'], vertex)
for vertexadj in lt.iterator(adjacents):
vertexid = vertexadj.split('-')[0]
for landingpoint in lt.iterator(analyzer['landingPointsGeo']):
if landingpoint['landing_point_id'] == vertexid:
newcountry = landingpoint['name'].split(', ')[-1]
found = False
for country in countries:
if country[0] == newcountry:
found = True
break
if not found and newcountry != lpCountry:
distancia = gr.getEdge(analyzer['connections'], vertex,
vertexadj)['weight']
countries.append((newcountry, distancia))
break
countries.sort(key=lambda x: x[1], reverse=True)
return countries
def segunda_consulta(citibike, time1, time2, identificador):
present = gr.containsVertex(citibike['graph'], identificador)
if present == True:
nombre_inicial = identificador
#nombre_final = ""
dicc = {}
lista = lt.newList(cmpfunction=compareroutes)
tiempo_total = abs(int(time1) - int(time2))
citibike['components'] = numSCC_2(citibike['graph'])
number = numSCC(citibike['graph'])
key = gr.adjacents(citibike['graph'], nombre_inicial)
tiempo = 0
ite = it.newIterator(key)
while tiempo < tiempo_total and it.hasNext(ite):
pro = it.next(ite)
pertenecer = sameCC(citibike['components'], nombre_inicial, pro)
if pertenecer == True:
peso = gr.getEdge(citibike["graph"], nombre_inicial, pro)
p = peso["weight"]
res = abs(tiempo_total - (p + 20))
tiempo = res
dicc["inicial"] = nombre_inicial
dicc["final"] = pro
dicc["tiempo"] = peso
lt.addLast(lista, dicc)
nombre_inicial = pro
#nombre_final = pro
answer = (number, lista)
else:
answer = "La estación no es válida, ingrese otra. "
return answer
def ruta_circula(graph, ref_table, tiempo, id_estacion):
vertices = gr.vertices(graph)
it_vertices = it.newIterator(vertices)
list_station = []
while it.hasNext(it_vertices):
actual_vertex = it.next(it_vertices)
if id_estacion == actual_vertex:
confirmador = gr.adjacents(graph, id_estacion)
it_confirmador = it.newIterator(confirmador)
while it.hasNext(it_confirmador):
ad_vertex = it.next(it_confirmador)
pt1 = Camino_corto(graph, ad_vertex, id_estacion)
if pt1:
if not lt.isEmpty(pt1):
estacion_final = lt.firstElement(pt1)
final = conversor_id_nombre(estacion_final["vertexA"],
ref_table)
final2 = conversor_id_nombre(estacion_final["vertexB"],
ref_table)
peso = estacion_final["weight"]
list_station.append((final, final2, peso))
for i in list_station:
if i[2] > tiempo:
list_station.remove(i)
return list_station
def ruta(analyzer, lst, path, vert, res):
routePath = path["path"]
vertLst = gr.adjacents(analyzer["trips"], vert)
iterator = it.newIterator(vertLst)
while it.hasNext(iterator):
element = it.next(iterator)
edge = gr.getEdge(analyzer["trips"], vert, element)
time = edge["weight"] + path["time"]
posibRoutes = 0
if (float(time) <= float(res)) and (element not in routePath):
if posibRoutes > 0:
route = newRoute()
route["path"] = routePath + "-" + edge["vertexB"]
route["time"] = time
lstTimes = route["Seg"]
lt.addLast(lstTimes,
(vert + "-" + edge["vertexB"], edge["weight"]))
lt.addLast(lst, route)
else:
route["path"] = routePath + "-" + edge["vertexB"]
route["time"] = time
lstTimes = route["Seg"]
lt.addLast(lstTimes,
(vert + "-" + edge["vertexB"], edge["weight"]))
posibRoutes += 1
ruta(analyzer, lst, route, edge["vertexB"], res)
return lst
def req2(analizer,limiteinf,limite,verticei):
grafo=analizer['connections']
sc = scc.KosarajuSCC(grafo)
componente_inicio=m.get(sc['idscc'],verticei)['value']
iterator=it.newIterator(m.keySet(sc['idscc']))
verticesfc=lt.newList(cmpfunction=compareroutes)
while it.hasNext(iterator):
proximo=it.next(iterator)
c_proximo=m.get(sc['idscc'],proximo)['value']
if c_proximo == componente_inicio: #Que el componente sea el mismo
lt.addLast(verticesfc,proximo)
adyacentes=gr.adjacents(grafo,verticei)
iterator=it.newIterator(verticesfc)
rutasposibles=[]
while it.hasNext(iterator):
proximo=it.next(iterator)
if lt.isPresent(adyacentes,proximo):
dfs3 = dfs.DepthFirstSearchSCC(grafo,proximo,verticesfc)
if dfs.pathTowithLimiter(dfs3,verticei,grafo,limite) != None:
rutachikita,tiempo=dfs.pathTowithLimiter(dfs3,verticei,grafo,limite)
lt.removeLast(rutachikita)
if limiteinf<tiempo<limite:
rutasposibles.append({"First":m.get(analizer['nameverteces'],lt.firstElement(rutachikita))['value'],"Last":m.get(analizer['nameverteces'],lt.lastElement(rutachikita))['value'],"Duracion":tiempo/60})
return rutasposibles
def req4(citibike, TiempoResistencia, IdEstacionI):
tiempoRuta = 0
if gr.containsVertex(citibike["graph"], IdEstacionI):
verticesAdy = gr.adjacents(citibike["graph"], IdEstacionI)
z = m.get(citibike["namesI"], IdEstacionI)
nombreX = en.getValue(z)
nombreI = nombreX["nombre"]
else:
return ("La estación escogida no existe")
listaFinal = []
if verticesAdy["size"] == 0:
print("La estación escogida no tiene estaciones adyacentes")
else:
for i in range(0, (verticesAdy["size"] + 1)):
tiempoRuta = 0
listaRuta = lt.newList("SINGLED_LINKED")
listaArcos = []
vertice = lt.getElement(verticesAdy, i)
lt.addLast(listaRuta, vertice)
valorArco = gr.getEdge(citibike["graph"], IdEstacionI,
vertice)["weight"]["duracion"]
listaArcos.append(valorArco)
tiempoRuta = int(valorArco)
req4Parte2(citibike, TiempoResistencia, vertice, tiempoRuta,
listaRuta, listaFinal, IdEstacionI, listaArcos, nombreI)
return listaFinal
def req2Parte2(citibike, TiempoI, TiempoF, vertice, tiempoRuta, listaFinal,
IdEstacionI, listaRuta, listaArcos):
verticesAdy = gr.adjacents(citibike["graph"], vertice)
if (verticesAdy["size"] == 0):
if int(tiempoRuta) >= int(TiempoI) and int(tiempoRuta) <= int(
TiempoF) and (str(listaRuta) + ": " + str(tiempoRuta) + "s "
not in listaFinal):
print("o")
listaFinal.append(str(listaRuta) + ": " + str(tiempoRuta) + "s ")
longitud = len(listaArcos)
if longitud != 0:
x = listaArcos.pop(len(listaArcos) - 1)
tiempoRuta -= int(x)
y = listaRuta.pop(len(listaRuta) - 1)
elif (verticesAdy["size"] != 0):
for j in range(0, (verticesAdy["size"] + 1)):
vertice2 = lt.getElement(verticesAdy, j)
valorArco2 = int(
gr.getEdge(citibike["graph"], vertice,
vertice2)["weight"]["duracion"])
if int(valorArco2) <= int(TiempoF):
tiempoRuta += valorArco2
listaArcos.append(valorArco2)
listaRuta.append(vertice2)
req2Parte2(citibike, TiempoI, TiempoF, vertice2, tiempoRuta,
listaFinal, IdEstacionI, listaRuta, listaArcos)
return listaFinal
def Requirement2(analyzer):
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = getTime()
start_memory = getMemory()
vertices = gr.vertices(analyzer["connections_origin_destination"])
size_max = 0
iterator1 = it.newIterator(vertices)
while it.hasNext(iterator1):
element = it.next(iterator1)
adjacents = gr.adjacents(analyzer["connections_origin_destination"],
element)
size = lt.size(adjacents)
if size >= size_max:
size_max = size
result = greaterLandingPoint(analyzer, element)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return size_max, result, delta_time, delta_memory
def dfsVertexc(search, graph, vertex, source, sc):
try:
adjlst = gr.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjlst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
visited = m.get(search['visited'], w)
if visited is None:
m.put(search['visited'], w, {'marked': True, 'edgeTo': vertex})
if scc.stronglyConnected(sc, w, source):
dfsVertexc(search, graph, w, source, sc)
elif w == source and gr.getEdge(graph, vertex, source) != None:
cycle = lt.newList()
lt.addLast(cycle, vertex)
lt.addLast(cycle, w)
x = me.getValue(m.get(search['visited'], vertex))['edgeTo']
while x != None:
lt.addFirst(cycle, x)
x = me.getValue(m.get(search['visited'], x))['edgeTo']
lt.addLast(search['cycles'], cycle)
return search
except Exception as exp:
error.reraise(exp, 'dfs:dfsVertex')
def req5(datos, landingpoint):
vertices = gr.vertices(datos['cables'])
tamano = lt.size(vertices)
p = 0
e = 0
final = []
paises = mp.keySet(datos['pais'])
pais = []
numero = 0
while p < int(tamano):
b = lt.getElement(vertices, p)
if landingpoint in b:
j = gr.adjacents(datos['cables'], b)
l = 0
while l < lt.size(j):
l += 1
y = lt.getElement(j, l)
x = y.split('-')
if x[0] not in pais:
pais.append(x[0])
numero += 1
p += 1
while e < lt.size(paises):
w = (lt.getElement(paises, e).lower()).replace(' ', '')
esta(w, pais, final)
e += 1
return final
def fallas(analyzer, name):
LPid = me.getValue(mp.get(analyzer['LPnames'], name))#id del LP.
afectados = gr.adjacents(analyzer['cables'], LPid)
paises = mp.newMap(37,comparefunction=LPids)
paisesSet = set()
ltSort = lt.newList('ARRAY_LIST', cmpfunction=LPids)
try:
for vertex in lt.iterator(afectados):
pais = me.getValue(mp.get(analyzer['landingPoints'], vertex))[2]
pais = pais.split(',')[1].strip() #Saca el país, quita la ciudad.
paisesSet.add(pais)
arc = gr.getEdge(analyzer['cables'], LPid, vertex)
if mp.contains(paises, pais):
lt.addLast(me.getValue(mp.get(paises, pais)), arc)
if not mp.contains(paises, pais):
mp.put(paises, pais, lt.newList('ARRAY_LIST', cmpfunction=LPids))
lt.addLast(me.getValue(mp.get(paises, pais)), arc)
for pais in paisesSet:
ltP = me.getValue(mp.get(paises, pais))
ltPO = sortMaster(ltP, cmpArcW)
mp.put(paises, pais, ltPO)#Pone la lista en orden.
primero = lt.firstElement(ltPO)#solo compara el cable más largo de ese país.
lt.addLast(ltSort, (pais, primero))
ltFinal = sortMaster(ltSort, cmpWtuple)
return len(list(paisesSet)), ltFinal
except Exception as exp:
error.reraise(exp, 'model:Fallas')
def hayarEstaciones(cont, initialStation):
informacion = gr.adjacents(cont["connections"], initialStation)
lista=[]
if stack.isEmpty(informacion) == False:
for i in range(0, stack.size(informacion)):
sub_pila = stack.pop(informacion)
lista.append(sub_pila)
return lista
def greaterDegree(ana):
congr = ana['connections']
vertices = gr.vertices(congr)
countries = ana['countries']
points = ana['points']
keysCountries = m.keySet(countries)
mayor = -1
llaves = []
size = lt.size(vertices)
for i in range(0, size):
vertex = lt.getElement(vertices, i)
degree = gr.degree(ana['connections'], vertex)
if degree > mayor:
mayor = degree
llaves = []
llaves.append(vertex)
elif degree == mayor:
llaves.append(vertex)
mayores = lt.newList()
M = folium.Map()
for llave in llaves:
encontrado = False
i = 0
while i < lt.size(keysCountries) and encontrado == False:
country = lt.getElement(keysCountries, i)
info = me.getValue(m.get(countries, country))
cap = info['CapitalName']
if cap == llave:
encontrado = True
lat = info['CapitalLatitude']
lon = info['CapitalLongitude']
loc = lat, lon
name = country + ', ' + cap
folium.Marker(loc,
name,
icon=folium.Icon(color='red',
icon_color='white')).add_to(M)
adj = gr.adjacents(congr, llave)
for i in range(0, lt.size(adj)):
vert = lt.getElement(adj, i)
code = vert.split('*')[0]
info = me.getValue(m.get(points, code))
latP = info['latitude']
lonP = info['longitude']
locP = latP, lonP
name = info['name']
folium.Marker(
locP,
name,
icon=folium.Icon(color='green',
icon_color='white')).add_to(M)
M.save('greater.html')
i += 1
retorno = llave, country
lt.addLast(mayores, retorno)
return mayores, mayor
def adyacentes_ciudad_cabl(analyzer, vertice_ciudad, cable):
lista_adyacentes = gr.adjacents(analyzer["connections_capacity"],
vertice_ciudad)
lista_adyacentes_cable = lt.newList(datastructure="ARRAY_LIST")
i = 1
while i <= lt.size(lista_adyacentes):
adyacente = lt.getElement(lista_adyacentes, i)
if adyacente[1] == cable:
lt.addLast(lista_adyacentes_cable, adyacente)
i += 1
return lista_adyacentes_cable
def req5(catalog, lpoint):
points = gr.adjacents(catalog['connections'], lpoint)
points_list = lt.newList()
for adjacent in lt.iterator(points):
distance = (gr.getEdge(catalog['connections'], lpoint,
adjacent))['weight']
name = ((mp.get(catalog['landing_points'],
adjacent))['value']['name'].split(","))[1]
if not lt.isPresent(points_list, [name, distance]):
lt.addLast(points_list, [name, distance])
sorted_points = sa.sort(points_list, cmpPointslist)
return sorted_points
def Requirement5(analyzer, landingPoint):
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = getTime()
start_memory = getMemory()
found = False
keys = mp.keySet(analyzer['landing_points_map'])
while found != True:
for i in range(0, lt.size(keys)):
name = lt.getElement(keys, i)
if landingPoint in name:
found = True
id = (mp.get(analyzer['landing_points_map'],
name)['value'])['landing_point_id']
vertexName = mp.get(analyzer['connections_map'], id)['value']
connectedComponents = gr.adjacents(
analyzer['connections_origin_destination'], vertexName)
countries = lt.newList('ARRAY_LIST')
print(connectedComponents)
iterator1 = it.newIterator(connectedComponents)
while it.hasNext(iterator1):
component = it.next(iterator1)
print(component)
id4Digits = component[0:4]
print(id4Digits)
print(mp.get(analyzer['landing_points_mapID'], id4Digits)['value'])
name = (mp.get(analyzer['landing_points_mapID'],
id4Digits)['value'])['name']
country = (name.split(','))[-1]
lt.addLast(countries, country)
size = lt.size(countries)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return (size, countries, delta_time, delta_memory)
def impact(ana, vertex):
rela = ana['relatedVertex']
points = ana['points']
congr = ana['connections']
pointKeys = m.keySet(points)
I = folium.Map()
j = 0
encontrado = False
while j < lt.size(pointKeys) and encontrado == False:
key = lt.getElement(pointKeys, j)
LPoint = me.getValue(m.get(points, key))
city = LPoint['name'].split(',')[0]
if vertex == city:
id = LPoint['landing_point_id']
encontrado = True
pLat = LPoint['latitude']
pLon = LPoint['longitude']
pLoc = pLat, pLon
pName = LPoint['name']
folium.Marker(pLoc, pName, icon=folium.Icon(color='red')).add_to(I)
j += 1
vertices = me.getValue(m.get(rela, id))
countries = lt.newList(cmpfunction=compareDistance)
llaves = []
for i in range(0, lt.size(vertices)):
vert = lt.getElement(vertices, i)
adyList = gr.adjacents(congr, vert)
for k in range(0, lt.size(adyList)):
ady = lt.getElement(adyList, k)
initial = ady.split('*')[0]
try:
code = int(initial)
lPoint = me.getValue(m.get(points, str(code)))
country = lPoint['name'].split(',')[-1]
country = country.strip()
name = lPoint['name']
lat = lPoint['latitude']
lon = lPoint['longitude']
loc = lat, lon
if country != 'Brazil':
folium.Marker(loc, name,
icon=folium.Icon(color='orange')).add_to(I)
distance = gr.getEdge(congr, vert, ady)['weight']
info = country, distance
if country not in llaves:
llaves.append(country)
lt.addLast(countries, info)
except:
pass
I.save('impact.html')
sorted = sortCountries(countries)
return sorted
def graphicateReq2(analyzer, definitiva):
map2 = folium.Map()
vertice = mp.get(analyzer['LP_lat_long'], definitiva[0][0])['value']
folium.Marker(vertice).add_to(map2)
adyacentes = gr.adjacents(analyzer['connections'], definitiva[0][0])
gral_list = []
for i in lt.iterator(adyacentes):
adj = gr.adjacents(analyzer['connections'], i)
for k in lt.iterator(adj):
if definitiva[0][0] not in k:
gral_list.append(k)
for i in gral_list:
split = i.split('-')
split = split[0]
if float(split) < 20000:
verticei = mp.get(analyzer['LP_lat_long'], split)['value']
folium.Marker(verticei).add_to(map2)
route = [vertice, verticei]
folium.PolyLine(route).add_to(map2)
else:
split2 = i.split("Capital Connection ")
split2 = split2[1]
countri = mp.get(analyzer['countries2'], split2)['value']
verticei = [float(countri['CapitalLatitude']), float(
countri['CapitalLongitude'])]
folium.Marker(verticei).add_to(map2)
route = [vertice, verticei]
folium.PolyLine(route).add_to(map2)
direction = cf.data_dir + 'MapREQ2.html'
map2.save(direction)
def totalTrips(analyzer):
master = analyzer["connections"]
vertex = gr.vertices(master)
iterator = it.newIterator(vertex)
trips = []
while it.hasNext(iterator):
element = it.next(iterator)
adjacents = gr.adjacents(master,element)
iterator2 = it.newIterator(adjacents)
while it.hasNext(iterator2) and element != None:
element2 = it.next(iterator2)
pair = (element,element2)
if pair not in trips and (element2,element) not in trips:
trips.append(pair)
return len(trips)
def affectedLPs(macrostructure, lp):
answer = []
affected = []
vertex = lt.getElement((mp.get(macrostructure['lp-names'], lp))['value'],
2)
x = gr.adjacents(macrostructure['connections'], vertex)
y = gr.degree(macrostructure['connections'], vertex)
answer.append(y)
for index in range(1, int(lt.size(x)) + 1):
data = lt.getElement(x, index)
pais = lt.getElement(mp.get(macrostructure['lp'], data)['value'], 2)
edge = gr.getEdge(macrostructure['connections'], vertex, data)
print(edge)
affected.append(pais)
answer.append(affected)
return answer
def requerimiento8(catalog):
m = folium.Map(location=[4.6, -74.083333], tiles="Stamen Terrain")
vertice = gr.vertices(catalog['connections'])
for v in lt.iterator(vertice):
cv = v.split("-", 1)
infov = mp.get(catalog['points'], cv[0])['value']
folium.Marker([float(infov['latitude']), float(infov['longitude'])], popup=str(infov['name'])).add_to(m)
ad = gr.adjacents(catalog['connections'], v)
for e in lt.iterator(ad):
ce = e.split("-", 1)
infoe = mp.get(catalog['points'], ce[0])['value']
folium.PolyLine(locations=[(float(infov['latitude']), float(infov['longitude'])), (float(infoe['latitude']), float(infoe['longitude']))], tooltip=str(cv[1])).add_to(m)
m.save('mapa_req1.html')
return m
def rutaInteresTuristico(analyzer, latlocal, longlocal, latfinal,
longfinal): #Req. 6
StationName = m.valueSet(analyzer['stationsName'])
iterator = it.newIterator(StationName)
minimal = 1000000000000
nameminimal = ''
minimal1 = 1000000000000
nameminimal1 = ''
while it.hasNext(iterator):
actual = it.next(iterator) #lista
iterator2 = it.newIterator(actual)
while it.hasNext(iterator2):
actual2 = it.next(iterator2)
coordenate = m.get(
analyzer['Latitude&Longitude'], actual2
) #tupla latitude=(coordenate['value'][0]) y longitude=(coordenate['value'][1])
latlst = (coordenate['value'][0])
longlst = (coordenate['value'][1])
ATS = distance(latlocal, latlst, longlocal, longlst)
STP = distance(latlst, latfinal, longlst, longfinal)
if ATS < minimal:
nameminimal = coordenate['key']
minimal = ATS
if STP < minimal1:
nameminimal1 = coordenate['key']
minimal1 = STP
duration = float(m.get(
analyzer['StationTripTime'], nameminimal)['value']) + float(
m.get(analyzer['StationTripTime'], nameminimal1)['value'])
nameminimalid = m.get(analyzer['StationsById'], nameminimal)
lst = gr.adjacents(analyzer['graph'], nameminimalid['value'])
Keys = m.keySet(analyzer['StationsById'])
iterator3 = it.newIterator(Keys)
lstres = lt.newList()
while it.hasNext(iterator3):
actual9 = it.next(iterator3)
Value = m.get(analyzer['StationsById'], actual9)
iterator4 = it.newIterator(lst)
while it.hasNext(iterator4):
actual8 = it.next(iterator4)
if actual8 == Value['value']:
lt.addLast(lstres, actual9)
#####
return (nameminimal, nameminimal1, duration, lstres)
def rutaCircular(analyzer, estacion, tiempoin, tiempofin):
if m.get(analyzer['stationsStart'],estacion) is not None:
lista1 = lt.newList("ARRAY_LIST")
adyacentes = gr.adjacents(analyzer['graph'], estacion)
connectedComponents(analyzer)
for h in range (adyacentes['size']):
adyacente= lt.getElement(adyacentes,h)
fcc = sameCC(analyzer, estacion, adyacente)
if fcc:
tiempo=0
analyzer['paths'] = dfs.DepthFirstSearch(analyzer["graph"], adyacente)
caminos = dfs.pathTo(analyzer["paths"], estacion)
primero= caminos['first']
siguiente = primero['next']
for i in range(caminos['size']-1):
infoin = primero['info']
if siguiente is not None:
infoul = siguiente['info']
arco = gr.getEdge(analyzer["graph"], infoin, infoul)
if arco is not None:
tiempo += float(arco["weight"])
primero = primero['next']
siguiente = siguiente['next']
suma = float(caminos['size'])*1200
tiempo+=suma
lt.addLast(caminos,tiempo)
lt.addLast(lista1, caminos)
listafinal= lt.newList("ARRAY_LIST")
if lista1 is not None:
tmi = int(tiempoin)*60
tmf = int(tiempofin)*60
while (not stack.isEmpty(lista1)):
parada = stack.pop(lista1)
if float(parada['last']['info']) >= tmi and float(parada['last']['info']) <= tmf:
lt.addLast(listafinal, parada)
print("la cantidad de rutas es : "+ str(listafinal['size']))
for i in range( listafinal['size'] ):
actual = lt.getElement(listafinal,i)
print("ruta no: "+ str(i+1))
for j in range(actual['size']-1):
info= m.get(analyzer['stationsStart'], lt.getElement(actual,j))['value']
print(str(j+1)+". " + info["nombre"])
print("con una duracion estimada de: "+str(int(actual['last']['info'])/60)+" minutos")
def req4Parte2(citibike, TiempoResistencia, vertice, tiempoRuta, listaRuta,
listaFinal, IdEstacionI, listaArcos, nombreI):
verticesAdy = gr.adjacents(citibike["graph"], vertice)
if verticesAdy["size"] == 0:
if int(tiempoRuta) <= int(
TiempoResistencia) and vertice != IdEstacionI:
o = m.get(citibike["namesF"], vertice)
nombreO = en.getValue(o)
nombreP = nombreO["nombre"]
if (nombreI + " - " + nombreP + ": " + str(tiempoRuta) +
"s ") not in listaFinal:
listaFinal.append(nombreI + " - " + nombreP + ": " +
str(tiempoRuta) + "s ")
y = lt.removeLast(listaRuta)
longitud = len(listaArcos)
if longitud != 0:
x = listaArcos.pop(len(listaArcos) - 1)
tiempoRuta -= int(x)
elif (verticesAdy["size"] != 0):
for j in range(0, (verticesAdy["size"] + 1)):
vertice2 = lt.getElement(verticesAdy, j)
valorArco2 = int(
gr.getEdge(citibike["graph"], vertice,
vertice2)["weight"]["duracion"])
tiempoRuta += valorArco2
listaArcos.append(valorArco2)
if listaRuta["size"] == 0:
None
elif (vertice2 in listaRuta
or int(tiempoRuta) > int(TiempoResistencia)):
None
elif int(tiempoRuta) <= int(TiempoResistencia):
r = m.get(citibike["namesF"], vertice2)
nombreE = en.getValue(r)
nombreT = nombreE["nombre"]
if (nombreI + " - " + nombreT + ": " + str(tiempoRuta) +
"s ") not in listaFinal:
listaFinal.append(nombreI + " - " + nombreT + ": " +
str(tiempoRuta) + "s ")
lt.addLast(listaRuta, vertice2)
req4Parte2(citibike, TiempoResistencia, vertice2, tiempoRuta,
listaRuta, listaFinal, IdEstacionI, listaArcos,
nombreI)
return listaFinal
