def test_weight_function(self):
"""Tests that a callable weight is interpreted as a weight
function instead of an edge attribute.
"""
# Create a triangle in which the edge from node 0 to node 2 has
# a large weight and the other two edges have a small weight.
G = nx.complete_graph(3)
G.adj[0][2]['weight'] = 10
G.adj[0][1]['weight'] = 1
G.adj[1][2]['weight'] = 1
# The weight function will take the multiplicative inverse of
# the weights on the edges. This way, weights that were large
# before now become small and vice versa.
def weight(u, v, d): return 1 / d['weight']
# The shortest path from 0 to 2 using the actual weights on the
# edges should be [0, 1, 2].
distance, path = nx.single_source_dijkstra(G, 0, 2)
assert_equal(distance, 2)
assert_equal(path, [0, 1, 2])
# However, with the above weight function, the shortest path
# should be [0, 2], since that has a very small weight.
distance, path = nx.single_source_dijkstra(G, 0, 2, weight=weight)
assert_equal(distance, 1 / 10)
assert_equal(path, [0, 2])
def ego_graph(G,n,radius=1,center=True,undirected=False,distance=None):
"""Returns induced subgraph of neighbors centered at node n within
a given radius.
Parameters
----------
G : nxgraph
A NetworkX Graph or DiGraph
n : node
A single node
radius : number, optional
Include all neighbors of distance<=radius from n.
center : bool, optional
If False, do not include center node in nxgraph
undirected : bool, optional
If True use both in- and out-neighbors of directed graphs.
distance : key, optional
Use specified edge data key as distance. For example, setting
distance='weight' will use the edge weight to measure the
distance from the node n.
Notes
-----
For directed graphs D this produces the "out" neighborhood
or successors. If you want the neighborhood of predecessors
first reverse the nxgraph with D.reverse(). If you want both
directions use the keyword argument undirected=True.
Node, edge, and nxgraph attributes are copied to the returned subgraph.
"""
if undirected:
if distance is not None:
sp,_=nx.single_source_dijkstra(G.to_undirected(),
n,cutoff=radius,
weight=distance)
else:
sp=nx.single_source_shortest_path_length(G.to_undirected(),
n,cutoff=radius)
else:
if distance is not None:
sp,_=nx.single_source_dijkstra(G,
n,cutoff=radius,
weight=distance)
else:
sp=nx.single_source_shortest_path_length(G,n,cutoff=radius)
H=G.subgraph(sp).copy()
if not center:
H.remove_node(n)
return H
def shortest_path_tree(self, node, search_type='time', cutoff=None):
if node in self.graph_time.nodes():
if search_type == 'distance':
dist, path = networkx.single_source_dijkstra(self.graph_dist, node, cutoff=cutoff)
elif search_type == 'time':
dist, path = networkx.single_source_dijkstra(self.graph_time, node, cutoff=cutoff)
else:
print 'invalid search type; valid values for variable - distance or time'
return None
else:
print 'Source node not found in the graph'
return None
return dist, path
def main():
'''
This is the main function
http://networkx.lanl.gov/reference/algorithms.operators.html
'''
# Get distance matrices
walking_times = read_weights_from_file(walking_time_filename)
shuttle_times = read_weights_from_file(shuttle_time_filename)
shuttle_connection_times = read_weights_from_file(shuttle_connection_time_filename)
outdoorness_matrix = read_weights_from_file(outdoorness_filename)
#print outdoorness_matrix
# Add penalties
shuttle_connection_times = apply_penalty(shuttle_connection_times, shuttle_penalty/2, 'add') # /2 because we get in and out the shuttle, so we don't want to have a double penalty
walking_times = apply_penalty(walking_times, walking_penalty , 'multiply')
walking_times = apply_outdoor_penalty(walking_times, outdoorness_matrix, outdoorness_penalty)
# Create subgraphs
walking_graph = nx.DiGraph(data=walking_times)
#print G.edges(data=True)
walking_graph = nx.relabel_nodes(walking_graph,convert_list_to_dict(read_node_labels(walking_time_filename)))
print 'walking_graph', walking_graph.edges(data=True)
shuttle_graph = nx.DiGraph(data=shuttle_times)
shuttle_graph = nx.relabel_nodes(shuttle_graph,convert_list_to_dict(read_node_labels(shuttle_time_filename)))
print 'shuttle_graph', shuttle_graph.edges(data=True)
shuttle_connection_graph = nx.DiGraph(data=shuttle_connection_times)
shuttle_connection_graph = nx.relabel_nodes(shuttle_connection_graph,convert_list_to_dict(read_node_labels(shuttle_connection_time_filename)))
print 'shuttle_connection_graph', shuttle_connection_graph.edges(data=True)
# Create main graph
main_graph = nx.compose(walking_graph, shuttle_graph)
print 'main_graph', main_graph.edges(data=True)
main_graph = nx.compose(main_graph, shuttle_connection_graph)
print 'main_graph', main_graph.edges(data=True)
# Compute the shortest paths and path lengths between nodes in the graph.
# http://networkx.lanl.gov/reference/algorithms.shortest_paths.html
compute_shortest_path(main_graph, '32', 'NW86')
compute_shortest_path(main_graph, 'W7', 'W20')
compute_shortest_path(main_graph, '50', '35')
#print nx.dijkstra_predecessor_and_distance(main_graph, 'NW86')
# Compute shortest paths and lengths in a weighted graph G. TODO: Return farthest region.
print nx.single_source_dijkstra(main_graph, '32', 'NW86')
# Compute KSP (k-shortest paths) using https://github.com/Pent00/YenKSP
yenksp_digraph = convert_nx_digraph_into_yenksp_digraph(main_graph)
print ksp_yen(yenksp_digraph, 'NW86', '32', 2)
def mst_of_g(g,terminals,verbose=False,weighted=True,cutoff=7,return_gL=False,bidir=False):
STARTTIME=time.time()
if verbose:
logger.info("Starting MST construction")
sys.stdout.flush()
STARTTIME=time.time()
gLedges=[]
shortest_network=model.AnnotatedGraph()
for i in range(len(terminals)):
src=terminals[i]
if src not in g:
if verbose:
logger.info("Node %s not in g"%(src))
continue
if weighted:
costs,paths=nx.single_source_dijkstra(g, src, weight='weight',cutoff=cutoff)
else:
paths=nx.single_source_shortest_path(g,src,cutoff=cutoff)
costs=dict([(k,len(v)) for k,v in paths.items()])
if bidir:
span=range(len(terminals))
else:
span=range(i+1,len(terminals))
for j in span:
if j==i:
continue
tgt=terminals[j]
if tgt not in paths:
if verbose:
logger.info("no paths between %s and %s"%(src,tgt))
continue
shortest_network.add_path(paths[tgt])
gLedges.append((src,tgt,{'weight':costs[tgt],'path':paths[tgt]}))
if verbose:
logger.info("Done %s. Still %d to go"%(src,len(terminals)-i))
sys.stdout.flush()
if verbose:
logger.info("Computed Metric closure in %f seconds"%(time.time() - STARTTIME))
STARTTIME=time.time()
sys.stdout.flush()
gL=nx.Graph()
gL.add_edges_from(gLedges)
# Min spanning Tree
tL=nx.minimum_spanning_tree(gL)
if verbose:
logger.info("Computed Min spanning tree in %f seconds"%(time.time() - STARTTIME))
STARTTIME=time.time()
sys.stdout.flush()
mst=model.AnnotatedGraph()
for e in tL.edges(data=True):
mst.add_path(e[2]["path"])
copy_attributes_from_g(mst,g)
if return_gL:
return mst,gL,shortest_network
else:
return mst
def path_to(self, source, target):
"""Return distance, path.
path[target]
distance[target]
"""
return nx.single_source_dijkstra(self.graph, source, target)
def topk_naive2(G, s, R, K):
"""
finds all business in the region and returns an iterator of K shortest paths
find shortest path to all reachable nodes from source by Disjktra's
return paths and lengths for filtered nodes in the region by R-Tree
:param G: NetworkX Graph instance
:param s: Source vertex's ID as a string or number that can be found in G
:param R: Region of interest as list of co-ordinates [nelat, nelong, swlat, swlong]
:param K: Number of shortest paths to compute
:return: Iterator of tuples (distance from s, path from s)
"""
# start = time.time()
# print '\nStarted Algorithm at %s' % (start,)
biz = business_in_loc(R[0], R[1], R[2], R[3])
# print 'After %ss: Found %s businesses in the region %s' % (time.time() - start, len(biz), R)
length, path = nx.single_source_dijkstra(G, s)
res = []
for b in biz:
b = BUSINESS_NODE_PREFIX + b
try:
res.append((length[b], path[b], b))
except KeyError:
# This business is not reachable from s
res.append((float("inf"), [], b))
# print 'After %ss: Found shortest path from %s to %s' % (time.time() - start, s, b)
res.sort()
return res[:K]
def connect_shortest_v3(weigthed_graph,nodes,weighted=True,cutoff=None,verbose=False): STARTTIME=time.time() if verbose: print "Starting SHOV3 construction" sys.stdout.flush() STARTTIME=time.time() res=nx.Graph() for i in range(len(nodes)): src=nodes[i] if src not in weigthed_graph: continue if weighted: costs,spaths=nx.single_source_dijkstra(weigthed_graph, src, weight='weight',cutoff=cutoff) else: spaths=nx.single_source_shortest_path(weigthed_graph, src,cutoff=cutoff) for j in range(i+1, len(nodes)): t=nodes[j] if t not in spaths: continue if cutoff and (len(spaths[t])>cutoff): continue res.add_path(spaths[t]) if verbose: print "Done",src,"to go:",len(nodes)-i sys.stdout.flush() if verbose: print "Computed SHOV3,",time.time() - STARTTIME,"seconds" STARTTIME=time.time() sys.stdout.flush() return res
def prepare(neighbours, costs, benefits, S, C, handpicked_targets=None):
# return moves, visitations, cars, score
if handpicked_targets is None:
return {i: [S] for i in xrange(C)}, set(), sort_cars([car_type(i, S, S, 0, 0) for i in xrange(C)]), 0
score = 0
G = nx.DiGraph()
for (fr, tos) in neighbours.iteritems():
G.add_node(fr)
for to in tos:
G.add_edge(fr, to, weight=costs[(fr, to)])
distances, shortest_paths = nx.single_source_dijkstra(G, S)
paths = {target: (distances[target], shortest_paths[target]) for target in handpicked_targets}
cars = []
visitations = set()
moves = {}
for (i, (target, (dist, path))) in enumerate(paths.items()):
assert target == path[-1]
cars.append(car_type(i, path[-2], path[-1], None, dist))
for (k, l) in zip(path[:-1], path[1:]):
if (k, l) not in visitations and (l, k) not in visitations:
score += benefits[(k, l)]
visitations.add((k, l))
visitations.add((l, k))
moves[i] = path
return moves, visitations, cars, score
def yen_ksp(G, src, tgt, top_K):
from copy import deepcopy
def getWeight(p, w=0):
for i in range(len(p) - 1):
w += G[p[i]][p[i + 1]]['weight']
return w
_cost, _path = nx.single_source_dijkstra(G, src, tgt)
A = [_path[tgt]]
costs = [_cost[tgt]]
B = PriorityQueue()
for k in range(1, top_K):
_G = deepcopy(G)
for i in range(len(A[k - 1]) - 1):
spurNode = A[k - 1][i]
rootPath = A[k - 1][:i]
for path in A:
if A[k - 1][:i + 1] == path[:i + 1] and _G.has_edge(path[i], path[i + 1]):
_G.remove_edge(path[i], path[i + 1])
if len(rootPath) > 0 and spurNode != tgt:
extra_edges = _G.edges(rootPath[len(rootPath) - 1])
for ed in extra_edges:
_G.remove_edge(ed[0], ed[1])
try:
spurPathCost, spurPath = nx.single_source_dijkstra(_G, spurNode, tgt)
spurPath = spurPath[tgt]
except Exception as e:
spurPath = []
if len(spurPath) > 0:
totalPath = rootPath + spurPath
B.put((getWeight(totalPath), totalPath))
if B.empty():
break
while not B.empty():
cost, path = B.get()
if path not in A:
A.append(path)
costs.append(cost)
break
return A, costs
def sampling(G,cent,hop,cover): G2 = share.vincity(G,cent,hop) sp = nx.single_source_dijkstra(G2,cent) for path in sp[1].values(): if len(path) >= hop: if len(set(path) & set(cover))==0: return True return False
def test_dijkstra(self):
(D,P)= nx.single_source_dijkstra(self.XG,'s')
assert_equal(P['v'], ['s', 'x', 'u', 'v'])
assert_equal(D['v'],9)
assert_equal(nx.single_source_dijkstra_path(self.XG,'s')['v'],
['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_dijkstra_path_length(self.XG,'s')['v'],9)
assert_equal(nx.single_source_dijkstra(self.XG,'s')[1]['v'],
['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_dijkstra_path(self.MXG,'s')['v'],
['s', 'x', 'u', 'v'])
GG=self.XG.to_undirected()
(D,P)= nx.single_source_dijkstra(GG,'s')
assert_equal(P['v'] , ['s', 'x', 'u', 'v'])
assert_equal(D['v'],8) # uses lower weight of 2 on u<->x edge
assert_equal(nx.dijkstra_path(GG,'s','v'), ['s', 'x', 'u', 'v'])
assert_equal(nx.dijkstra_path_length(GG,'s','v'),8)
assert_equal(nx.dijkstra_path(self.XG2,1,3), [1, 4, 5, 6, 3])
assert_equal(nx.dijkstra_path(self.XG3,0,3), [0, 1, 2, 3])
assert_equal(nx.dijkstra_path_length(self.XG3,0,3),15)
assert_equal(nx.dijkstra_path(self.XG4,0,2), [0, 1, 2])
assert_equal(nx.dijkstra_path_length(self.XG4,0,2), 4)
assert_equal(nx.dijkstra_path(self.MXG4,0,2), [0, 1, 2])
assert_equal(nx.single_source_dijkstra(self.G,'s','v')[1]['v'],
['s', 'u', 'v'])
assert_equal(nx.single_source_dijkstra(self.G,'s')[1]['v'],
['s', 'u', 'v'])
assert_equal(nx.dijkstra_path(self.G,'s','v'), ['s', 'u', 'v'])
assert_equal(nx.dijkstra_path_length(self.G,'s','v'), 2)
# NetworkXError: node s not reachable from moon
assert_raises(nx.NetworkXError,nx.dijkstra_path,self.G,'s','moon')
assert_raises(nx.NetworkXError,nx.dijkstra_path_length,self.G,'s','moon')
assert_equal(nx.dijkstra_path(self.cycle,0,3),[0, 1, 2, 3])
assert_equal(nx.dijkstra_path(self.cycle,0,4), [0, 6, 5, 4])
def diameter_dic(graph):
ds = {}
for start_nodes in graph:
distance_dic, path_dic = nx.single_source_dijkstra(graph,start_nodes)
far_node = max(distance_dic, key=distance_dic.get) #Farthest Node
ds[start_nodes] = [far_node]
dis_from_far_node = distance_dic[far_node]
ds[start_nodes].append(dis_from_far_node)
return ds
def get_Rel_one(self,ipt,tp,N,cut=6.0):
if N>= len( nx.node_connected_component(self.G, ipt) ):
N=len( nx.node_connected_component(self.G, ipt) )
T2L,T2P=nx.single_source_dijkstra(self.G,ipt,cutoff=cut,weight=tp)
count=len(T2L.keys())
while count<N:
cut=cut+1.0
T2L,T2P=nx.single_source_dijkstra(self.G,ipt,cutoff=cut,weight=tp)
count=len(T2L.keys())
sorted_T=sorted(T2L.keys(),key=T2L.get)[:N]
Rel=[]
for t in sorted_T:
Rel.append((t,[T2L[t],T2P[t]]))
Rel=collections.OrderedDict(Rel)
return Rel
def get_effdist_tree(G, source, cutoff=None, create_using=nx.DiGraph, weight="weight", effdist_key="effdist"):
T = create_using()
T.graph["root"] = source
T.add_node(source)
length, path = nx.single_source_dijkstra(G, source, cutoff=cutoff, weight=weight)
for n in path.keys():
T.add_path(path[n])
T.node[n][effdist_key] = length[n]
return T
def build_prism_between_nodes_static(self, g, source, dest, t_s, t_d):
ti = time.time()
reached_d, reached_path = networkx.single_source_dijkstra(g, source, cutoff=t_d-t_s)
#print '\tReached retrieved in', time.time()-ti
ti = time.time()
left_d, left_path = networkx.single_source_dijkstra(g, dest, cutoff=t_d-t_s)
#print '\tLeft retrieved in', time.time()-ti
#print ('\tDestination(s) reached from source starting at %s within %s analysis intervals is %s' %
# (t_s, t_d, len(reached_d)))
#print ('\tDestination(s) accessed to destination by %s start after %s analysis intervals is %s' %
# (t_d, t_s, len(left_d)))
#print 'cutoff = ', t_d-t_s
#print 'max_dist = ', max(reached_d.values()), max(left_d.values())
dests_accessible = {}
for i in reached_d:
if i in left_d and ((reached_d[i] + left_d[i]) < t_d - t_s):
dests_accessible[i] = reached_d[i]
return dests_accessible
def test_dijkstra(self):
(D, P) = nx.single_source_dijkstra(self.XG, "s")
assert_equal(P["v"], ["s", "x", "u", "v"])
assert_equal(D["v"], 9)
assert_equal(nx.single_source_dijkstra_path(self.XG, "s")["v"], ["s", "x", "u", "v"])
assert_equal(nx.single_source_dijkstra_path_length(self.XG, "s")["v"], 9)
assert_equal(nx.single_source_dijkstra(self.XG, "s")[1]["v"], ["s", "x", "u", "v"])
assert_equal(nx.single_source_dijkstra_path(self.MXG, "s")["v"], ["s", "x", "u", "v"])
GG = self.XG.to_undirected()
(D, P) = nx.single_source_dijkstra(GG, "s")
assert_equal(P["v"], ["s", "x", "u", "v"])
assert_equal(D["v"], 8) # uses lower weight of 2 on u<->x edge
assert_equal(nx.dijkstra_path(GG, "s", "v"), ["s", "x", "u", "v"])
assert_equal(nx.dijkstra_path_length(GG, "s", "v"), 8)
assert_equal(nx.dijkstra_path(self.XG2, 1, 3), [1, 4, 5, 6, 3])
assert_equal(nx.dijkstra_path(self.XG3, 0, 3), [0, 1, 2, 3])
assert_equal(nx.dijkstra_path_length(self.XG3, 0, 3), 15)
assert_equal(nx.dijkstra_path(self.XG4, 0, 2), [0, 1, 2])
assert_equal(nx.dijkstra_path_length(self.XG4, 0, 2), 4)
assert_equal(nx.dijkstra_path(self.MXG4, 0, 2), [0, 1, 2])
assert_equal(nx.single_source_dijkstra(self.G, "s", "v")[1]["v"], ["s", "u", "v"])
assert_equal(nx.single_source_dijkstra(self.G, "s")[1]["v"], ["s", "u", "v"])
assert_equal(nx.dijkstra_path(self.G, "s", "v"), ["s", "u", "v"])
assert_equal(nx.dijkstra_path_length(self.G, "s", "v"), 2)
# NetworkXError: node s not reachable from moon
assert_raises(nx.NetworkXNoPath, nx.dijkstra_path, self.G, "s", "moon")
assert_raises(nx.NetworkXNoPath, nx.dijkstra_path_length, self.G, "s", "moon")
assert_equal(nx.dijkstra_path(self.cycle, 0, 3), [0, 1, 2, 3])
assert_equal(nx.dijkstra_path(self.cycle, 0, 4), [0, 6, 5, 4])
def mst_of_g(g,terminals,verbose=False,weighted=True):
STARTTIME=time.time()
GLOBALTIME=STARTTIME
if verbose:
print "Starting MST construction"
sys.stdout.flush()
STARTTIME=time.time()
gLedges=[]
for i in range(len(terminals)):
src=terminals[i]
if src not in g:
continue
if weighted:
costs,paths=nx.single_source_dijkstra(g, src, weight='weight',cutoff=7)
else:
paths=nx.single_source_shortest_path(g,src,cutoff=7)
costs=dict([(k,len(v)) for k,v in paths.items()])
for j in range(i+1,len(terminals)):
tgt=terminals[j]
if tgt not in paths:
continue
gLedges.append((src,tgt,{'weight':costs[tgt],'path':paths[tgt]}))
if verbose:
print "Done",src,"to go:",len(terminals)-i
sys.stdout.flush()
if verbose:
print "Computed Metric closure,",time.time() - STARTTIME,"seconds"
STARTTIME=time.time()
sys.stdout.flush()
gL=nx.Graph()
gL.add_edges_from(gLedges)
# Min spanning Tree
tL=nx.minimum_spanning_tree(gL)
if verbose:
print "Computed Min spanning tree,",time.time() - STARTTIME,"seconds"
STARTTIME=time.time()
sys.stdout.flush()
mst=nx.Graph()
for e in tL.edges(data=True):
mst.add_path(e[2]["path"])
if verbose:
print "Totla comp time,",time.time() - GLOBALTIME,"seconds"
sys.stdout.flush()
return mst
def main():
G = nx.DiGraph() # G eh um grafo direcionado
# gera o grafo apartir de suas arestas
G.add_weighted_edges_from([(1,2,2.0),(1,3,1.0),(2,3,3.0),(2,4,3.0),(3,5,1.0),(4,6,2.0),(5,4,2.0),(5,6,5.0)])
for i in G.edges():
# print i[0], i[1]
G[i[0]][i[1]]["color"] = "black"
# G[1][2]["color"] = "red"
comprimento, caminho = nx.single_source_dijkstra(G, 1)
print caminho
for i in caminho:
print i, comprimento[i], caminho[i]
for j in range(1, len(caminho[i])):
#print caminho[i][j-1], caminho[i][j]
G[caminho[i][j-1]][caminho[i][j]]["color"] = "red"
desenhaGrafo(G, "grafo-1c.png")
def local_query_edit(G,start,end,cover,k):
G2 = share.vincity(G,start,k)
sp = nx.single_source_dijkstra(G2,start)
n_set = {}
loc_dist = -1
if end in sp[1]:
loc_dist = sp[0][end]
for path in sp[1].values():
tmp = list(set(path[1:])&set(cover))
if len(tmp)>0:
tmp = tmp[0]
if tmp not in n_set:
n_set[tmp] = sp[0][tmp]
return [n_set,loc_dist]
def main():
G = nx.DiGraph() # G eh um grafo direcionado
# gera o grafo apartir de suas arestas
G.add_weighted_edges_from([(1,2,20),(1,3,15),(2,1,2),(2,4,10),(2,5,25),(3,2,4),(3,4,25),(3,5,10),(4,6,15),(5,4,10),(5,6,4)])
for i in G.edges():
# print i[0], i[1]
G[i[0]][i[1]]["color"] = "black"
# G[1][2]["color"] = "red"
distancia, caminho = nx.single_source_dijkstra(G,1)
print caminho
print distancia
for i in caminho:
print i, caminho[i]
for j in range(1, len(caminho[i])):
#print caminho[i][j-1], caminho[i][j]
G[caminho[i][j-1]][caminho[i][j]]["color"] = "red"
desenhaGrafo(G, "grafo-1a.png")
def buildNeighbors(graph, cutoff, source=None):
'''
This method returns a dictionary keyed by node source index that contains
another dictionary keyed by target node index. The values are the weighted
shortest path lengths from source to target that are below a certain
cutoff value
if a source is set, then neighbours are only calculated for this node
'''
if source:
distanceDict = nx.single_source_dijkstra(graph, source, cutoff)
else:
print('Begin calculating for all nodes with radius %.2f.' % (cutoff))
distanceDict = nx.all_pairs_dijkstra_path_length(graph, cutoff)
print('Done calculating for all nodes with radius %.2f.' % (cutoff))
return distanceDict
def main():
G = nx.DiGraph() # G eh um grafo direcionado
# gera o grafo apartir de suas arestas
G.add_weighted_edges_from([(1, 2, 2), (1, 3, 6), (1, 4, 3), (2, 3, 5),
(2, 5, 8), (3, 5, 3), (4, 3, 2), (4, 6, 9),
(5, 6, 1)])
for i in G.edges():
# print i[0], i[1]
G[i[0]][i[1]]["color"] = "black"
# G[1][2]["color"] = "red"
distancia, caminho = nx.single_source_dijkstra(G, 1)
print distancia
print caminho
for i in caminho:
print i, caminho[i]
for j in range(1, len(caminho[i])):
#print caminho[i][j-1], caminho[i][j]
G[caminho[i][j - 1]][caminho[i][j]]["color"] = "red"
desenhaGrafo(G, "grafo-1d.png")
def all_or_nothing_assignment(self):
"""
Method for implementing all-or-nothing assignment based on the current graph. \n
It updates link traffic flow
"""
for edge in self.graph.edges(data=True):
edge[2]['object'].vol = 0
shortestpath_graph = {}
for i in self.origins:
shortestpath_graph[i] = nx.single_source_dijkstra(self.graph,
i,
weight="weight")
for (i, j) in self.od_vols:
odvol = self.od_vols[(i, j)]
path = shortestpath_graph[str(i)][1][str(j)]
for p in range(len(path) - 1):
fnode, tnode = path[p], path[p + 1]
self.graph[fnode][tnode]["object"].vol += odvol
def shortes_path_in_graph(G, source_airport_id, destination_airport_id, k):
# copy graph
H = G.copy()
airports_list = list()
weigh_list = list()
airline_list = list()
for qq in range(0, k + 1):
tmp = nx.single_source_dijkstra(H, source_airport_id, destination_airport_id, weight='weight')
weigh_list.append(tmp[0])
airports_list.append(tmp[1])
airline_list_tmp = list()
count = 0
ptr = tmp[1]
for i in tmp[1]:
if count == 0:
ptr = i
count += 1
else:
wght = 99999999
# find edge with the lowest weight that was used
for (u, v, kk, c) in H.edges(data=True, keys=True):
### c-dict data kk-key edges
if u == ptr and v == i:
if (wght > c['weight']):
wght = c['weight']
kkey = kk
air_id = c['airline_id']
airline_list_tmp.append(air_id)
# go all the way and collect airlines numbers
H.remove_edge(ptr, i, kkey)
ptr = i
airline_list.append(airline_list_tmp)
print(weigh_list)
print(airports_list)
print(airline_list)
return geo_helper.ShortestPaths(weigh_list, airports_list, airline_list)
def get_star_overlay(connectivity_graph, centrality):
"""
Generate server connectivity graph given an underlay topology represented as an nx.Graph
:param connectivity_graph: nx.Graph() object, each edge should have availableBandwidth:
"latency", "availableBandwidth" and "weight";
:param centrality: mode of centrality to use, possible: "load", "distance", "information", default="load"
:return: nx.Graph()
"""
if centrality == "distance":
centrality_dict = nx.algorithms.centrality.closeness_centrality(connectivity_graph, distance="latency")
server_node = max(centrality_dict, key=centrality_dict.get)
elif centrality == "information":
centrality_dict = nx.algorithms.centrality.information_centrality(connectivity_graph, weight="latency")
server_node = max(centrality_dict, key=centrality_dict.get)
else:
# centrality = load_centrality
centrality_dict = nx.algorithms.centrality.load_centrality(connectivity_graph, weight="latency")
server_node = max(centrality_dict, key=centrality_dict.get)
weights, paths = nx.single_source_dijkstra(connectivity_graph, source=server_node, weight="weight")
star = nx.Graph()
star.add_nodes_from(connectivity_graph.nodes(data=True))
for node in paths.keys():
if node != server_node:
latency = 0.
available_bandwidth = 1e32
for idx in range(len(paths[node]) - 1):
u = paths[node][idx]
v = paths[node][idx + 1]
data = connectivity_graph.get_edge_data(u, v)
latency += data["latency"]
available_bandwidth = data["availableBandwidth"]
star.add_edge(server_node, node, availableBandwidth=available_bandwidth, latency=latency)
return star
def get_to_kols(therapeutic_area, country, kol_from, degree):
if pd.notna(kol_from) and kol_from != '':
ids = all_nodes_dupe.loc[
((all_nodes_dupe.country == country) | (country == None))
& ((all_nodes_dupe.synonym == therapeutic_area)
| (therapeutic_area == None)) &
(all_nodes_dupe.fullname == kol_from)].sort_values(
'eigenvector', ascending=False).id.unique()
kol_from_id = ids[0]
length, path = nx.single_source_dijkstra(G, kol_from_id, cutoff=degree)
s = G.subgraph(path)
nodes, edges = getNodesEdges(s, kol_from_id)
to_kols = [
(sub['id'], length[sub['id']] * 100 -
(s.edges[kol_from_id, sub['id']]['totalLinkages']
if length[sub['id']] == 1 else 0),
str(int(length[sub['id']])) + '-deg ' +
((str(int(s.edges[kol_from_id, sub['id']]['totalLinkages'])) +
'-linkages: ') if length[sub['id']] == 1 else ': ') +
sub['label'] + ' (' + sub['country'] + ' - ' +
str(sub['specialties']) + ' specialties, ' +
('both share ' +
(str(
int(s.edges[kol_from_id,
sub['id']]['Shared_organization_link'])) +
' Orgs, ' + str(
int(s.edges[kol_from_id, sub['id']]
['Shared_clinical_trials_link'])) + ' Clin.Trials, ' +
str(int(s.edges[kol_from_id, sub['id']]['Shared_articles_Link'])
) + ' Articles') if length[sub['id']] == 1 else '') + ')')
for sub in nodes
if (sub['country'] == country or country == None) &
(therapeutic_area in sub['specialty'] or therapeutic_area == None)
]
to_kols = [{'label': n, 'value': x, 'order': i} for x, i, n in to_kols]
to_kols = [{
'label': y['label'],
'value': y['value']
} for y in sorted(to_kols, key=lambda x: x['order'])]
information = 'Display network of ' + str(
len(to_kols)) + ' Stakeholders'
return [information, kol_from_id, to_kols, '']
def main():
G = nx.Graph() # G eh um grafo direcionado
# gera o grafo apartir de suas arestas
G.add_weighted_edges_from([(1, 2, 2), (1, 3, 15), (2, 3, 24), (2, 4, 4),
(2, 5, 11), (3, 4, 2), (3, 5, 10), (4, 5, 5),
(4, 6, 15), (5, 6, 18)])
for i in G.edges():
# print i[0], i[1]
G[i[0]][i[1]]["color"] = "black"
# G[1][2]["color"] = "red"
comprimento, caminho = nx.single_source_dijkstra(G, 1)
print caminho
for i in caminho:
# print i, comprimento[i], caminho[i]
for j in range(1, len(caminho[i])):
print caminho[i][j - 1], caminho[i][j]
G[caminho[i][j - 1]][caminho[i][j]]["color"] = "red"
desenhaGrafo(G, "grafo-6.png")
T = nx.minimum_spanning_tree(G)
desenhaGrafo(T, "grafo-6arv.png")
def ptva_li(graph, obs_time, distribution):
mu = distribution.mean()
sigma = distribution.std()
obs = np.array(list(obs_time.keys()))
path_lengths = {}
paths = {}
for o in obs:
path_lengths[o], paths[o] = nx.single_source_dijkstra(graph, o)
### Run the estimation
s_est, likelihoods, d_mu, cov = se.ml_estimate(graph, obs_time, sigma, mu,
paths, path_lengths)
ranked = sorted(likelihoods.items(),
key=operator.itemgetter(1),
reverse=True)
return (s_est, ranked)
def complete_matrix(tree, G):
nodes = list(tree.nodes())
print("printing nodes now", nodes)
num = len(nodes)
matrix = []
max_edge = 0
for i in range(num):
adj_list = [0]
for x in range(i):
adj_list.append(0)
node = nodes[i]
for j in range(i + 1, num):
node2 = nodes[j]
if G.has_edge(node, node2):
adj_list.append(G.get_edge_data(node, node2)['weight'])
else:
length, path = nx.single_source_dijkstra(tree, node, node2)
adj_list.append(length)
matrix.append(adj_list)
return matrix
def test_dijkstra(self):
(D, P) = nx.single_source_dijkstra(self.XG, 's')
validate_path(self.XG, 's', 'v', 9, P['v'])
assert_equal(D['v'], 9)
validate_path(
self.XG, 's', 'v', 9, nx.single_source_dijkstra_path(self.XG, 's')['v'])
assert_equal(
nx.single_source_dijkstra_path_length(self.XG, 's')['v'], 9)
validate_path(
self.XG, 's', 'v', 9, nx.single_source_dijkstra(self.XG, 's')[1]['v'])
validate_path(
self.MXG, 's', 'v', 9, nx.single_source_dijkstra_path(self.MXG, 's')['v'])
GG = self.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
(D, P) = nx.single_source_dijkstra(GG, 's')
validate_path(GG, 's', 'v', 8, P['v'])
assert_equal(D['v'], 8) # uses lower weight of 2 on u<->x edge
validate_path(GG, 's', 'v', 8, nx.dijkstra_path(GG, 's', 'v'))
assert_equal(nx.dijkstra_path_length(GG, 's', 'v'), 8)
validate_path(self.XG2, 1, 3, 4, nx.dijkstra_path(self.XG2, 1, 3))
validate_path(self.XG3, 0, 3, 15, nx.dijkstra_path(self.XG3, 0, 3))
assert_equal(nx.dijkstra_path_length(self.XG3, 0, 3), 15)
validate_path(self.XG4, 0, 2, 4, nx.dijkstra_path(self.XG4, 0, 2))
assert_equal(nx.dijkstra_path_length(self.XG4, 0, 2), 4)
validate_path(self.MXG4, 0, 2, 4, nx.dijkstra_path(self.MXG4, 0, 2))
validate_path(
self.G, 's', 'v', 2, nx.single_source_dijkstra(self.G, 's', 'v')[1]['v'])
validate_path(
self.G, 's', 'v', 2, nx.single_source_dijkstra(self.G, 's')[1]['v'])
validate_path(self.G, 's', 'v', 2, nx.dijkstra_path(self.G, 's', 'v'))
assert_equal(nx.dijkstra_path_length(self.G, 's', 'v'), 2)
# NetworkXError: node s not reachable from moon
assert_raises(nx.NetworkXNoPath, nx.dijkstra_path, self.G, 's', 'moon')
assert_raises(
nx.NetworkXNoPath, nx.dijkstra_path_length, self.G, 's', 'moon')
validate_path(self.cycle, 0, 3, 3, nx.dijkstra_path(self.cycle, 0, 3))
validate_path(self.cycle, 0, 4, 3, nx.dijkstra_path(self.cycle, 0, 4))
assert_equal(
nx.single_source_dijkstra(self.cycle, 0, 0), ({0: 0}, {0: [0]}))
def dijkstra_tree_old(G, v, targets=None):
"""
Deprecated method for finding shortest path tree
"""
edgeSet = set()
T = nx.Graph()
T.add_nodes_from(range(len(G.nodes())))
dists, paths = nx.single_source_dijkstra(G, v)
if targets != None:
paths = {v: paths[v] for v in paths if v in targets}
for p in paths.values():
for i in range(len(p) - 1):
edgeSet.add((p[i], p[i + 1]))
T.add_edges_from(edgeSet)
for e in T.edges():
T.edges[e]['weight'] = G.edges[e]['weight']
#remove vertices of degree 0 because they're not targets
if targets != None:
T.remove_nodes_from([v for v in T.nodes() if T.degree()[v] == 0])
return T
def test_dijkstra(self):
(D, P) = nx.single_source_dijkstra(self.XG, 's')
validate_path(self.XG, 's', 'v', 9, P['v'])
assert_equal(D['v'], 9)
validate_path(
self.XG, 's', 'v', 9, nx.single_source_dijkstra_path(self.XG, 's')['v'])
assert_equal(dict(
nx.single_source_dijkstra_path_length(self.XG, 's'))['v'], 9)
validate_path(
self.XG, 's', 'v', 9, nx.single_source_dijkstra(self.XG, 's')[1]['v'])
validate_path(
self.MXG, 's', 'v', 9, nx.single_source_dijkstra_path(self.MXG, 's')['v'])
GG = self.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
(D, P) = nx.single_source_dijkstra(GG, 's')
validate_path(GG, 's', 'v', 8, P['v'])
assert_equal(D['v'], 8) # uses lower weight of 2 on u<->x edge
validate_path(GG, 's', 'v', 8, nx.dijkstra_path(GG, 's', 'v'))
assert_equal(nx.dijkstra_path_length(GG, 's', 'v'), 8)
validate_path(self.XG2, 1, 3, 4, nx.dijkstra_path(self.XG2, 1, 3))
validate_path(self.XG3, 0, 3, 15, nx.dijkstra_path(self.XG3, 0, 3))
assert_equal(nx.dijkstra_path_length(self.XG3, 0, 3), 15)
validate_path(self.XG4, 0, 2, 4, nx.dijkstra_path(self.XG4, 0, 2))
assert_equal(nx.dijkstra_path_length(self.XG4, 0, 2), 4)
validate_path(self.MXG4, 0, 2, 4, nx.dijkstra_path(self.MXG4, 0, 2))
validate_path(
self.G, 's', 'v', 2, nx.single_source_dijkstra(self.G, 's', 'v')[1]['v'])
validate_path(
self.G, 's', 'v', 2, nx.single_source_dijkstra(self.G, 's')[1]['v'])
validate_path(self.G, 's', 'v', 2, nx.dijkstra_path(self.G, 's', 'v'))
assert_equal(nx.dijkstra_path_length(self.G, 's', 'v'), 2)
# NetworkXError: node s not reachable from moon
assert_raises(nx.NetworkXNoPath, nx.dijkstra_path, self.G, 's', 'moon')
assert_raises(
nx.NetworkXNoPath, nx.dijkstra_path_length, self.G, 's', 'moon')
validate_path(self.cycle, 0, 3, 3, nx.dijkstra_path(self.cycle, 0, 3))
validate_path(self.cycle, 0, 4, 3, nx.dijkstra_path(self.cycle, 0, 4))
assert_equal(
nx.single_source_dijkstra(self.cycle, 0, 0), ({0: 0}, {0: [0]}))
def augment_graph(self, pairs):
# create a new graph and stuff in the new fake/virtual edges
# between odd pairs. Generate the edge metadata to make them
# look similar to the native edges.
log.info('pre augmentation eulerian=%s',
nx.is_eulerian(self.g_augmented))
for i, pair in enumerate(pairs):
a, b = pair
length, path = nx.single_source_dijkstra(self.g,
a,
b,
weight='length')
log.debug('PAIR[%s] nodes = (%s,%s), length=%s, path=%s', i, a, b,
length, path)
linestring = self.path_to_linestring(self.g_augmented, path)
# create a linestring of paths...
data = {
'length': length,
'augmented': True,
'path': path,
'geometry': linestring,
'from': a,
'to': b,
}
log.debug(' creating new edge (%s,%s) - data=%s', a, b, data)
self.g_augmented.add_edge(a, b, **data)
pass
log.info('post augmentation eulerian=%s',
nx.is_eulerian(self.g_augmented))
return
def single_source_dijkstra(graph,
source,
data,
route='route_id',
stop='destination',
return_type='list'):
"""
:param graph: networkx DiGraph to perform the search in
:param source: source of the dijkstra search
:param data: dict that contains the data of the edges of the graph
(besides the weight). route and destination station for example
:param route: name of the group identifier (route_id, trip_id, pattern...). Most probably :Â 'route_id'
:param stop: key to the stop_id in data:
:return:
"""
lengths, paths = nx.single_source_dijkstra(graph, source)
to_return = {
'stops': [{
'source': source,
'target': key,
'path': [data[p][stop] for p in value],
'routes': set([data[p][route] for p in value]),
'transfers': len(set([data[p][route] for p in value])) - 2,
'length': lengths[key]
} for key, value in paths.items() if type(key) == str],
'links': [{
'source': source,
'target': key,
'path': [data[p][stop] for p in value],
'routes': set([data[p][route] for p in value]),
'transfers': len(set([data[p][route] for p in value])) - 2,
'length': lengths[key]
} for key, value in paths.items() if type(key) == int],
}
return to_return if return_type == 'list' else {
kind: {item['target']: item
for item in to_return[kind]}
for kind in to_return.keys()
} # never tested, may be bugged
def CalculateSSPTree(idx_train, labels, nclass, B, isdirected):
labels_train = labels[idx_train]
rank_result = [None] * nclass
weight_result = [None] * nclass
for j in range(0, nclass):
indexes = [idx_train[i] for i, x in enumerate(labels_train) if x == j]
dict_l = {}
dict_w = {}
if bool(isdirected) == True:
G = nx.from_numpy_matrix(np.matrix(B[j]), create_using=nx.DiGraph)
else:
G = nx.from_numpy_matrix(B[j])
for z in tqdm(range(len(indexes))):
length, path = nx.single_source_dijkstra(G,
indexes[z],
target=None,
cutoff=None,
weight='weight')
level = {k: len(v) - 1 for k, v in path.items()}
if len(dict_l) == 0:
dict_l = level
dict_w = length
else:
for k, v in level.items():
if k in dict_l:
if dict_l[k] > v:
dict_l[k] = v
dict_w[k] = length[k]
if dict_l[k] == v:
if dict_w[k] > length[k]:
dict_w[k] = length[k]
else:
dict_l[k] = v
dict_w[k] = length[k]
# dict_l = {k: min(v, dict_l[k]) for k, v in level.items() if k in dict_l}
rank_result[j] = dict_l
weight_result[j] = dict_w
return rank_result, weight_result
def prepare(self, model):
self.mesh = nx.DiGraph()
self.mesh.add_nodes_from([
e for e in model.nodes(data=True)
if e[1]["node_type"] == nm.NODE_TYPE_WORKER
])
self.mesh.add_nodes_from(
nx.subgraph(model,
[self.node_src, self.node_dst]).nodes(data=True))
self.mesh_costs = {}
self.mesh_paths = {}
for node in self.mesh:
self.mesh_costs[node], self.mesh_paths[
node] = nx.single_source_dijkstra(G=model,
source=node,
weight="latency")
for node_a in self.mesh:
for node_b in self.mesh:
self.mesh.add_edge(node_a,
node_b,
latency=self.mesh_costs[node_a][node_b])
def shortest_path(start_node, G, out_folder):
'''
:param start_node: Input node
:param G: input graph
:return: short path of the start node in graph
'''
length, path = nx.single_source_dijkstra(G,
start_node,
cutoff=5,
weight='weight')
dest_index = list(length.keys())
shortest_distance = list(length.values())
d = {
'destination_index': dest_index,
'shortest_path_distance': shortest_distance
}
df_out = pd.DataFrame(data=d)
df_out.to_csv(out_folder + 'path_dist_index_' + str(start_node) + '.csv',
sep=',',
index=False)
def get_effdist_tree(G,
source,
cutoff=None,
create_using=nx.DiGraph,
weight='weight',
effdist_key='effdist'):
T = create_using()
T.graph['root'] = source
T.add_node(source)
length, path = nx.single_source_dijkstra(G,
source,
cutoff=cutoff,
weight=weight)
for n in list(path.keys()):
T.add_path(path[n])
T.node[n][effdist_key] = length[n]
return T
def test_dijkstra(self):
(D, P) = nx.single_source_dijkstra(self.XG, 's')
validate_path(self.XG, 's', 'v', 9, P['v'])
assert D['v'] == 9
validate_path(self.XG, 's', 'v', 9,
nx.single_source_dijkstra_path(self.XG, 's')['v'])
assert dict(nx.single_source_dijkstra_path_length(self.XG,
's'))['v'] == 9
validate_path(self.XG, 's', 'v', 9,
nx.single_source_dijkstra(self.XG, 's')[1]['v'])
validate_path(self.MXG, 's', 'v', 9,
nx.single_source_dijkstra_path(self.MXG, 's')['v'])
GG = self.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
(D, P) = nx.single_source_dijkstra(GG, 's')
validate_path(GG, 's', 'v', 8, P['v'])
assert D['v'] == 8 # uses lower weight of 2 on u<->x edge
validate_path(GG, 's', 'v', 8, nx.dijkstra_path(GG, 's', 'v'))
assert nx.dijkstra_path_length(GG, 's', 'v') == 8
validate_path(self.XG2, 1, 3, 4, nx.dijkstra_path(self.XG2, 1, 3))
validate_path(self.XG3, 0, 3, 15, nx.dijkstra_path(self.XG3, 0, 3))
assert nx.dijkstra_path_length(self.XG3, 0, 3) == 15
validate_path(self.XG4, 0, 2, 4, nx.dijkstra_path(self.XG4, 0, 2))
assert nx.dijkstra_path_length(self.XG4, 0, 2) == 4
validate_path(self.MXG4, 0, 2, 4, nx.dijkstra_path(self.MXG4, 0, 2))
validate_path(self.G, 's', 'v', 2,
nx.single_source_dijkstra(self.G, 's', 'v')[1])
validate_path(self.G, 's', 'v', 2,
nx.single_source_dijkstra(self.G, 's')[1]['v'])
validate_path(self.G, 's', 'v', 2, nx.dijkstra_path(self.G, 's', 'v'))
assert nx.dijkstra_path_length(self.G, 's', 'v') == 2
# NetworkXError: node s not reachable from moon
pytest.raises(nx.NetworkXNoPath, nx.dijkstra_path, self.G, 's', 'moon')
pytest.raises(nx.NetworkXNoPath, nx.dijkstra_path_length, self.G, 's',
'moon')
validate_path(self.cycle, 0, 3, 3, nx.dijkstra_path(self.cycle, 0, 3))
validate_path(self.cycle, 0, 4, 3, nx.dijkstra_path(self.cycle, 0, 4))
assert nx.single_source_dijkstra(self.cycle, 0, 0) == (0, [0])
def get_shortest_path_length_with_limit(self, vertex1, vertex2, cutoff=None):
"""
Parameters
----------
vertex1:
vertex2:
cutoff:
Returns
-------
NxGraph: Graph object
Examples
--------
>>>
"""
try:
return nx.single_source_dijkstra(self._graph, source=vertex1, target=vertex2, cutoff=cutoff,
weight=self._weight_field)
except nx.NetworkXNoPath:
return 0
def getBestMove(self):
(bestScores, bestPathes) = nx.single_source_dijkstra(self,
self.head,
cutoff=10)
maxLen = 0
for bestPath in bestPathes.values():
if maxLen < len(bestPath): maxLen = len(bestPath)
print_err("max path len = " + str(maxLen))
bestscoreitem = sorted([(key, value)
for (key, value) in bestScores.items()],
key=lambda x: x[1] / len(bestPathes[x[0]]))
#bestscoreitem = sorted([(key, value) for (key, value) in bestscoreitem], key=lambda x:x[1])
bestTarget = bestscoreitem[0]
bestMove = None
bestScore = self.head.score
if len(bestPathes[bestTarget[0]]) > 1:
bestfirstTarget = bestPathes[bestTarget[0]][1]
bestScore = bestfirstTarget.score
bestMove = self[self.head][bestfirstTarget]['move']
return (bestMove, bestScore)
def create_paths_file(G, fn_paths, fn_times):
counter = 0
# pbar = ProgressBar(
# widgets=["Creating Paths File: ", Bar(), Percentage(), "|", ETA()],
# maxval=pow(len(G.nodes()), 2)).start()
with io.open(fn_paths, "wb") as fout:
with io.open(fn_times, "wb") as ftimes:
writer = csv.writer(fout, delimiter=" ")
times_writer = csv.writer(ftimes, delimiter=" ")
times_writer.writerow([len(G.nodes())])
for i in G.nodes():
tts, paths = nx.single_source_dijkstra(G, i)
rows = list()
time_row = [-1] * len(G.nodes())
for j in paths.keys():
time_row[int(j)] = tts[int(j)]
rows.append([int(i), int(j)] + map(int, paths[int(j)]))
# pbar.update(counter + 1)
counter += 1
writer.writerows(rows)
times_writer.writerow(time_row)
def list_flights(self, flights_map, price_limit, flights_limit, departure_point):
print("Flights from {0}:".format(flights_map.points_names[departure_point].encode(self.output_encoding)))
costs, paths = nx.single_source_dijkstra(flights_map.map, departure_point)
self._find_cycle_from_dep_point(flights_map.map, departure_point, costs, paths, price_limit)
price_w = len(str(max(costs)))
for point in sorted(costs, key=lambda y: costs[y]):
print("{0:{1}} {2} - {3}".format(costs[point], price_w, self.webpage_currency, flights_map.points_names[point].encode(self.output_encoding))),
p = paths[point][1:-1]
if len(p)>0 :
print('\t( via'),
for c in p:
print(flights_map.points_names[c].encode(self.output_encoding)),
print(")"),
print("")
def validate(self, g):
"""
:param g:
:return:
"""
self.property_map = {
k: v
for k, v in self.property_map.items() if v != self.infinity
}
p = nx.single_source_dijkstra(g, self.source_vertex)
if p[0] == self.property_map:
return True
else:
print("Error: The algorithm is faulty!!!")
for k, v in p[0].items():
if p[0][k] != self.property_map[k]:
print("vertex ", k, " value in ground truth is ", p[0][k],
" and value in delta stepping is ",
self.property_map[k])
return False
def test_dijkstra(n, p=0.2, min_w=0, max_w=10, directed=True):
"""Tests the dijkstra implementation on a random weighted graph with
n vertices.
:param n: order of the graph to test on
:param p: the edge probability in G
:param min_w: minimum edge weight in G
:param max_w: maximum edge weight in G
:param directed: whether or not the graph is directed.
:return: True iff the distance output of dijkstra is the same
as that generated by networkx's built in dijkstra function.
"""
G, w, s = random_dijkstra_instance(n, p, min_w, max_w, directed)
expected_ds, expected_path = nx.single_source_dijkstra(G, s)
print(expected_path)
print(expected_ds)
actual_ds, parents = dijkstra(G, w, s)
for v in G.nodes:
assert actual_ds[v] == expected_ds[v]
return True
def get_point_path_machine(self, point, cutoff=None):
point_path_machine = None
if self._add_visibility_edges(point):
path_legths, paths = nx.single_source_dijkstra(
self.visibility_graph, point, None, cutoff)
def point_path_machine(point1):
if self._is_visible(point, point1):
return [point, point1]
visible_points = [
point2
for point2 in (self._get_visible_points(point1) or [])
if point2 in path_legths
]
if visible_points:
return paths[min(visible_points,
key=lambda point2: point1.distance(point2)
+ path_legths[point2])] + [point1]
self.visibility_graph.remove_node(point)
return point_path_machine
def all_relationship_weights(self, source_id):
connections = {}
lengths, paths = nx.single_source_dijkstra(self.GlobalGraph, source_id)
del paths[source_id]
for target in paths:
if len(paths[target]) < 3:
connections[target] = [lengths[target]]
else:
connections[target] = []
for index, node in enumerate(paths[target]):
if index + 1 < len(paths[target]):
next_node_in_path = paths[target][index + 1]
weight = self.GlobalGraph[node][next_node_in_path][
node]['weight']
connections[target].append(weight)
return connections
def find_midpoint(G, start_node, dist): #Inputs: G, index of start_node, distance of walk #Returns: index of midpoint_node, list of indices of nodes along path to midpoint #Step 1: Identify contender midpoints within factor1*dist factor1 = 0.5 contender_midpoints = nx.single_source_dijkstra(G, start_node, weight = 'length', cutoff = factor1*dist) #Returns 2 dicts: first of end nodes:distance and second of end node:node path #Dict [node index]:distance from start node contender_paths = contender_midpoints[0] #All contender nodes that are within factor2 of target length factor2 = 0.9 farthest_node_considered = max(contender_paths.values()) midpoint_nodes = [k for (k, v) in contender_paths.items() if v >= factor2*farthest_node_considered] #Step 2: Find contender midpoint node in a tree-rich area midpoints = beautreeful_node(G, midpoint_nodes) return midpoints
def create_paths_file(G, fn_paths, fn_times):
counter = 0
# pbar = ProgressBar(
# widgets=["Creating Paths File: ", Bar(), Percentage(), "|", ETA()],
# maxval=pow(len(G.nodes()), 2)).start()
with io.open(fn_paths, "wb") as fout:
with io.open(fn_times, "wb") as ftimes:
writer = csv.writer(fout, delimiter=" ")
times_writer = csv.writer(ftimes, delimiter=" ")
times_writer.writerow([len(G.nodes())])
for i in G.nodes():
tts, paths = nx.single_source_dijkstra(G, i)
rows = list()
time_row = [-1] * len(G.nodes())
for j in paths.keys():
time_row[int(j)] = tts[int(j)]
rows.append([int(i), int(j)] + map(int, paths[int(j)]))
# pbar.update(counter + 1)
counter += 1
writer.writerows(rows)
times_writer.writerow(time_row)
def pointsToBackbone(points, uvframe):
# Generate a complete graph over these points,
# weighted by Euclidean distances
g = nx.Graph()
# Graph vertices are point numbers, except points which are set to None
nodes = filter(lambda x: points[x] is not None, range(len(points)))
g.add_nodes_from(nodes)
for i in range(len(points)):
if points[i] is None:
continue
for j in range(i+1, len(points)):
# TODO: scipy's cpair? but we will need to construct
# a graph anyway
if points[j] is None:
continue
# Eschew lines crossing dark areas
lineSum = lineSumValue(points[i], points[j], uvframe)
# print i, j, points[i], points[j], lineSum, math.sqrt(pointSquaredDistance(points[i], points[j]) * (LINE_VALUE_THRESHOLD ** 2))
if lineSum ** 2 < pointSquaredDistance(points[i], points[j]) * (LINE_VALUE_THRESHOLD ** 2):
#print '-->'
continue
g.add_edge(i, j, {'weight': math.pow(points[i][0]-points[j][0], 2) + math.pow(points[i][1]-points[j][1], 2)})
# Reduce the complete graph to MST
gmst = nx.minimum_spanning_tree(g)
# Show the MST
# f = plt.figure()
# imgplot = plt.imshow(uvframe, cmap=plt.cm.gray)
# display_graph(f.add_subplot(111), gmst, points)
# plt.show()
# Diameter of the minimum spanning tree will generate
# a "likely pose walk" through the graph
tip0 = max(nx.single_source_dijkstra_path_length(gmst, nodes[0]).items(), key=lambda x:x[1])[0] # funky argmax
(tip1_lengths, tip1_paths) = nx.single_source_dijkstra(gmst, tip0)
tip1 = max(tip1_lengths.items(), key=lambda x:x[1])[0]
backbone = tip1_paths[tip1]
return backbone
def converter(self, a, b):
"""returns a function that converts elements of type `a` to element with type `b`.
"""
def c(n1, n2):
data = self.get_edge_data(n1, n2)
return data['fn']
import inspect, itertools
from_type = _ptype(a)
to_type = _ptype(b)
mro = inspect.getmro(from_type) # inherited from
resolve_order = [from_type] + list(mro)
for start in resolve_order:
try:
(length, paths) = networkx.single_source_dijkstra(self, start, to_type, 'precedence')
if to_type not in length:
continue # not found a valid path, try super class
path = paths[to_type]
edges = zip(path[:-1], path[1:])
converters = list(itertools.starmap(c, edges))
def fn(val):
return reduce(lambda val, convert: convert(val),
converters, val)
return fn
except KeyError as e:
# : Unknown node
pass
raise MSMLMissingConversionException("Could not find a conversion for %s -> %s" % (from_type, to_type))
def find_spt(digraph, root):
"""
Finding the shortest-path-tree
See algorithm here:
https://web.archive.org/web/20200124171216/http://www.me.utexas.edu/~jensen/exercises/mst_spt/spt_demo/spt1.html
(Original link is dead: http://www.me.utexas.edu/~jensen/exercises/mst_spt/spt_demo/spt1.html)
:param digraph: graph
:param root: root node
:return: spt
"""
spt = nx.Graph()
s1 = {root}
s2 = set(G.nodes())
s2.remove(root)
while s2:
nodes_from_s2_to_s1 = set()
direct_reachable_nodes = set()
for _s in s1:
for _i in digraph.adj[_s]:
direct_reachable_nodes.add(_i)
direct_reachable_nodes = direct_reachable_nodes - s1
shortest_paths = [
nx.single_source_dijkstra(digraph,
source=root,
target=t,
weight="weight")
for t in direct_reachable_nodes
]
shortest_path = min(shortest_paths)
edge_to_add = (shortest_path[1][-2], shortest_path[1][-1],
shortest_path[0])
spt.add_weighted_edges_from([edge_to_add])
nodes_from_s2_to_s1.add(shortest_path[1][-1])
s1.update(nodes_from_s2_to_s1)
s2.difference_update(nodes_from_s2_to_s1)
return spt
def get_shopabas(G,
seed,
data_shape,
max_d=10,
init_dist_val=None,
suppxls=None,
using_superpixels=False):
if init_dist_val is None:
init_dist_val = 2 * max_d
n_pts = np.prod(data_shape)
# urceni vzdalenosti od noveho seedu
dists, _ = nx.single_source_dijkstra(G, seed, cutoff=max_d)
# z rostouci vzdalenosti udelam klesajici (penalizacni) energii
energy_s = np.zeros(n_pts)
dists_items_array = np.array(dists.items())
dist_layer = init_dist_val * np.ones(data_shape)
if using_superpixels:
idxs = dists_items_array[:, 0].astype(np.uint32)
dists = dists_items_array[:, 1]
energy_s_im = np.zeros(data_shape)
for i in range(len(idxs)):
suppxl = suppxls == idxs[i]
energy_s_im[np.nonzero(suppxl)] = max_d - dists[i]
energy_s = energy_s_im.flatten()
dist_layer[np.nonzero(suppxl)] = dists[i]
else:
energy_s[dists_items_array[:, 0].astype(
np.uint32)] = max_d - dists_items_array[:, 1]
# vsechny body inicializuji na maximalni vzdalenost max_d
dist_layer = init_dist_val * np.ones(n_pts)
dist_layer[dists_items_array[:, 0].astype(
np.uint32)] = dists_items_array[:, 1]
dist_layer = dist_layer.reshape(data_shape)
return dist_layer, energy_s
def test_dijkstra(self):
(D,P)= nx.single_source_dijkstra(self.XG,'s')
assert_equal(P['v'], ['s', 'x', 'u', 'v'])
assert_equal(D['v'],9)
assert_equal(nx.single_source_dijkstra_path(self.XG,'s')['v'],
['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_dijkstra_path_length(self.XG,'s')['v'],9)
assert_equal(nx.single_source_dijkstra(self.XG,'s')[1]['v'],
['s', 'x', 'u', 'v'])
assert_equal(nx.single_source_dijkstra_path(self.MXG,'s')['v'],
['s', 'x', 'u', 'v'])
GG=self.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
(D,P)= nx.single_source_dijkstra(GG,'s')
assert_equal(P['v'] , ['s', 'x', 'u', 'v'])
assert_equal(D['v'],8) # uses lower weight of 2 on u<->x edge
assert_equal(nx.dijkstra_path(GG,'s','v'), ['s', 'x', 'u', 'v'])
assert_equal(nx.dijkstra_path_length(GG,'s','v'),8)
assert_equal(nx.dijkstra_path(self.XG2,1,3), [1, 4, 5, 6, 3])
assert_equal(nx.dijkstra_path(self.XG3,0,3), [0, 1, 2, 3])
assert_equal(nx.dijkstra_path_length(self.XG3,0,3),15)
assert_equal(nx.dijkstra_path(self.XG4,0,2), [0, 1, 2])
assert_equal(nx.dijkstra_path_length(self.XG4,0,2), 4)
assert_equal(nx.dijkstra_path(self.MXG4,0,2), [0, 1, 2])
assert_equal(nx.single_source_dijkstra(self.G,'s','v')[1]['v'],
['s', 'u', 'v'])
assert_equal(nx.single_source_dijkstra(self.G,'s')[1]['v'],
['s', 'u', 'v'])
assert_equal(nx.dijkstra_path(self.G,'s','v'), ['s', 'u', 'v'])
assert_equal(nx.dijkstra_path_length(self.G,'s','v'), 2)
# NetworkXError: node s not reachable from moon
assert_raises(nx.NetworkXNoPath,nx.dijkstra_path,self.G,'s','moon')
assert_raises(nx.NetworkXNoPath,nx.dijkstra_path_length,self.G,'s','moon')
assert_equal(nx.dijkstra_path(self.cycle,0,3),[0, 1, 2, 3])
assert_equal(nx.dijkstra_path(self.cycle,0,4), [0, 6, 5, 4])
assert_equal(nx.single_source_dijkstra(self.cycle,0,0),({0:0}, {0:[0]}) )
def test_correctness(self):
"""
This test check the correctness of shortest path and connected_component
by compar it to the results from networkx on the same graph.
:return:None
"""
ga = GraphAlgo.GraphAlgo()
filename = '../data/G_20000_160000_1.json'
ga.load_from_json(filename)
ganx = self.graph_nx(ga.get_graph())
l = ga.shortest_path(0, 2)
l2 = nx.single_source_dijkstra(ganx, 0, 2)
self.assertEqual(l, l2)
l = ga.connected_components()
l2 = list(nx.strongly_connected_components(ganx))
for i in range(len(l)):
l[i].sort()
self.assertTrue(set(l[i]) in l2)
def _find_cycle_from_dep_point(map, point, costs, paths, price_limit):
costs[point] = float("inf")
if map.edge[point].has_key(point) and map.edge[point][point]["weight"] <= price_limit:
costs[point] = map.edge[point][point]["weight"]
map.add_node("point_copy")
for p in map.edge[point].copy():
map.add_edge(p, "point_copy", weight=map.edge[point][p]["weight"])
copy_cost, copy_path = nx.single_source_dijkstra(map, point, "point_copy")
if copy_cost["point_copy"] < costs[point] and copy_cost["point_copy"] <= price_limit:
costs[point] = copy_cost["point_copy"]
paths[point] = copy_path["point_copy"]
map.remove_node("point_copy")
if costs[point] == float("inf"):
costs.pop(point, None)
def get_lineage_distances_across_time(early_tree, late_tree):
"""
Returns the matrix of lineage distances between leaves of early_tree and leaves in
late_tree. Assumes that early_tree is a truncated version of late_tree
"""
num_cells_early = len(get_leaves(early_tree)) - 1
num_cells_late = len(get_leaves(late_tree)) - 1
d = np.zeros([num_cells_early, num_cells_late])
cells_early = get_leaves(early_tree, include_root=False)
cells_late = get_leaves(late_tree, include_root=False)
# get length of path up to parent of early_cell and back to early_cell
for late_cell in cells_late:
distance_dictionary, tmp = nx.single_source_dijkstra(
late_tree.to_undirected(), late_cell, weight='time')
for early_cell in cells_early:
d[early_cell,
late_cell] = (distance_dictionary[next(
early_tree.predecessors(early_cell))] +
early_tree.nodes[early_cell]['time_to_parent'])
# correct distances to descendants
for early_cell in cells_early:
parent = next(early_tree.predecessors(early_cell))
late_cell = None
for child in late_tree.successors(parent):
if late_tree.nodes[child]['cell'].seed == early_tree.nodes[
early_cell]['cell'].seed:
late_cell = child
break
if late_cell is not None:
descendants = get_leaf_descendants(late_tree, late_cell)
d[early_cell, descendants] = (
d[early_cell, descendants] -
2 * early_tree.nodes[early_cell]['time_to_parent'])
return d
def get_shortest_path(
graph: nx.DiGraph, departure_airport: str, destination_airport: str
) -> Union[Tuple[int, list], Tuple[None, None]]:
"""
Get the shortest path between nodes
Handles missing nodes, and no path available
:param graph: Graph holding the airport connection information
:param departure_airport: The source node
:param destination_airport: The destination node
:return: total lenght of the path, the path taken
"""
try:
length, path = nx.single_source_dijkstra(graph,
departure_airport,
destination_airport,
weight="Time")
except nx.exception.NetworkXNoPath:
length, path = None, None
except nx.NodeNotFound:
length, path = None, None
return length, path
def findPlayerDistances(G, player_name, pathQ=False):
"""Find players distances to others in the graph.
If pathQ = True returns a dictionary of the shortest paths,
else returns distances."""
import networkx as nx
pos = findPlayer(players_list,player_name)
go = False
if len(pos)>1:
print 'Found players ', [players_list[i].name for i in pos]
print 'Please use more specific name.'
elif len(pos)==1:
print 'Found player', players_list[pos[0]].name
go = True
else:
print 'No players found.'
if go:
res = nx.single_source_dijkstra(G, pos[0])
if pathQ:
return res[1]
else:
return res[0]
