def test_zero_distance(self): XG = nx.DiGraph() XG.add_weighted_edges_from([ ("s", "u", 10), ("s", "x", 5), ("u", "v", 1), ("u", "x", 2), ("v", "y", 1), ("x", "u", 3), ("x", "v", 5), ("x", "y", 2), ("y", "s", 7), ("y", "v", 6), ]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG) for u in XG: assert dist[u][u] == 0 GG = XG.to_undirected() # make sure we get lower weight # to_undirected might choose either edge with weight 2 or weight 3 GG["u"]["x"]["weight"] = 2 path, dist = nx.floyd_warshall_predecessor_and_distance(GG) for u in GG: dist[u][u] = 0
def test_floyd_warshall_predecessor_and_distance(self): XG=nx.DiGraph() XG.add_weighted_edges_from([('s','u',10) ,('s','x',5) , ('u','v',1) ,('u','x',2) , ('v','y',1) ,('x','u',3) , ('x','v',5) ,('x','y',2) , ('y','s',7) ,('y','v',6)]) path, dist =nx.floyd_warshall_predecessor_and_distance(XG) assert_equal(dist['s']['v'],9) assert_equal(path['s']['v'],'u') assert_equal(dist, {'y': {'y': 0, 'x': 12, 's': 7, 'u': 15, 'v': 6}, 'x': {'y': 2, 'x': 0, 's': 9, 'u': 3, 'v': 4}, 's': {'y': 7, 'x': 5, 's': 0, 'u': 8, 'v': 9}, 'u': {'y': 2, 'x': 2, 's': 9, 'u': 0, 'v': 1}, 'v': {'y': 1, 'x': 13, 's': 8, 'u': 16, 'v': 0}}) GG=XG.to_undirected() path, dist = nx.floyd_warshall_predecessor_and_distance(GG) assert_equal(dist['s']['v'],8) assert_equal(path['s']['v'],'y') G=nx.DiGraph() # no weights G.add_edges_from([('s','u'), ('s','x'), ('u','v'), ('u','x'), ('v','y'), ('x','u'), ('x','v'), ('x','y'), ('y','s'), ('y','v')]) path, dist = nx.floyd_warshall_predecessor_and_distance(G) assert_equal(dist['s']['v'],2) assert_equal(path['s']['v'],'x')
def test_floyd_warshall_predecessor_and_distance(self): XG = nx.DiGraph() XG.add_weighted_edges_from([('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6)]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG) assert dist['s']['v'] == 9 assert path['s']['v'] == 'u' assert (dist == {'y': {'y': 0, 'x': 12, 's': 7, 'u': 15, 'v': 6}, 'x': {'y': 2, 'x': 0, 's': 9, 'u': 3, 'v': 4}, 's': {'y': 7, 'x': 5, 's': 0, 'u': 8, 'v': 9}, 'u': {'y': 2, 'x': 2, 's': 9, 'u': 0, 'v': 1}, 'v': {'y': 1, 'x': 13, 's': 8, 'u': 16, 'v': 0}}) GG = XG.to_undirected() # make sure we get lower weight # to_undirected might choose either edge with weight 2 or weight 3 GG['u']['x']['weight'] = 2 path, dist = nx.floyd_warshall_predecessor_and_distance(GG) assert dist['s']['v'] == 8 # skip this test, could be alternate path s-u-v # assert_equal(path['s']['v'],'y') G = nx.DiGraph() # no weights G.add_edges_from([('s', 'u'), ('s', 'x'), ('u', 'v'), ('u', 'x'), ('v', 'y'), ('x', 'u'), ('x', 'v'), ('x', 'y'), ('y', 's'), ('y', 'v')]) path, dist = nx.floyd_warshall_predecessor_and_distance(G) assert dist['s']['v'] == 2 # skip this test, could be alternate path s-u-v # assert_equal(path['s']['v'],'x') # alternate interface dist = nx.floyd_warshall(G) assert dist['s']['v'] == 2 # floyd_warshall_predecessor_and_distance returns # dicts-of-defautdicts # make sure we don't get empty dictionary XG = nx.DiGraph() XG.add_weighted_edges_from([('v', 'x', 5.0), ('y', 'x', 5.0), ('v', 'y', 6.0), ('x', 'u', 2.0)]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG) inf = float("inf") assert (dist == {'v': {'v': 0, 'x': 5.0, 'y': 6.0, 'u': 7.0}, 'x': {'x': 0, 'u': 2.0, 'v': inf, 'y': inf}, 'y': {'y': 0, 'x': 5.0, 'v': inf, 'u': 7.0}, 'u': {'u': 0, 'v': inf, 'x': inf, 'y': inf}}) assert (path == {'v': {'x': 'v', 'y': 'v', 'u': 'x'}, 'x': {'u': 'x'}, 'y': {'x': 'y', 'u': 'x'}})
def sp_router(self, router_type='dijkstra', weight='delay', savesteps=False): if str.lower(router_type) != 'dijkstra': if weight == 'delay': self.preds, _ = nx.floyd_warshall_predecessor_and_distance(self.dynetwork._network, weight='edge_delay') else: self.preds, _ = nx.floyd_warshall_predecessor_and_distance(self.dynetwork._network) temp_node_queue_lens = [0] temp_num_nodes_at_capacity = 0 temp_num_nonEmpty_node = 0 self.update_queues(True) self.update_time(True) '''iterate all nodes''' for node in self.dynetwork._network.nodes: '''provides pointer for queue of current node''' curr_queue = self.dynetwork._network.nodes[node]['sp_sending_queue'] sending_capacity = self.dynetwork._network.nodes[node]['max_send_capacity'] queue_size = len(curr_queue) '''Congestion Measure #1: max queue length''' if(queue_size > self.dynetwork.sp_max_queue_length): self.dynetwork.sp_max_queue_length = queue_size '''Congestion Measure #2: average queue length''' if(queue_size > 0): temp_node_queue_lens.append(queue_size) temp_num_nonEmpty_node += 1 '''Congestion Measure #3: average percentage of active nodes at capacity''' if(queue_size > sending_capacity): temp_num_nodes_at_capacity += 1 '''stores packets which currently have no path to destination''' remaining = [] sendctr = 0 for i in range(queue_size): '''when node cannot send anymore packets, break and move on to next node''' if sendctr == sending_capacity: self.dynetwork.sp_rejections +=(len(self.dynetwork._network.nodes[node]['sp_sending_queue'])) break remaining, curr_queue, sent = self.handle_node_packet(curr_queue, remaining, router_type, weight, savesteps) if sent: sendctr += 1 self.dynetwork._network.nodes[node]['sp_sending_queue'] = remaining + self.dynetwork._network.nodes[node]['sp_sending_queue'] '''Congestion Measure #2: average queue length''' if len(temp_node_queue_lens) > 1: self.dynetwork.sp_avg_q_len_arr.append(np.average(temp_node_queue_lens[1:])) '''Congestion Measure #3: percentage of nodes at capacity''' self.dynetwork.sp_num_capacity_node.append(temp_num_nodes_at_capacity) self.dynetwork.sp_num_working_node.append(temp_num_nonEmpty_node) self.dynetwork.sp_num_empty_node.append((self.nnodes - temp_num_nonEmpty_node)/self.nnodes)
def main(): # sets up basic graph, noting that nodes will be added implicitly g = nx.DiGraph() g.add_edge("AUS", "USA", weight=4) g.add_edge("USA", "AUS", weight=3) g.add_edge("AUS", "FRN", weight=5) g.add_edge("AUS", "CHN", weight=-1) g.add_edge("FRN", "USA", weight=7) g.add_edge("FRN", "CHN", weight=6) g.add_edge("UK", "CHN", weight=7) g.add_edge("USA", "UK", weight=2) g.add_edge("UK", "OMG", weight=-3) g.add_edge("USA", "FRN", weight=1) predecessors, distances = nx.floyd_warshall_predecessor_and_distance( g, weight='weight') one = tree("AUS", predecessors, g) two = single("AUS", "OMG", predecessors, g) three = planet("AUS", distances) # graph all the graphs print(one.nodes()) print(one.edges()) print("one") print(two.nodes()) print(two.edges()) print("two") print(three.nodes()) print(three.edges()) print("three")
def main(): cont=0 g=nx.DiGraph() while cont < len(ciudades): g.add_edge(ciudades[cont][0],ciudades[cont][1],weight=int(ciudades[cont][2])) cont=+1 inicial=raw_input("Ingrese la ciudad de origen:") final=raw_input("Igrese la ciudad de llegada: ") Fin = final predecesor, distance = nx.floyd_warshall_predecessor_and_distance(g) distancia = predecesor[inicial].keys() n=0 recorrido = [] recorrido.append(final) while n < len(distancia): if distancia[n] == Fin: recorrido.append(predecesor[inicial][distancia[n]]) if predecesor[inicial][distancia[n]] != inicial: Fin=predecesor[inicial][distancia[n]] n=-1 print print ("Distancia: ") print (distance[inicial][final]) print ("Camino más corto: ") n = len(recorrido) - 1 while n>=0: print (recorrido[n]) n=-1 print ("Centro del grafo: ") print print (Fin)
def findPath(graph, src, dest): # finds node predecessors using a function imported from networkx predecessors, _ = nx.floyd_warshall_predecessor_and_distance(graph) try: # finds the shortest path through the Floyd-Warshall algorithm by using a function imported from networkx path = nx.reconstruct_path(src, dest, predecessors) dpath = nx.dijkstra_path(graph, src, dest) bfpath = nx.bellman_ford_path(graph, src, dest) # prints the shortest path print("Path:", path) # print("Dijkstra's Path:", dpath) # print("Bellman-Ford Path:", bfpath) # prints the number of hops from source to destination print("Number of Hops:", len(path) - 1) # print("Dijkstra's Number of Hops:", len(dpath)-1) # print("Bellman-Ford Number of Hops:", len(bfpath)-1) # gets the total cost edge = 0 for i in range(1, len(path)): edge += graph.edges[path[i - 1], path[i]]['weight'] dpathcost = nx.dijkstra_path_length(graph, src, dest) bfpathcost = nx.bellman_ford_path_length(graph, src, dest) print("Total Cost:", edge) # print("Dijkstra's Total Cost:", dpathcost) # print("Bellman-Ford Total Cost:", bfpathcost) print() except: # Print to the terminal if no path exists. print("ERROR: No available path from source: node", src, "to destination: node", dest)
def programa(): Inicio = raw_input("Ingrese la ciudad de partida: ") Final = raw_input("Ingrese la ciudad de llegada: ") FinalAlt = Final predecesor, distance = nx.floyd_warshall_predecessor_and_distance(g) distancias = predecesor[Inicio].keys() n=0 recorrido = [] recorrido.append(Final) while n < len(distancias) : if distancias[n] == FinalAlt: recorrido.append(predecesor[Inicio][distancias[n]]) if predecesor[Inicio][distancias[n]] != Inicio: FinalAlt = predecesor[Inicio][distancias[n]] n=-1 n=n+1 print print "Disancia: " print distance[Inicio][Final] print "Camino mas corto:" n = len(recorrido) - 1 while n >= 0: print recorrido[n] n=n-1 print "CENTRO DEL GRAFO" print print FinalAlt
def test_weighted(self): XG3=nx.Graph() XG3.add_weighted_edges_from([ [0,1,2],[1,2,12],[2,3,1], [3,4,5],[4,5,1],[5,0,10] ]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG3) assert_equal(dist[0][3],15) assert_equal(path[0][3],2)
def floyd_warshall_all(G): pred, dist = nx.floyd_warshall_predecessor_and_distance(G) def path(u, v): # doesn't include v while u != v: yield u u = pred[v][u] return pred, dist, path
def solve(list_of_kingdom_names, starting_kingdom, adjacency_matrix, params=[]): """ Write your algorithm here. Input: list_of_kingdom_names: An list of kingdom names such that node i of the graph corresponds to name index i in the list starting_kingdom: The name of the starting kingdom for the walk adjacency_matrix: The adjacency matrix from the input file Output: Return 2 things. The first is a list of kingdoms representing the walk, and the second is the set of kingdoms that are conquered """ # raise Exception('"solve" function not defined') # return closed_walk, conquered_kingdoms graph = adjacency_matrix_to_graph(adjacency_matrix) for i in range(len(list_of_kingdom_names)): if list_of_kingdom_names[i] == starting_kingdom: start = i break dominating_set = new_min_weighted_dominating_set(graph, weight='weight') path_dict, dist_dict = nx.floyd_warshall_predecessor_and_distance( graph, weight='weight') shortest_path_through_dom_set = best_set_permutation( dominating_set, start, dist_dict) path = final_tour_creator(shortest_path_through_dom_set, path_dict, start) return path, list(dominating_set)
def path_generate_for_truck_greedy(self, truck: Truck): """ 通过贪心算法,生成一个车辆的次优回路,时间复杂度为O(n^2) :param truck: 待生成回路的车辆 :return: None """ # Floyd预处理 subgraph = truck.subgraph predecessors, dists = nx.floyd_warshall_predecessor_and_distance(subgraph) d = 0 path = [] visited = {u: False for u in subgraph} visited[0] = True # 从配送中心出发开始贪心 u = 0 for i in range(len(subgraph) - 1): v_opt = 0 dist_opt = np.inf for v in subgraph: if not visited[v] and dists[u][v] < dist_opt: v_opt = v dist_opt = dists[u][v] visited[v_opt] = True d += dists[u][v_opt] path += nx.reconstruct_path(u, v_opt, predecessors)[:-1] u = v_opt # 更新车辆路径 truck.d = d + dists[u][0] truck.path = path + [u, 0]
def rutaMasCorta(ciudad1,ciudad2): ciudadesIntermedias = [] control = True path = nx.floyd_warshall_predecessor_and_distance(grafo) try: #Ruta a traves de nodos intermedia = path[0][ciudad1][ciudad2] distancia = path[1][ciudad1][ciudad2] ciudadesIntermedias.append(intermedia) while control: #Se crea una lista para saber por donde pasa a traves de los nodos if not(intermedia == ciudad1): intermedia1 = path[0][ciudad1][intermedia] ciudadesIntermedias.append(intermedia1) intermedia = intermedia1 else: control = False #Ordenamos la lista ciudadesIntermedias.reverse() #Se hace la impresion print ("\nLa ruta mas corta entre es pasando por: ") print (", ".join(ciudadesIntermedias),",",ciudad2) print ("\nLa distancia total es de", distancia, "km") except KeyError: print ("No hay ruta directa entre las ciudades\n")
def establecerRuta(ciudad1, ciudad2, distancia): paths = nx.floyd_warshall_predecessor_and_distance(grafo) grafo.add_edge(ciudad1,ciudad2,weight=distancia) print("Se ha realizado la conecxion entre las ciudades")
def __init__(self, number_of_vehicles=0, deposts=[], limit=[], transfer_points=(), requests={}, graph=None): """init method for PDPT class This method construct an PDPT instance Parameters: number_of_vehicles (int): The total numbers of vehicles in the instance. deposts (list): The vehicles initial position, must have a length of N transfer_points (tuple): Transfer Points requests (dict): The Problem request graph (nx.Graph): The Graph with all the posible routes """ self.N = number_of_vehicles self.time = 0 self.vehicles = [] for i in range(self.N): self.vehicles.append(Vehicle(deposts)) self.transfer_points = transfer_points self.requests = requests self.origins = tuple(requests.keys()) self.destinations = tuple(requests.values()) self.routes = graph self.floyd = nx.floyd_warshall_predecessor_and_distance(self.routes) self.solution = None
def test_reconstruct_path(self): with pytest.raises(KeyError): XG = nx.DiGraph() XG.add_weighted_edges_from([ ("s", "u", 10), ("s", "x", 5), ("u", "v", 1), ("u", "x", 2), ("v", "y", 1), ("x", "u", 3), ("x", "v", 5), ("x", "y", 2), ("y", "s", 7), ("y", "v", 6), ]) predecessors, _ = nx.floyd_warshall_predecessor_and_distance(XG) path = nx.reconstruct_path("s", "v", predecessors) assert path == ["s", "x", "u", "v"] path = nx.reconstruct_path("s", "s", predecessors) assert path == [] # this part raises the keyError nx.reconstruct_path("1", "2", predecessors)
def greedy_solver(DTHGraph, timeout=40): def path(u, v): return nx.reconstruct_path(u, v, predecessors) t0, curr_min = time.time(), float('inf') solution = [] predecessors, _ = nx.floyd_warshall_predecessor_and_distance( DTHGraph.nxgraph) solution.append(DTHGraph.start) curr_loc = DTHGraph.start remaining_loc = DTHGraph.homes[:] while len(remaining_loc) != 0: distances = [DTHGraph.dist[curr_loc][v] for v in remaining_loc] best = remaining_loc.pop(np.argmin(distances)) if best == curr_loc: continue walk = path(curr_loc, best) solution += walk[1:] curr_loc = best walk = path(curr_loc, DTHGraph.start) solution += walk[1:] DTHGraph.solution = solution
def createAndInitNetwork(): #draw and show graph mapper['color'] = np.array(map(ord, mapper['group'])) nx.draw_kamada_kawai(graph, with_labels=True, node_color=mapper['color'], cmap=plt.cm.Greens) plt.show() #plt.savefig('../networks/network'+ sys.argv[1] +'.png') #calculate shortest path between all nodes pred, dist = nx.floyd_warshall_predecessor_and_distance(graph) for p in pred: commandCreate = 'python node.py ' + str(p) + ' ' + mapper['group'][ p] + ' ' + sys.argv[1] + ' ' + sys.argv[2] + ' ' + str(pred[p]) commandList.append(commandCreate) #clear ports to create nodes clearPort = 'sudo fuser -k -n tcp ' for g in nx.nodes(graph): clearPort = clearPort + str(8090 + g) + ' ' print clearPort os.system(clearPort) t = threading.Thread(target=(createNodes), args=()) t.start() time.sleep(1)
def test_weight_parameter(self): XG4 = nx.Graph() XG4.add_edges_from([ (0, 1, { "heavy": 2 }), (1, 2, { "heavy": 2 }), (2, 3, { "heavy": 1 }), (3, 4, { "heavy": 1 }), (4, 5, { "heavy": 1 }), (5, 6, { "heavy": 1 }), (6, 7, { "heavy": 1 }), (7, 0, { "heavy": 1 }), ]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG4, weight="heavy") assert dist[0][2] == 4 assert path[0][2] == 1
def test_weighted(self): XG3 = nx.Graph() XG3.add_weighted_edges_from([[0, 1, 2], [1, 2, 12], [2, 3, 1], [3, 4, 5], [4, 5, 1], [5, 0, 10]]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG3) assert dist[0][3] == 15 assert path[0][3] == 2
def test_weighted2(self): XG4 = nx.Graph() XG4.add_weighted_edges_from([[0, 1, 2], [1, 2, 2], [2, 3, 1], [3, 4, 1], [4, 5, 1], [5, 6, 1], [6, 7, 1], [7, 0, 1]]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG4) assert dist[0][2] == 4 assert path[0][2] == 1
def test_weighted2(self): XG4=nx.Graph() XG4.add_weighted_edges_from([ [0,1,2],[1,2,2],[2,3,1], [3,4,1],[4,5,1],[5,6,1], [6,7,1],[7,0,1] ]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG4) assert_equal(dist[0][2],4) assert_equal(path[0][2],1)
def steiner_find(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix): G = nx.Graph(incoming_graph_data=adjacency_matrix, cutoff=1000) predecessors, distances = nx.floyd_warshall_predecessor_and_distance(G) homeIndices = [] for h in list_of_homes: homeIndices.append(list_of_locations.index(h)) # homeIndices.append(list_of_locations.index(starting_car_location)) tree = apxa.steiner_tree( G, homeIndices + [list_of_locations.index(starting_car_location)]) # print(list(tree.nodes)) # print(homeIndices) # print(starting_car_location) # treematrix = nx.adjacency_matrix(tree) # return greedyAllPairs(list(tree.nodes), homeIndices, int(starting_car_location), treematrix) nodelist = list(tree.nodes()) currIndex = list_of_locations.index(starting_car_location) visitedNodes = [] path = [list_of_locations.index(starting_car_location)] dropoff_mapping = {} added = False # print(currIndex) nodelist = nodelist[ nodelist.index(currIndex):] + nodelist[:nodelist.index(currIndex)] # print(nodelist) dropped = False allHomes = set(homeIndices) homeSet = set(homeIndices) length = len(nodelist) - 1 i = 0 while i in range(0, length): dropped = False homeNeighbors = list( homeSet.intersection(list(tree.neighbors(nodelist[i])))) if len(homeNeighbors) >= 3: dropped = True homeNeighbors = [j for j in homeNeighbors if j in homeSet] if (nodelist[i] in homeSet): homeNeighbors = homeNeighbors + [nodelist[i]] dropoff_mapping[nodelist[i]] = homeNeighbors homeSet = set([j for j in homeSet if j not in homeNeighbors]) n = 1 while i + n in range(0, length) and nodelist[ i + n] in allHomes and nodelist[i + n] not in homeSet: n = n + 1 path_to_next = nx.reconstruct_path(nodelist[i], nodelist[i + n], predecessors) path.extend(path_to_next[1:]) if nodelist[i] in homeSet and not dropped: dropoff_mapping[nodelist[i]] = [nodelist[i]] homeSet.remove(nodelist[i]) i = i + n if nodelist[-1] in homeSet: dropoff_mapping[nodelist[-1]] = [nodelist[-1]] path_to_start = nx.reconstruct_path(nodelist[-1], nodelist[0], predecessors) path.extend(path_to_start[1:]) return path, dropoff_mapping
def ruta(): graf = nx.DiGraph() archivo = open("guategrafo.txt", "r") contenido = archivo.readlines() archivo.close() for lineas in contenido: string = lineas.split(" ") graf.add_node(string[0]) graf.add_node(string[1]) graf.add_edge(string[0], string[1], weight=float(string[2])) path = nx.floyd_warshall_predecessor_and_distance(graf) nodos = graf.nodes() ciudadI = input("Ingrese la ciudad de la cual desea partir: ") while ciudadI not in graf.nodes(): print("La ciudad que ingreso no se encuentra en la base de datos") ciudadI = input("Ingrese la ciudad de la cual desea partir: ") ciudadD = input("Indique la ciudad de destino: ") while ciudadD not in graf.nodes(): print("La ciudad que ingreso no se encuentra en la base de datos") ciudadD = input("Indique la ciudad de destino: ") try: predecesor1 = path[0][ciudadI][ciudadD] ciudades = [] ciudades.append(predecesor1) #print predecesor1 cont = 0 if predecesor1 != ciudadI: while cont == 0: predecesor = path[0][ciudadI][predecesor1] ciudades.append(predecesor) predecesor1 = predecesor if predecesor1 == ciudadI: cont = 1 else: predecesor1 = predecesor #print predecesor1 imprimir = [] for i in reversed(ciudades): if ciudadI != i: imprimir.append(i) print("La ruta mas corta de ", ciudadI, " a ", ciudadD, " es por: ") print(ciudadI, "-> " + "-> ".join(imprimir), "->", ciudadD) print("La distancia en kilometros es: ") print(path[1][ciudadI][ciudadD]) except: print("No existen rutas entre esas ciudades")
def __init__(self, request=[], path=[], floyd=None, instance=None): self.request = request self.path = [] if not floyd: self.minPath, self.minDist =\ nx.floyd_warshall_predecessor_and_distance(instance.routes) else: self.minPath, self.minDist = floyd self.f()
def floyd_warshall(distance): ''' :param distance: distance model with maxsize :return: shortest_dis, predecessors ''' G = nx.DiGraph(distance) shortest_dis = nx.floyd_warshall(G) predecessors, _ = nx.floyd_warshall_predecessor_and_distance(G) return shortest_dis, predecessors
def test_weight_parameter(self): XG4 = nx.Graph() XG4.add_edges_from([ (0, 1, {'heavy': 2}), (1, 2, {'heavy': 2}), (2, 3, {'heavy': 1}), (3, 4, {'heavy': 1}), (4, 5, {'heavy': 1}), (5, 6, {'heavy': 1}), (6, 7, {'heavy': 1}), (7, 0, {'heavy': 1}) ]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG4, weight='heavy') assert_equal(dist[0][2], 4) assert_equal(path[0][2], 1)
def floydWarshall(self): """ This finds all-pairs of shortest path lengths using Floyd's algorithm and sets self.min_path_dict to [predecessor_dict, distance_dict] where the two dictionaries 2D dictionaries keyed on node index. predecessor is the ordered list of visited nodes when going from node A to node B along a shortest path. """ # self.min_path_dict = nx.floyd_warshall(self.G) self.min_path_dict = nx.floyd_warshall_predecessor_and_distance(self.G)
def all_pairs_shortest_paths(graph): """Returns a dictionary of dictionaries. Each inner dictionary is indexed by a node and value is distance between outer key and inner key.""" predecessors, lengths = nx.floyd_warshall_predecessor_and_distance(graph) paths = dict() for i in range(len(graph.nodes)): paths[i] = dict() for j in range(len(graph.nodes)): paths[i][j] = nx.reconstruct_path(i, j, predecessors) return lengths, paths
def test_zero_distance(self): XG=nx.DiGraph() XG.add_weighted_edges_from([('s','u',10) ,('s','x',5) , ('u','v',1) ,('u','x',2) , ('v','y',1) ,('x','u',3) , ('x','v',5) ,('x','y',2) , ('y','s',7) ,('y','v',6)]) path, dist =nx.floyd_warshall_predecessor_and_distance(XG) for u in XG: assert_equal(dist[u][u], 0) GG=XG.to_undirected() # make sure we get lower weight # to_undirected might choose either edge with weight 2 or weight 3 GG['u']['x']['weight']=2 path, dist = nx.floyd_warshall_predecessor_and_distance(GG) for u in GG: dist[u][u] = 0
def solve_from_file(input_file, output_directory, params=[]): print('Processing', input_file) input_data = utils.read_file(input_file) num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser( input_data) car_path, drop_offs, homeList = solve(list_locations, list_houses, starting_car_location, adjacency_matrix, params=params) G = nx.Graph(incoming_graph_data=adjacency_matrix, cutoff=1000) predecessors, distances = nx.floyd_warshall_predecessor_and_distance(G) print(list(distances.items())[0][1][0]) prev_dropoff = list_locations.index(starting_car_location) list_houses = homeList def cost(h, i, j, k): ''' h : place you are coming from i : place to drop off person j : actual house for person dropped off at i k : next place to drive to ''' return ((2 / 3) * list(distances.items())[h][1][i]) + (list( distances.items())[i][1][j]) + ( (2 / 3) * list(distances.items())[i][1][k]) #how do i access the next index in the list of houses? #ask eric and calvin to check the code and see if it has correct syntax i = 0 drop_to_home = {} dropoff_list = [] while (i < num_houses - 1): i_ind = list_houses.index(list_houses[i]) i_ind_next = list_houses.index(list_houses[i + 1]) total_cost = list(distances.items())[prev_dropoff][1][i_ind] best_dropoff = i_ind for x in list_locations: x_ind = list_locations.index(x) challenge = cost(prev_dropoff, x, i_ind, i_ind_next) if challenge < total_cost: total_cost = challenge best_dropoff = x_ind prev_dropoff = best_dropoff best_dropoff_location = list_locations[best_dropoff] drop_to_home[best_dropoff] = [i_ind] dropoff_list.append(best_dropoff_location) i += 1 return greedyAllPairs(list_locations, dropoff_list, drop_to_home, starting_car_location, adjacency_matrix)
def test_zero_distance(self): XG = nx.DiGraph() XG.add_weighted_edges_from([('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6)]) path, dist = nx.floyd_warshall_predecessor_and_distance(XG) for u in XG: assert dist[u][u] == 0 GG = XG.to_undirected() # make sure we get lower weight # to_undirected might choose either edge with weight 2 or weight 3 GG['u']['x']['weight'] = 2 path, dist = nx.floyd_warshall_predecessor_and_distance(GG) for u in GG: dist[u][u] = 0
def calculate_many_marginals(self, projections): """ Calculates marginals for all the projections in the list using Algorithm for answering many out-of-clique queries (section 10.3 in Koller and Friedman) This method may be faster than calling project many times :param projections: a list of projections, where each projection is a subset of attributes (represented as a list or tuple) :return: a list of marginals, where each marginal is represented as a Factor """ self.marginals = self.belief_propagation(self.potentials) sep = self.sep_axes neighbors = self.neighbors # first calculate P(Cj | Ci) for all neighbors Ci, Cj conditional = {} for Ci in neighbors: for Cj in neighbors[Ci]: Sij = sep[(Cj, Ci)] Z = self.marginals[Cj] conditional[(Cj, Ci)] = Z / Z.project(Sij) # now iterate through pairs of cliques in order of distance pred, dist = nx.floyd_warshall_predecessor_and_distance( self.junction_tree.tree, weight=False) results = {} for Ci, Cj in sorted(itertools.combinations(self.cliques, 2), key=lambda X: dist[X[0]][X[1]]): Cl = pred[Ci][Cj] Y = conditional[(Cj, Cl)] if Cl == Ci: X = self.marginals[Ci] results[(Ci, Cj)] = results[(Cj, Ci)] = X * Y else: X = results[(Ci, Cl)] S = set(Cl) - set(Ci) - set(Cj) results[(Ci, Cj)] = results[(Cj, Ci)] = (X * Y).sum(S) results = { self.domain.canonical(key[0] + key[1]): results[key] for key in results } answers = {} for proj in projections: for attr in results: if set(proj) <= set(attr): answers[proj] = results[attr].project(proj) break if proj not in answers: # just use variable elimination answers[proj] = self.project(proj) return answers
def test_floyd_warshall_predecessor_and_distance(self): XG=nx.DiGraph() XG.add_weighted_edges_from([('s','u',10) ,('s','x',5) , ('u','v',1) ,('u','x',2) , ('v','y',1) ,('x','u',3) , ('x','v',5) ,('x','y',2) , ('y','s',7) ,('y','v',6)]) path, dist =nx.floyd_warshall_predecessor_and_distance(XG) assert_equal(dist['s']['v'],9) assert_equal(path['s']['v'],'u') assert_equal(dist, {'y': {'y': 0, 'x': 12, 's': 7, 'u': 15, 'v': 6}, 'x': {'y': 2, 'x': 0, 's': 9, 'u': 3, 'v': 4}, 's': {'y': 7, 'x': 5, 's': 0, 'u': 8, 'v': 9}, 'u': {'y': 2, 'x': 2, 's': 9, 'u': 0, 'v': 1}, 'v': {'y': 1, 'x': 13, 's': 8, 'u': 16, 'v': 0}}) GG=XG.to_undirected() # make sure we get lower weight # to_undirected might choose either edge with weight 2 or weight 3 GG['u']['x']['weight']=2 path, dist = nx.floyd_warshall_predecessor_and_distance(GG) assert_equal(dist['s']['v'],8) # skip this test, could be alternate path s-u-v # assert_equal(path['s']['v'],'y') G=nx.DiGraph() # no weights G.add_edges_from([('s','u'), ('s','x'), ('u','v'), ('u','x'), ('v','y'), ('x','u'), ('x','v'), ('x','y'), ('y','s'), ('y','v')]) path, dist = nx.floyd_warshall_predecessor_and_distance(G) assert_equal(dist['s']['v'],2) # skip this test, could be alternate path s-u-v # assert_equal(path['s']['v'],'x') # alternate interface dist = nx.floyd_warshall(G) assert_equal(dist['s']['v'],2)
def test_reconstruct_path(self): XG = nx.DiGraph() XG.add_weighted_edges_from([('s', 'u', 10), ('s', 'x', 5), ('u', 'v', 1), ('u', 'x', 2), ('v', 'y', 1), ('x', 'u', 3), ('x', 'v', 5), ('x', 'y', 2), ('y', 's', 7), ('y', 'v', 6)]) predecessors, _ = nx.floyd_warshall_predecessor_and_distance(XG) path = nx.reconstruct_path('s', 'v', predecessors) assert_equal(path, ['s', 'x', 'u', 'v']) path = nx.reconstruct_path('s', 's', predecessors) assert_equal(path, []) # this part raises the keyError nx.reconstruct_path('1', '2', predecessors)
def test_directed_cycle_numpy(self): G = nx.DiGraph() G.add_cycle([0,1,2,3]) pred,dist = nx.floyd_warshall_predecessor_and_distance(G) D = nx.utils.dict_to_numpy_array(dist) assert_equal(nx.floyd_warshall_numpy(G),D)
def approximate_line_segments(self, TRAINING_MIN_AREA = 60, TRAINING_MAX_AREA = 20576, MAX_FAIL_COUNTER = 20, NEIGHBOR_TRESHOLD = 6): obj_area = len(self.FOOTPRINT_initial[self.FOOTPRINT_initial != 0]) if obj_area < TRAINING_MIN_AREA: obj_area = TRAINING_MIN_AREA elif obj_area > TRAINING_MAX_AREA: obj_area = TRAINING_MAX_AREA lin_area = [60,86,113,137,140,146,152,155,158,176,183,187,191,194,198,202,209,221,231,240,247,254,265,280,289,290,293,294,299,307,317,332,344,369,386,398,415,424,446,256,472,485,517,532,571,590,611,634,671,689,713,722,755,781,796,893,938,970,1004,1050,1050,1107,1114,1153,1164,1226,1518,1598,1762,1830,1875,1985,2045,2212,2574,2829,2895,3038,3610,4299,5088,5261,5312,5961,10616,12586,20576] lin_min_e = [0.4,0.4,0.4,0.4,0.6,0.4,0.425,0.5,0.425,0.4,0.475,0.5,0.475,0.475,0.5,0.6,0.625,0.7,0.6,0.6,0.6,0.725,0.725,0.7,0.7,0.7,0.6,0.6,0.7,0.7,0.75,0.75,0.75,0.775,0.76,0.75,0.8,0.775,0.7,0.725,0.725,0.8,0.83,0.805,0.82,0.8,0.85,0.85,0.9,0.87,0.9,0.9,0.9,0.92,1.0,1.0,1.0,0.95,1.0,0.9,0.95,1.0,1.0,1.0,1.0,1.0,0.9,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0] FXN_min_e = interp1d(lin_area, lin_min_e) MIN_E_DISTANCE = FXN_min_e(obj_area) G=nx.DiGraph() E=nx.DiGraph() len_ordered_points = len(self.POINTS_ordered) for idx in xrange(0,len_ordered_points): next_idx = (idx+1) % len_ordered_points dist = math.hypot(self.POINTS_ordered[idx][0] - self.POINTS_ordered[next_idx][0], self.POINTS_ordered[idx][1] - self.POINTS_ordered[next_idx][1]) G.add_edge(idx,next_idx,weight=dist) G.add_edge(idx,str(next_idx),weight=dist) E.add_edge(idx,next_idx,weight=0) E.add_edge(idx,str(next_idx),weight=0) idx2 = (idx + 2) % len_ordered_points fail_counter = 0 while((idx2 + 1) % len_ordered_points != idx and fail_counter < MAX_FAIL_COUNTER): #? counter = 0 average_distance = 0.0 base = math.hypot(self.POINTS_ordered[idx][0] - self.POINTS_ordered[idx2][0], self.POINTS_ordered[idx][1] - self.POINTS_ordered[idx2][1]) idx3 = (idx + 1) % len_ordered_points while(idx2 != idx3): #? side_1 = math.hypot(self.POINTS_ordered[idx][0] - self.POINTS_ordered[idx3][0], self.POINTS_ordered[idx][1] - self.POINTS_ordered[idx3][1]) side_2 = math.hypot(self.POINTS_ordered[idx2][0] - self.POINTS_ordered[idx3][0], self.POINTS_ordered[idx2][1] - self.POINTS_ordered[idx3][1]) semi_perimeter = (side_1 + side_2 + base) / 2.0 temp = semi_perimeter * (semi_perimeter - side_1) * (semi_perimeter - side_2) * (semi_perimeter - base) if temp < 0: temp = 0 area = math.sqrt(temp) height = (2.0 * area) / base average_distance += height counter += 1 idx3 = (idx3 + 1) % len_ordered_points average_distance /= counter if average_distance <= MIN_E_DISTANCE: G.add_edge(idx,idx2,weight=base) G.add_edge(idx,str(idx2),weight=base) E.add_edge(idx,idx2,weight=average_distance) E.add_edge(idx,str(idx2),weight=average_distance) fail_counter = 0 else: fail_counter += 1 idx2 = (idx2 + 1) % len_ordered_points F = nx.floyd_warshall_predecessor_and_distance(G) best_route = [] for target in xrange(0,len_ordered_points): pointer = str(target) route = [] route.append(pointer) while pointer != target: pointer = F[0][target][pointer] route.append(pointer) if len(best_route) == 0 or len(best_route) > len(route): best_route = copy.deepcopy(route) valid_nodes = [] best_route = best_route[::-1] best_route.pop() for point in best_route: point = int(point) valid_nodes.append([point]) for i in xrange(1, (NEIGHBOR_TRESHOLD / 2) + 1): valid_nodes[-1].append((point + i) % len_ordered_points) valid_nodes[-1].append((point - i) % len_ordered_points) len_valid_nodes = len(valid_nodes) simplified_E=nx.DiGraph() for node_idx in xrange(0, len_valid_nodes): next_node = (node_idx + 1) % len_valid_nodes for point in valid_nodes[node_idx]: for adj_point in valid_nodes[next_node]: curr_edge = E.get_edge_data(point, adj_point, False) if next_node != 0: next_node_name = str(next_node) + '_' + str(adj_point) else: next_node_name = adj_point if curr_edge != False: simplified_E.add_edge(str(node_idx) + '_' + str(point), next_node_name, weight = curr_edge['weight']) elif point == adj_point: simplified_E.add_edge(str(node_idx) + '_' + str(point), next_node_name, weight = 0) SHORTEST_E = nx.floyd_warshall_predecessor_and_distance(simplified_E) best_cost = "notset" best_route = [] for target in valid_nodes[0]: pointer = target target = '0_' + str(target) route = [] route.append(pointer) route_cost = 0 while pointer != target: try: route_cost += SHORTEST_E[1][target][pointer] pointer = SHORTEST_E[0][target][pointer] except KeyError: break route.append(pointer) if len(route) == (len_valid_nodes + 1) and (best_cost == "notset" or best_cost > route_cost): best_route = copy.deepcopy(route) best_cost = route_cost best_route = best_route[::-1] best_route.pop() critical_points = [] for point in best_route: critical_points.append(list(self.POINTS_ordered[int(point.split("_")[1])])) critical_points = np.array(critical_points) return critical_points
def test_cycle(self): path, dist = nx.floyd_warshall_predecessor_and_distance(nx.cycle_graph(7)) assert_equal(dist[0][3],3) assert_equal(path[0][3],2) assert_equal(dist[0][4],3)
def regularizeBoundary(indexedObject): t0 = time.time() obj = indexedObject[1] CIRCLE_RADIUS = 5 MINIMUM_BOUNDARY = 70 MAXIMUM_DISTANCE = 15 MINIMUM_SIDES = 4 obj_length = obj.shape obj_area = len(obj[obj != 0]) lin_area = [60,86,113,137,140,146,152,155,158,176,183,187,191,194,198,202,209,221,231,240,247,254,265,280,289,290,293,294,299,307,317,332,344,369,386,398,415,424,446,256,472,485,517,532,571,590,611,634,671,689,713,722,755,781,796,893,938,970,1004,1050,1050,1107,1114,1153,1164,1226,1518,1598,1762,1830,1875,1985,2045,2212,2574,2829,2895,3038,3610,4299,5088,5261,5312,5961,10616,12586,20576] lin_min_e = [0.4,0.4,0.4,0.4,0.6,0.4,0.425,0.5,0.425,0.4,0.475,0.5,0.475,0.475,0.5,0.6,0.625,0.7,0.6,0.6,0.6,0.725,0.725,0.7,0.7,0.7,0.6,0.6,0.7,0.7,0.75,0.75,0.75,0.775,0.76,0.75,0.8,0.775,0.7,0.725,0.725,0.8,0.83,0.805,0.82,0.8,0.85,0.85,0.9,0.87,0.9,0.9,0.9,0.92,1.0,1.0,1.0,0.95,1.0,0.9,0.95,1.0,1.0,1.0,1.0,1.0,0.9,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0] lin_temp = [1.0,1.0,1.0,1.0,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.0,2.5,2.5,2.5,2.5,2.5,2.5,2.5,2.5,2.5,2.5,3.0,3.0,3.0,3.0,3.0,3.0,3.5,3.5,3.5,3.5] f1_min_e = interp1d(lin_area, lin_min_e) f2_temp = interp1d(lin_area, lin_temp) if obj_area < TRAINING_MIN_AREA: obj_area = TRAINING_MIN_AREA elif obj_area > TRAINING_MAX_AREA: obj_area = TRAINING_MAX_AREA MIN_E_DISTANCE = f1_min_e(obj_area) CURR_MAX_TEMP = f2_temp(obj_area) if CURR_MAX_TEMP % 0.5 != 0.0: CURR_MAX_TEMP = round(CURR_MAX_TEMP * 2.0) / 2.0 original_image = np.zeros((obj_length[0]+CIRCLE_RADIUS*2,obj_length[1]+CIRCLE_RADIUS*2),dtype=np.uint) original_image[CIRCLE_RADIUS:obj_length[0]+CIRCLE_RADIUS,CIRCLE_RADIUS:obj_length[1]+CIRCLE_RADIUS] = obj #REMOVE TAILS cleaned_image = opening(original_image, square(5)) labeled_image, num_of_labels = ndimage.measurements.label(cleaned_image, [[1,1,1],[1,1,1],[1,1,1]]) if num_of_labels > 1: b_slices = ndimage.find_objects(labeled_image) area = [] for idx,s in enumerate(b_slices): area.append(len(cleaned_image[cleaned_image[s] != 0])) cleaned_image[labeled_image != (area.index( max(area))) + 1] = 0 # area = np.bincount(obj.flatten())[indexedObject[0]] area = len(cleaned_image[cleaned_image!=0]) if area < 10: zeros = np.zeros(original_image.shape,dtype=np.uint8) return indexedObject[0],zeros,indexedObject[2] boundary_image = find_boundaries(cleaned_image, mode='inner').astype(np.uint8) #value = 1 # orig_rough_building = copy.deepcopy(boundary_image) orig_rough_boundaries = find_boundaries(original_image, mode='inner').astype(np.uint8) orig_rough_building = copy.deepcopy(orig_rough_boundaries) # pickle.dump( orig_rough_building, open( "orig_footprint_1003.p", "wb" ) ) orig_rough_building = ndimage.binary_fill_holes(orig_rough_building) orig_rough_building = orig_rough_building * 1 nonzero_x, nonzero_y = np.nonzero(boundary_image) zip_nonzero = zip(nonzero_x, nonzero_y) #SUBJECT TO CHANGE!!!!!!!!!!!!!!!!!!!!!!!!! # ordered_points = moore_neighbor_tracing(zip_nonzero, boundary_image) ordered_points = neighbor_tracing(zip_nonzero) # exit() for point in zip_nonzero: segments = [] circle_x, circle_y = circle_perimeter(point[0],point[1],CIRCLE_RADIUS) circle_points = np.array(list(sorted(set(zip(circle_x,circle_y))))) sortedpoints = np.empty([len(circle_points), 2], dtype=int) test1 = circle_points[circle_points[:,0] == point[0] - CIRCLE_RADIUS] start = len(test1) end = len_cpoints = len(sortedpoints) sortedpoints[0:start] = test1 for x in xrange(point[0] - CIRCLE_RADIUS + 1, point[0] + CIRCLE_RADIUS): test1 = circle_points[circle_points[:,0] == x] testlen = len(test1) if x <= point[0]: sortedpoints[start:start+testlen/2] = test1[testlen/2:] sortedpoints[end-testlen/2:end] = test1[:testlen/2] else: sortedpoints[start:start+testlen/2] = test1[testlen/2:][::-1] sortedpoints[end-testlen/2:end] = test1[:testlen/2][::-1] start += testlen/2 end -= testlen/2 test1 = circle_points[circle_points[:,0] == point[0] + CIRCLE_RADIUS] sortedpoints[start:start + len(test1)] = test1[::-1] for c_perimeter in sortedpoints: segments.append(True) line_x, line_y = line(point[0], point[1], c_perimeter[0], c_perimeter[1]) for line_points in zip(line_x,line_y)[1:]: # if original_image[line_points[0]][line_points[1]] != 0: if cleaned_image[line_points[0]][line_points[1]] != 0: segments[-1] = False break min_boundpoints = (MINIMUM_BOUNDARY / 360.0) * len_cpoints seg_sizes = [] new_segment = True for segment in segments: if segment: if new_segment: seg_sizes.append(1) new_segment = False else: seg_sizes[-1] += 1 else: new_segment = True if segments[0] == True and segments[-1] == True and len(seg_sizes) > 1: seg_sizes[0] = seg_sizes[0] + seg_sizes[-1] seg_sizes.pop() if(len(seg_sizes) == 0 or max(seg_sizes) < min_boundpoints): boundary_image[point[0]][point[1]] = 0 if (point[0],point[1]) in ordered_points: ## IDENTIFY KUNG BAKIT NAGKA-ERRROR, EXAMPLE pt000120_merged4.py obj 1301 ordered_points.remove((point[0],point[1])) # print "Obtaining All Possible Edges..." G=nx.DiGraph() E=nx.DiGraph() len_ordered_points = len(ordered_points) for idx in xrange(0,len_ordered_points): next_idx = (idx+1) % len_ordered_points dist = math.hypot(ordered_points[idx][0] - ordered_points[next_idx][0], ordered_points[idx][1] - ordered_points[next_idx][1]) G.add_edge(idx,next_idx,weight=dist) G.add_edge(idx,str(next_idx),weight=dist) E.add_edge(idx,next_idx,weight=0) E.add_edge(idx,str(next_idx),weight=0) # idx2 = idx - 2 idx2 = (idx + 2) % len_ordered_points fail_counter = 0 while((idx2 + 1) % len_ordered_points != idx and fail_counter < 20): #? counter = 0 total_distance = 0.0 average_distance = 0.0 base = math.hypot(ordered_points[idx][0] - ordered_points[idx2][0], ordered_points[idx][1] - ordered_points[idx2][1]) idx3 = (idx + 1) % len_ordered_points while(idx2 != idx3): #? side_1 = math.hypot(ordered_points[idx][0] - ordered_points[idx3][0], ordered_points[idx][1] - ordered_points[idx3][1]) side_2 = math.hypot(ordered_points[idx2][0] - ordered_points[idx3][0], ordered_points[idx2][1] - ordered_points[idx3][1]) semi_perimeter = (side_1 + side_2 + base) / 2.0 temp = semi_perimeter * (semi_perimeter - side_1) * (semi_perimeter - side_2) * (semi_perimeter - base) if temp < 0: temp = 0 area = math.sqrt(temp) height = (2.0 * area) / base Ax = ordered_points[idx][0] Ay = ordered_points[idx][1] Bx = ordered_points[idx2][0] By = ordered_points[idx2][1] Cx = ordered_points[idx3][0] Cy = ordered_points[idx3][1] position = np.sign((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax)) total_distance += height * position average_distance += height counter += 1 idx3 = (idx3 + 1) % len_ordered_points average_distance /= counter # if average_distance <= MIN_E_DISTANCE and total_distance >= -MIN_E_DISTANCE and total_distance < 30: if average_distance <= MIN_E_DISTANCE: G.add_edge(idx,idx2,weight=base) G.add_edge(idx,str(idx2),weight=base) E.add_edge(idx,idx2,weight=average_distance) E.add_edge(idx,str(idx2),weight=average_distance) fail_counter = 0 else: fail_counter += 1 idx2 = (idx2 + 1) % len_ordered_points F = nx.floyd_warshall_predecessor_and_distance(G) best_route = [] count = 0 for target in xrange(0,len_ordered_points): pointer = str(target) route = [] route.append(pointer) while pointer != target: pointer = F[0][target][pointer] route.append(pointer) if len(route) == 7: count += 1 if len(best_route) == 0 or len(best_route) > len(route): best_route = copy.deepcopy(route) #print best_route #######################################CODE 4/29/16 #######################################CODE 4/29/16 NEIGHBOR_TRESHOLD = 6 valid_nodes = [] best_route = best_route[::-1] best_route.pop() for point in best_route: point = int(point) valid_nodes.append([point]) for i in xrange(1, (NEIGHBOR_TRESHOLD / 2) + 1): valid_nodes[-1].append((point + i) % len_ordered_points) valid_nodes[-1].append((point - i) % len_ordered_points) #print "VALID", valid_nodes #print len(valid_nodes) len_valid_nodes = len(valid_nodes) simplified_E=nx.DiGraph() for node_idx in xrange(0, len(valid_nodes)): next_node = (node_idx + 1) % len(valid_nodes) for point in valid_nodes[node_idx]: # print "2ndLOOP: ",point for adj_point in valid_nodes[next_node]: # print "3rdLOOP:", adj_point curr_edge = E.get_edge_data(point, adj_point, False) if next_node != 0: next_node_name = str(next_node) + '_' + str(adj_point) else: next_node_name = adj_point if curr_edge != False: simplified_E.add_edge(str(node_idx) + '_' + str(point), next_node_name, weight = curr_edge['weight']) # print "1: ", str(node_idx) + '_' + str(point), next_node_name elif point == adj_point: simplified_E.add_edge(str(node_idx) + '_' + str(point), next_node_name, weight = 0) # print "2: ", str(node_idx) + '_' + str(point), next_node_name SHORTEST_E = nx.floyd_warshall_predecessor_and_distance(simplified_E) # print SHORTEST_E best_cost = "notset" best_route = [] for target in valid_nodes[0]: pointer = target target = '0_' + str(target) route = [] route.append(pointer) route_cost = 0 while pointer != target: try: route_cost += SHORTEST_E[1][target][pointer] pointer = SHORTEST_E[0][target][pointer] except KeyError: break route.append(pointer) if len(route) == (len_valid_nodes + 1) and (best_cost == "notset" or best_cost > route_cost): # if best_cost == False or (best_cost > route_cost and len(best_route) == len(route)): #print 'HEHEHEHEY' #print best_route, route #print best_cost #print best_cost, ">", route_cost, best_cost > route_cost #print len(route), "==", (len_valid_nodes + 1), len(route) == (len_valid_nodes + 1) best_route = copy.deepcopy(route) best_cost = route_cost best_route = best_route[::-1] best_route.pop() footprint = [] for point in best_route: footprint.append(list(ordered_points[int(point.split("_")[1])])) critical_points = copy.deepcopy(boundary_image) for point in footprint: critical_points[point[0], point[1]] = 5 #print "JEJEJEJEJEJJEJEJEJE", MIN_E_DISTANCE adjusted_route = adjust_route_v2(np.array(footprint)) # adjusted_route = adjust_route(np.array(footprint),mask_BR, max_temp = CURR_MAX_TEMP) # print np.array(footprint) # print "nyahahahaha" # print adjusted_route # # SA_building = np.zeros(boundary_image.shape, dtype=np.uint8) # print adjusted_route for idx in xrange(0, len(adjusted_route)): rr, cc = line(adjusted_route[idx][0], adjusted_route[idx][1], adjusted_route[idx-1][0], adjusted_route[idx-1][1]) SA_building[rr,cc] = 1 SA_building = ndimage.binary_fill_holes(SA_building) SA_building = SA_building * 1 for idx in xrange(0, len(adjusted_route)): SA_building[adjusted_route[idx][0], adjusted_route[idx][1]] = 2 final_route = copy.deepcopy(adjusted_route) try: adjust_itr = 1 MAX_ITR_FOR_ADJUSTING = 2 while adjust_itr <= MAX_ITR_FOR_ADJUSTING: adjusted_sides = adjust_sides(final_route, orig_rough_building) adjusted_rotation = adjust_rotation(adjusted_sides, orig_rough_building) # print "POTOTOY",adjust_itr, (final_route == adjusted_rotation) if np.array_equal(final_route,adjusted_rotation): # final_route = copy.deepcopy(adjusted_rotation) break else: final_route = copy.deepcopy(adjusted_rotation) adjust_itr += 1 except: print "Something went terribly wrong. Sht. I was working on index ", indexedObject[0] # final_route = copy.deepcopy(adjusted_route) # adjust_itr = 1 # MAX_ITR_FOR_ADJUSTING = 2 # while adjust_itr <= MAX_ITR_FOR_ADJUSTING: # adjusted_rotation = adjust_rotation(final_route, orig_rough_building) # adjusted_sides = adjust_sides(adjusted_rotation, orig_rough_building) # # print "POTOTOY",adjust_itr, (final_route == adjusted_rotation) # if np.array_equal(final_route,adjusted_sides): # # final_route = copy.deepcopy(adjusted_rotation) # break # else: # final_route = copy.deepcopy(adjusted_sides) # adjust_itr += 1 # adjusted_sides = adjust_sides(adjusted_route, orig_rough_building) # adjusted_rotation = adjust_rotation(adjusted_sides, orig_rough_building) # final_route = adjust_sides(adjusted_rotation, orig_rough_building) #print "ADJUSTING ITERATION", adjust_itr Adjusted_building = np.zeros(boundary_image.shape, dtype=np.uint8) for idx in xrange(0, len(final_route)): rr, cc = line(final_route[idx][0], final_route[idx][1], final_route[idx-1][0], final_route[idx-1][1]) Adjusted_building[rr,cc] = 1 Adjusted_building = ndimage.binary_fill_holes(Adjusted_building) Adjusted_building = Adjusted_building * 1 for idx in xrange(0, len(final_route)): Adjusted_building[final_route[idx][0], final_route[idx][1]] = 2 patong = copy.deepcopy(orig_rough_boundaries) patong[Adjusted_building > 0] = 2 patong[orig_rough_boundaries != 0] = 1 # approx_image = copy.deepcopy(boundary_image) # approx_image[approx_image > 0] = 0 # len_points = len(final_route) # for idx in xrange(0,len_points-1): # rr,cc = line(final_route[idx][0], final_route[idx][1], final_route[idx+1][0], final_route[idx+1][1]) # approx_image[rr,cc] = 4 # approx_image[final_route[idx][0], final_route[idx][1]] = 5 # approx_image[final_route[(idx+1)% len_points][0], final_route[(idx+1)% len_points][1]] = 5 # rr,cc = line(final_route[len_points-1][0], final_route[len_points-1][1], final_route[0][0], final_route[0][1]) # approx_image[rr,cc] = 4 # approx_image[approx_image>0] = 1 # filled = ndimage.binary_fill_holes(approx_image) # filled = filled*1 # filled[filled==1] = indexedObject[0] # test = copy.deepcopy(boundary_image) # test[filled > 0] = 2 # test[boundary_image != 0] = 1 Adjusted_building[Adjusted_building!=0] = indexedObject[0] t1=time.time() print "Finished processing index",indexedObject[0],"in",round(t1-t0,2),"s." # return indexedObject[0],filled,indexedObject[2] # return indexedObject[0],filled,indexedObject[2] # return indexedObject[0],Adjusted_building,indexedObject[2]
G=nx.Graph() print "Reading category file" with open(categoryLinksFile, 'rb') as f: reader = csv.reader(f, delimiter=',', quoting=csv.QUOTE_ALL, quotechar ='"', escapechar='\\', doublequote=False) for row in reader: G.add_node(row[0]) G.add_node(row[1]) G.add_edge(row[0], row[1]) #G.add_edge(row[1], row[0]) print "Floyd-Warshall" #path = nx.all_pairs_dijkstra_path(G) #path = nx.all_pairs_shortest_path_length(G) #path = nx.floyd_warshall(G) path = nx.floyd_warshall_predecessor_and_distance(G) #print G.nodes() #print path print "Generating categories for each page" with open(pageFile, 'rb') as f: reader = csv.reader(f, delimiter=',', quoting=csv.QUOTE_ALL, quotechar ='"', escapechar='\\', doublequote=False) for (page, cat) in reader: if cat not in path: #print "Page: ", row[0], " has category ", row[1], " which is not in paths map" continue