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