def test_pathweight():
valid_path = [1, 2, 3]
invalid_path = [1, 3, 2]
graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
edges = [
(1, 2, dict(cost=5, dist=6)),
(2, 3, dict(cost=3, dist=4)),
(1, 2, dict(cost=1, dist=2)),
]
for graph in graphs:
graph.add_edges_from(edges)
assert nx.path_weight(graph, valid_path, "cost") == 4
assert nx.path_weight(graph, valid_path, "dist") == 6
pytest.raises(nx.NetworkXNoPath, nx.path_weight, graph, invalid_path, "cost")
def approx_steiner(graph, terms):
res = []
Gt = nx.complete_graph(terms)
#calcul de tout les plus court chemins
path = dict(nx.all_pairs_shortest_path(graph))
#pour chaque combinaison de 2 noeuds
for (i, j) in it.combinations(terms, 2):
#on met le poids au plus court chemin dans Gt
Gt.add_edge(i,
j,
weight=nx.path_weight(graph, path[i][j], weight="weight"))
#arbre couvrant minimum de Gt
A = list(nx.minimum_spanning_tree(Gt).edges(data=True))
for i in range(len(A)):
pcc = path[A[i][0]][A[i][1]]
for j in range(len(pcc) - 1):
pair = (pcc[j], pcc[j + 1])
res.append(pair)
print_graph(Gt, terms)
return res
def sum_costs(G, path, impedance):
"""
This function calculates the sum of the costs
of a path created according to the geographic
scenario graph.
:param G: NetworkX graph.
Geographic scenario
:param path: list
The list must contains the id
of nodes of the path.
:param weight: String or function
:return: float
The sum of all cost (weight)
edges of the path.
"""
sum_costs = nx.path_weight(G, path,
impedance) # Graph._weight(G, impedance)
#sum_costs = 0
#for i in range(len(path)-1):
# e = G.adj[path[i]].get(path[i + 1])
# weight_edge = Graph.get_edge_weight(G, path[i], path[i + 1], e, impedance)
# sum_costs += weight_edge
return sum_costs
def similar_length(
M, G, R, S, T, cutoff
): #cutoff=percentage of shortest path longer ie 110% would be cutoff=1.10
tol = 1e-5
(paths, lengths) = return_paths(M, G, R, S, T)
G_adj = nx.Graph()
norm = np.sqrt(sum(M.t[i].value * M.t[i].value for i in M.V))
for (i, j) in G.edges:
l = G[i][j]['length']
r = G[i][j]['interdicted_length']
if M.x[(i, j)].value >= 0.9:
length = l + r
if norm > tol:
adjustment = (-1 / norm) * (sum(R[(i, j, k - 1)] * M.t[k].value
for k in M.V))
length = length + adjustment
else:
length = l
if G_adj.has_edge(j, i):
#Check which length to use
if G_adj[j][i][
'adjusted_length'] <= length: #Shorter Lengths indicate that the edge has been interdicted so we shoudl use that value for both directions
G_adj[i][j]['adjusted_length'] = length
else:
G_adj.add_edge(i, j, adjusted_length=length)
similar_paths = []
all_paths = list(
islice(nx.shortest_simple_paths(G_adj, S, T, weight='adjusted_length'),
30))
for path in all_paths:
if nx.path_weight(G_adj, path,
weight='adjusted_length') <= cutoff * lengths:
similar_paths.append(path)
else:
break
no_of_similar_paths = len(similar_paths)
return (similar_paths, no_of_similar_paths)
def get_optimal_path(self,
start: Tuple,
goal: Tuple,
distance_tolerance=.05) -> List[Tuple]:
"""
Provides the optimal path from start to goal. All inputs should be in the global coordinate frame. Output
waypoints are in the global coordinate frame.
:param start: tuple with x,y coordinates of starting location (in mm).
:param goal: tuple with x,y coordinate of goal location (in mm).
:param distance_tolerance: how close to the goal the path should be to.
:return: List of waypoints representing the path.
"""
if self.display:
print('Initializing Display')
self.__init_display(start, goal)
self.__build_tree(start)
graph = self.__build_graph(self.vertices, self.edges)
potential_goals = []
for vertex in self.vertices: # find all vertices within 5m of goal
if self.__euclidean_dist(vertex, goal) < distance_tolerance:
potential_goals.append(vertex)
path_queue = []
for potential_goal in potential_goals: # find shortest path among potential goals
path = networkx.shortest_path(graph,
start,
potential_goal,
weight='weight')
cost = networkx.path_weight(graph, path, weight='weight')
heapq.heappush(path_queue, (cost, path))
if len(path_queue) == 0:
return []
best_path = heapq.heappop(path_queue)[1]
best_path = self.__add_heading_to_waypoints(best_path, start[2],
goal[2])
if self.display:
self.__draw_optimal_path(best_path)
return best_path
def parse_grid(grid, p2=False):
R = len(grid)
C = len(grid[0])
G = nx.DiGraph()
# Add the edges
for r in range(R):
for c in range(C):
G.add_node((r, c), pos=[r, c])
# Every point has an edge to another point up and down
for dr, dc in [[1, 0], [0, 1], [-1, 0], [0, -1]]:
rr = r + dr
cc = c + dc
if not (dr == 0
and dc == 0) and (0 <= rr < R) and (0 <= cc < C):
weight = grid[rr][cc]
G.add_edge((r, c), (rr, cc), weight=weight)
path = nx.dijkstra_path(G, (0, 0), (R - 1, C - 1), weight="weight")
return nx.path_weight(G, path, weight="weight")
(47, 48, 20)]
G = nx.DiGraph()
for fr, to, cp in e:
G.add_edge(fr, to, weight=cp)
plt.subplot(121)
nx.draw(G, with_labels=True)
plt.show()
##Минимальный путь с помошью ф-ции библиотеки networkx.algorithms.shortest_paths.generic.shortest_path
p = nx.shortest_path(G,
source=1,
target=48,
weight="weight",
method="dijkstra")
weight = nx.path_weight(G, p, "weight")
print("Путь ", end="")
for count, value in enumerate(p):
if count < len(p) - 1:
print(value, end=" -> ")
else:
print(value)
print("Вес пути", weight)
##инициализация графа
e = [(1, 2, 19), (2, 3, 15), (3, 4, 23), (4, 5, 22), (5, 6, 16), (6, 7, 16),
(7, 8, 23), (1, 9, 23), (2, 10, 17), (3, 11, 23), (4, 12, 15),
(5, 13, 15), (6, 14, 24), (7, 15, 15), (8, 16, 22), (9, 10, 15),
(10, 11, 16), (11, 12, 15), (12, 13, 21), (13, 14, 20), (14, 15, 20),
(15, 16, 18), (9, 17, 23), (10, 18, 19), (11, 19, 19), (12, 20, 24),
def calculate_stacking_velocity(semblance,
times,
velocities,
start_velocity_range,
end_velocity_range,
max_acceleration=None,
n_times=25,
n_velocities=25):
"""Calculate stacking velocity by given semblance.
Stacking velocity is the value of the seismic velocity obtained from the best fit of the traveltime curve by a
hyperbola for each timestamp. It is used to correct the arrival times of reflection events in the traces for their
varying offsets prior to stacking.
If calculated by semblance, stacking velocity must meet the following conditions:
1. It should be monotonically increasing
2. Its gradient should be bounded above to avoid gather stretching after NMO correction
3. It should pass through local energy maxima on the semblance
In order for these conditions to be satisfied, the following algorithm is proposed:
1. Stacking velocity is being found inside a trapezoid whose vertices at first and last time are defined by
`start_velocity_range` and `end_velocity_range` respectively.
2. An auxiliary directed graph is constructed so that:
1. `n_times` evenly spaced points are generated to cover the whole semblance time range. For each of these
points `n_velocities` evenly spaced points are generated to cover the whole range of velocities inside the
trapezoid from its left to right border. All these points form a set of vertices of the graph.
2. An edge from a vertex A to a vertex B exists only if:
1. Vertex B is located at the very next timestamp after vertex A,
2. Velocity at vertex B is no less than at A,
3. Velocity at vertex B does not exceed that of A by a value determined by `max_acceleration` provided.
3. Edge weight is defined as sum of semblance values along its path.
3. A path with maximal semblance sum along it between any of starting and ending nodes is found using Dijkstra
algorithm and is considered to be the required stacking velocity.
Parameters
----------
semblance : 2d np.ndarray
An array with calculated vertical velocity semblance values.
times : 1d np.ndarray
Recording time for each seismic trace value for which semblance was calculated. Measured in milliseconds.
velocities : 1d np.ndarray
Range of velocity values for which semblance was calculated. Measured in meters/seconds.
start_velocity_range : tuple with 2 elements
Valid range for stacking velocity for the first timestamp. Both velocities are measured in meters/seconds.
end_velocity_range : tuple with 2 elements
Valid range for stacking velocity for the last timestamp. Both velocities are measured in meters/seconds.
max_acceleration : None or float, defaults to None
Maximal acceleration allowed for the stacking velocity function. If `None`, equals to
2 * (mean(end_velocity_range) - mean(start_velocity_range)) / total_time. Measured in meters/seconds^2.
n_times : int, defaults to 25
The number of evenly spaced points to split time range into to generate graph vertices.
n_velocities : int, defaults to 25
The number of evenly spaced points to split velocity range into for each time to generate graph vertices.
Returns
-------
stacking_times : 1d np.ndarray
Times for which stacking velocities were picked. Measured in milliseconds.
stacking_velocities : 1d np.ndarray
Picked stacking velocities. Matches the length of `stacking_times`. Measured in meters/seconds.
metric : float
Sum of semblance values along the stacking velocity path.
Raises
------
ValueError
If no path was found for given parameters.
"""
times = np.asarray(times, dtype=np.float32)
velocities = np.asarray(velocities, dtype=np.float32)
start_velocity_range = np.array(start_velocity_range, dtype=np.float32)
end_velocity_range = np.array(end_velocity_range, dtype=np.float32)
# Calculate maximal velocity growth (in samples) between two adjacent timestamps,
# for which graph nodes are created
total_time = (times[-1] - times[0]) / 1000 # from ms to s
if max_acceleration is None:
max_acceleration = 2 * (np.mean(end_velocity_range) -
np.mean(start_velocity_range)) / total_time
max_vel_step = np.ceil((max_acceleration * total_time / n_times) /
np.mean(velocities[1:] - velocities[:-1]))
max_vel_step = np.int32(max_vel_step)
# Create a graph and find paths with maximal semblance sum along them to all reachable nodes
edges, start_node, end_nodes = create_edges(semblance, times, velocities,
start_velocity_range,
end_velocity_range,
max_vel_step, n_times,
n_velocities)
graph = nx.DiGraph()
graph.add_weighted_edges_from(zip(*edges))
paths = nx.shortest_path(graph, source=start_node, weight="weight") # pylint: disable=unexpected-keyword-arg
# Select only paths to the nodes at the last timestamp and choose the optimal one
path_weights = [(paths[end_node],
nx.path_weight(graph, paths[end_node], weight="weight"))
for end_node in end_nodes if end_node in paths]
if not path_weights:
raise ValueError("No path was found for given parameters")
path, metric = min(path_weights, key=lambda x: x[1])
# Remove the first auxiliary node from the path and calculate mean semblance value along it
path = np.array(path)[1:]
metric = 1 - metric / len(times)
return times[path[:, 0]], velocities[path[:, 1]], metric
def finished_path_part_two(self, path):
length = nx.path_weight(self.g, path, "weight")
if length > self.longest_path_length:
self.longest_path = path
self.longest_path_length = length
def finished_path(self, path):
length = nx.path_weight(self.g, path, "weight")
if length < self.shortest_path_length:
self.shortest_path = path
self.shortest_path_length = length
nx.algorithms.dijkstra_path(g, 1, 21)
list(itertools.combinations(g.nodes(),2))
nn = list(g.nodes()) # essentially a tuple
nn
# check out the iterable unpacking:
for pair in itertools.combinations(nn[:8], 2):
print(nx.algorithms.shortest_path(g, *pair),
nx.algorithms.dijkstra_path(g, *pair))
ee = list(g.edges())
## Add edge weights by appending a tuple of length 1 to each edge tuple
weighted_edges = [x + (random.choice(range(10)), ) for x in ee]
weighted_edges
g.clear()
g.add_weighted_edges_from(weighted_edges)
# Re-run the above, now with weight to take into account (paths may differ)
for pair in itertools.combinations(nn[:8], 2):
print(pair,
nx.algorithms.shortest_path(g, *pair),
nx.algorithms.dijkstra_path(g, *pair),
nx.path_weight(g, nx.algorithms.shortest_path(g, *pair), weight="weight"),
nx.algorithms.dijkstra_path_length(g, *pair))
def analyzePlacement(self, path):
happiness = nx.path_weight(self.graph, path, "happiness")
happiness = happiness + self.graph.get_edge_data(path[0], path[-1])["happiness"]
if happiness > self.maxHappiness:
self.maxHappiness = happiness
self.optimumPlacement = path
def pathAnalysis(graph, \
valueFilter, distanceFilter,\
sourceResid, targetResid, \
selectedAtoms, num_paths):
"""
This function calculates paths between a source and target residue.
This function calculates a path between a source (beginning) and a
target (end) residue from the graph build out of your ccMatrix.
Parameters
----------
graph: object
It is a Networkx Graph object.
valueFilter: float
The ccMatrix values lower than the valueFilter will be ignored.
distanceFilter: float
The distance values higher than the distanceFilter will be ignored
and they will not be considered as edges in a network.
This kind of value pruning may work for low conformational change MD
simulations or ENM based calculations. However, if there are large
scale structural changes, it will be necessary to eliminate the edges
based on contacts and their preservation in during the entire simulation.
sourceResid: str
Chain and residue ID of the source residue. For example, A41, B145 etc..
targetResid: str
Chain and residue ID of the target residue. For example, A145, B41 etc..
selectedAtoms: object
This is a prody.parsePDB object of typically CA atoms of a protein.
num_paths: int
Number of shortest paths to write to tcl or pml files. Minimum is 1.
Returns
-------
Nothing
"""
# # Build the graph
# graph = buildDynamicsNetwork(ccMatrix, distanceMatrix, \
# valueFilter, distanceFilter,\
# selectedAtoms)
suboptimalPaths = k_shortest_paths(graph,
source=sourceResid,
target=targetResid,
k=num_paths,
weight='weight')
# #shortestPath = nx.shortest_path(graph, source=residue, target=targetResid, weight='weight', method='dijkstra')
# shortestPathScoreList = []
# for path in suboptimalPaths:
# shortestPathScore = 0.0
# for j in range(len(path)-1):
# # print(path[j], end="\n")
# # print(shortestPath[j+1], end="\n")
# shortestPathScore = shortestPathScore + ccMatrix[path[j]][path[j+1]]
# shortestPathScoreList.append(shortestPathScore)
# spNP = np.array(shortestPath)
# print(spNP)
# print(shortestPathScoreList)
# print("The shortest path score is: ", end='')
# print(np.array(shortestPathScoreList).sum().round(3))
k = 0
for path in suboptimalPaths:
k = k + 1
path_length = nx.path_weight(graph, path, weight="weight")
print("Path " + str(k) + " length: " + str(path_length))
return suboptimalPaths
# Ingest and flatten
numbers = []
last_row = []
with open('big_triangle.txt') as f:
for line in f:
for number in line.split():
numbers.append(int(number))
last_row = line.split()
# Create graph
G = nx.DiGraph()
for i in range(1, len(numbers) + 1):
G.add_node(i)
# Make connections (n -> n + r and n -> n + r + 1)
r = lambda n: math.ceil((math.sqrt(8 * n + 1) - 1) / 2)
for i in range(1, len(numbers) - len(last_row) + 1):
# Don't attempt to connect the last row
G.add_edge(i, i + r(i), weight=numbers[i - 1])
G.add_edge(i, i + r(i) + 1, weight=numbers[i - 1])
# Connect the bottom row to a destination node
G.add_node(-1)
for i in range(len(numbers) - len(last_row) + 1, len(numbers) + 1):
G.add_edge(i, -1, weight=numbers[i - 1])
# Find the longest path and its associated path weight
path = nx.dag_longest_path(G, weight='weight')
path_weight = nx.path_weight(G, path, weight='weight')
print(path)
print(path_weight)
def path_weight(self, path, attribute):
return nx.path_weight(self.graph, path=path, weight=attribute)
def answer(lines):
#find paths trough the maze, starting at 0,0 (dont count in total) and ending at maxx,maxy
#you can not move diagonally
#return the total risk of the path with the lowest total
lines = list(lines)
maxy = len(lines) - 1
maxx = len(lines[-1].strip()) - 1
print()
G = nx.DiGraph()
# input is a map of risk levels
for y, line in enumerate(map(str.strip, lines)):
for x in range(len(line)):
weight = int(line[x])
edges = []
# add all inward edges
if x > 0: edges.append(((x - 1, y), (x, y), weight)) #left ->
if x < maxx: edges.append(((x + 1, y), (x, y), weight)) #right <-
if y > 0: edges.append(((x, y - 1), (x, y), weight)) #top \/
if y < maxy: edges.append(((x, y + 1), (x, y), weight)) #bottom /\
G.add_weighted_edges_from(edges)
def print_graph():
for y in range(maxy + 1):
for x in range(maxx + 1):
n = (x, y)
if n[0] % (maxx + 1) == 0:
print()
try:
print(G[(n[0] - 1, n[1])][n]['weight'], end='') #left
except KeyError:
try:
print(G[(n[0], n[1] - 1)][n]['weight'], end='') #top
except KeyError:
print('x', end='')
print()
def print_path(path):
prevn = path[0]
for y in range(maxy + 1):
for x in range(maxx + 1):
n = (x, y)
if n[0] % (maxx + 1) == 0:
print()
if n in path:
try:
w = int(G[prevn][n]['weight'])
except KeyError:
w = 'x'
print(w, end='')
prevn = n
else:
print('.', end='')
print()
print_graph()
startp = (0, 0)
endp = (maxx, maxy)
sp = nx.shortest_path(G, startp, endp, 'weight')
# return nx.shortest_path_length(G, startp, endp, 'weight')
print_path(sp)
return nx.path_weight(G, sp, 'weight')
