def plotMinimumCostPathMap(analyzer, vertexa, vertexb):
"""
Crea un mapa interactivo de la ruta de costo mínimo entre dos
puntos de conexión
"""
lstvertexs = controller.getMinimumCostPathVertexs(analyzer, vertexb)
lstcoordinates = controller.getPathCoordinates(analyzer, lstvertexs)
origincoords = lt.firstElement(lstcoordinates)
destcoords = lt.lastElement(lstcoordinates)
originpos = lt.isPresent(lstcoordinates, origincoords)
destpos = lt.isPresent(lstcoordinates, destcoords)
lt.removeFirst(lstcoordinates)
lt.removeLast(lstcoordinates)
map = folium.Map(origincoords, zoom_start=2.5)
for location in lt.iterator(lstcoordinates):
folium.Marker(location).add_to(map)
lt.insertElement(lstcoordinates, origincoords, originpos)
lt.insertElement(lstcoordinates, destcoords, destpos)
folium.Marker(origincoords,
str(vertexa.replace('-', ', ')),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
folium.Marker(destcoords,
str(vertexb.replace('-', ', ')),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
folium.PolyLine(lstcoordinates['elements'],
color="grey",
weight=2.5,
opacity=0.75).add_to(map)
map.save("map3.html")
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 total_antes_de_una_fecha(analyzer, fecha):
date = fecha_convertidor_consultas(fecha)
a = om.keys(analyzer["index"], om.minKey(analyzer["index"]), date)
lt.removeLast(a)
total = 0
it1 = lit.newIterator(a)
while lit.hasNext(it1):
n = lit.next(it1)
b = om.get(analyzer["index"], n)
c = me.getValue(b)
total += lt.size(c)
return total
def buscar_estaciones_top_ingreso(graph, reference_table):
""""Funcion para hallar los viajes que llegan a una estacion!"""
estaciones = lt.newList()
vertices = gr.vertices(graph)
it_vertice = it.newIterator(vertices)
while it.hasNext(it_vertice):
vert = it.next(it_vertice)
estacion = gr.indegree(graph, vert)
nombre = conversor_id_nombre(vert, reference_table)
lt.addLast(estaciones, (estacion, nombre))
merge.mergesort(estaciones, lessFunction)
final_top = []
for i in range(3):
top = lt.lastElement(estaciones)
final_top.append(top)
lt.removeLast(estaciones)
return final_top
def hallarTop(tabla, numero):
taxis = m.keySet(tabla)
puntos = m.valueSet(tabla)
mrg.mergesort(puntos, lessfunction)
listaOrd = lt.newList(datastructure="ARRAY_LIST")
i = 0
while i < numero:
F = lt.lastElement(puntos)
lt.addLast(listaOrd, F)
lt.removeLast(puntos)
i += 1
listaTaxis = lt.newList(datastructure="ARRAY_LIST")
itelistapuntos = it.newIterator(listaOrd)
while it.hasNext(itelistapuntos):
G = it.next(itelistapuntos)
itetop = it.newIterator(taxis)
while it.hasNext(itetop):
H = it.next(itetop)
I = m.get(tabla, H)
J = me.getValue(I)
if J == G:
lt.addLast(listaTaxis, H)
return listaTaxis
def getAccidentsBeforeDate(analyzer, date):
existe_fecha = om.contains(analyzer['dateIndex'], date)
if existe_fecha == False:
return ('Esta fecha no existe dentro de la documentación.')
else:
first_date = om.minKey(analyzer['dateIndex'])
fechas = om.keys(analyzer['dateIndex'], first_date, date)
lt.removeLast(fechas)
cant_fechas = lt.size(fechas)
cant_accidentes = 0
i = 1
mayor = 0
fecha_final = -10
while i <= cant_fechas:
llave = lt.getElement(fechas, i)
arbol = om.get(analyzer['dateIndex'], llave)
valor = lt.size(arbol['value']['lstaccidents'])
cant_accidentes += valor
if valor > mayor:
mayor = valor
fecha_final = llave
i += 1
return cant_accidentes, fecha_final
def estacionesCriticas(dataBase) -> dict:
top3In = list.newList()
top3Out = list.newList()
bot3 = list.newList()
analysis = Analysis.topViajes(dataBase)
i = 0
while i < 3:
list.addLast(top3In, list.removeFirst(analysis[0]))
list.addLast(top3Out, list.removeFirst(analysis[1]))
list.addFirst(bot3, list.removeLast(analysis[2]))
i += 1
del analysis
return (top3In, top3Out, bot3)
def criticalStations(citibike):
"""
RETO 4 | REQ 3
Retorna:
Las tres estaciones de donde salen más viajes.
La tres estaciones de donde llegan más viajes.
La tres estaciones menos usadas.
"""
top_arrival = []
top_departure = []
least_used = []
arrival_lt_sorted = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
departure_lt_sorted = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
total_trips_sorted = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
stations_keys = m.keySet(citibike['Edges_Map'])
iterator = it.newIterator(stations_keys)
while it.hasNext(iterator):
station = it.next(iterator)
sta = m.get(citibike['Edges_Map'], station)
lt.addLast(arrival_lt_sorted, sta)
lt.addLast(departure_lt_sorted, sta)
lt.addLast(total_trips_sorted, sta)
mg.mergesort(arrival_lt_sorted, greaterValueArrival)
mg.mergesort(departure_lt_sorted, greaterValueDeparture)
mg.mergesort(total_trips_sorted, greaterTotalTrips)
i = 0
while i < 3:
top_arr = lt.removeFirst(arrival_lt_sorted)
top_arrival.append(top_arr)
top_dep = lt.removeFirst(departure_lt_sorted)
top_departure.append(top_dep)
least = lt.removeLast(total_trips_sorted)
least_used.append(least)
i += 1
return top_arrival, top_departure, least_used
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
def pop(stack):
""" Retorna el elemento presente en el tope de la pila.
Args:
stack: La pila de donde se retirara el elemento
Returns:
El elemento del tope de la pila
Raises:
Exception
"""
try:
if stack is not None and not lt.isEmpty(stack):
return lt.removeLast(stack)
else:
raise Exception
except Exception as exp:
error.reraise(exp, 'TADStack->pop: ')
def estacionesCriticas(analyzer):
cuenta= 0
estaciones= gr.vertices(analyzer["graph"])
listaEntrada= lt.newList("ARRAY_LIST", comparestations)
listaSalida= lt.newList("ARRAY_LIST", comparestations)
listaSolitarias= lt.newList("ARRAY_LIST", comparestations)
entradasConcurridas= lt.newList("ARRAY_LIST", compareSizes)
salidasConcurridas= lt.newList("ARRAY_LIST", compareSizes)
estacionesSolitarias= lt.newList("ARRAY_LIST", compareSizes)
while cuenta<lt.size(estaciones):
estacion= lt.getElement(estaciones, cuenta)
entrada= gr.indegree(analyzer["graph"], estacion)
lt.addFirst(entradasConcurridas,entrada)
salida= gr.outdegree(analyzer["graph"], estacion)
lt.addFirst(salidasConcurridas,salida)
bidireccional= gr.degree(analyzer["graph"], estacion)
lt.addFirst(estacionesSolitarias,bidireccional)
cuenta+= 1
entradasOrg= sel.selectionSort(entradasConcurridas,lessequal)
salidasOrg= sel.selectionSort(salidasConcurridas,lessequal)
solitariasOrg= sel.selectionSort(estacionesSolitarias,lessequal)
for conteo in range(0,3):
if entrada == lt.getElement(entradasOrg, conteo):
lt.insertElement(listaEntrada, estacion, conteo)
if salida == lt.getElement(salidasOrg, conteo):
lt.insertElement(listaSalida, estacion, conteo)
if bidireccional == lt.getElement(solitariasOrg, conteo):
lt.insertElement(listaSolitarias, estacion, conteo)
if lt.size(listaEntrada) > 3:
lt.removeLast(listaEntrada)
if lt.size(listaSalida) > 3:
lt.removeLast(listaSalida)
if lt.size(listaSolitarias) > 3:
lt.removeLast(listaSolitarias)
return (listaEntrada, listaSalida, listaSolitarias)
def test_removeLast_array(altbooks, books):
assert lt.size(altbooks) == 5
lt.removeLast(altbooks)
assert lt.size(altbooks) == 4
book = lt.getElement(altbooks, 4)
assert book == books[3]
distance += e.weight(edge)
print(edge)
print('La distancia es de ', distance, ' Km')
else:
print('No es posible establecer una conexion')
print("\nTiempo [ms]: ", f"{result[1][0]:.3f}", " || ",
"Memoria [kB]: ", f"{result[1][1]:.3f}")
vermap = input('Desea observar el camino grafica en el mapa?')
if vermap == 'si':
webbrowser.open('mapa.html')
elif int(inputs[0]) == 5:
result = controller.requerimiento4(analyzer)
distance = 0
while (not lt.isEmpty(result[0][0])):
edge = lt.removeLast(result[0][0])
distance += e.weight(edge)
print(edge)
print(
'El numero de vertices asociados a la red de expansion minima es de: ',
result[0][1][1])
print('El costo del MST es de ', result[0][1][0], ' Km')
print('El costo de la rama mas larga es de ', distance, ' Km')
print("\nTiempo [ms]: ", f"{result[1][0]:.3f}", " || ",
"Memoria [kB]: ", f"{result[1][1]:.3f}")
vermap = input(
'Desea observar la red de expansion minima graficada en el mapa?')
if vermap == 'si':
webbrowser.open('mapa.html')
elif int(inputs[0]) == 6:
landingpoint = input("Ingresa el landing point: ")
