def simple_wgraph():
"""Return a simple weighted graph with edges."""
from weighted_graph import WeightedGraph
wg = WeightedGraph()
for edge in SIMPLE_WGRAPH:
wg.add_edge(edge[0], edge[1], edge[2])
return wg
def test_topological_sort_error(self):
"""test_topological_sort_error: Make sure that 'topological_sort' raises the correct error
"""
node_0 = WeightedNode(1, [2], {(1, 2): 1})
node_1 = WeightedNode(2, [1], {(2, 1): 1})
graph = WeightedGraph([node_0, node_1])
with self.assertRaises(TypeError):
graph.topological_sort()
def test_remove(self):
"""test_remove: Test removing a node
"""
node_1 = WeightedNode(1, [2], {(1, 2): 2})
node_2 = WeightedNode(2, [1], {(2, 1): 2})
graph = WeightedGraph([node_1, node_2])
graph.remove_node(node_1)
self.assertEqual(graph.vertices, set({2}))
self.assertEqual(graph.edges, {2: set({})})
self.assertEqual(graph.weights, {})
def test_longest_path(self):
"""test_longest_path: Test that the longest path is correctly generated using
the '_bellman_ford' function
"""
node_0 = WeightedNode(0, [1, 4], {(0, 1): 1, (0, 4): 11})
node_1 = WeightedNode(1, [2], {(1, 2): 2})
node_2 = WeightedNode(2, [3], {(2, 3): 3})
node_3 = WeightedNode(3, [], {})
node_4 = WeightedNode(4, [5], {(4, 5): 14})
node_5 = WeightedNode(5, [3], {(5, 3): 12})
graph = WeightedGraph([node_0, node_1, node_2, node_3, node_4, node_5])
self.assertEqual(graph.longest_path(0, 3), 'Path: [0, 4, 5, 3]\nDistance traveled: 37')
def test_add_node(self):
"""test_add_node: Test adding a new node
"""
node_1 = WeightedNode(1, [2], {(1, 2): 2})
node_2 = WeightedNode(2, [1], {(2, 1): 2})
node_3 = WeightedNode(3, [1, 2], {(3, 1): 2, (3, 2): 4})
graph = WeightedGraph([node_1, node_2])
graph.add_node(node_3)
self.assertEqual(graph.vertices, set({1, 2, 3}))
self.assertEqual(graph.edges, {1: set({2}), 2: set({1}), 3: set({1, 2})})
self.assertEqual(graph.weights, {(1, 2): 2, (2, 1): 2, (3, 1): 2, (3, 2): 4})
def main():
"""main: Example case for finding longest and shortest path
"""
node_0 = WeightedNode(0, [1, 4], {(0, 1): 1, (0, 4): 11})
node_1 = WeightedNode(1, [2], {(1, 2): 2})
node_2 = WeightedNode(2, [3], {(2, 3): 3})
node_3 = WeightedNode(3, [], {})
node_4 = WeightedNode(4, [5], {(4, 5): 14})
node_5 = WeightedNode(5, [3], {(5, 3): 12})
graph = WeightedGraph([node_0, node_1, node_2, node_3, node_4, node_5])
print('The longest path is {0}'.format(graph.longest_path(0, 3)))
print('The shortest path is {0}'.format(graph.shortest_path(0, 3)))
def make_graph():
g = WeightedGraph()
g.add_edge('a', 'b')
g.add_edge('b', 'c')
g.add_edge('c', 'f')
g.add_edge('g', 'f')
g.add_edge('a', 'd')
g.add_edge('d', 'e')
g.add_edge('e', 'a')
return g
def test_topological_sort(self):
"""test_topological_sort: There is a picture in this folder showing the visual
representation of this graph. Testing generating a topologically sorted list
of graph vertices
"""
node_0 = WeightedNode(5, [11], {(5, 11): 1})
node_1 = WeightedNode(11, [2, 9, 10], {(11, 2): 1, (11, 9): 1, (11, 10): 1})
node_2 = WeightedNode(2, [], {})
node_3 = WeightedNode(7, [8, 11], {(7, 8): 1, (7, 11): 1})
node_4 = WeightedNode(8, [9], {(8, 9): 1})
node_5 = WeightedNode(9, [], {})
node_6 = WeightedNode(3, [8, 10], {(3, 8): 1, (3, 10): 1})
node_7 = WeightedNode(10, [], {})
graph = WeightedGraph([node_0, node_1, node_2, node_3, node_4, node_5, node_6, node_7])
self.assertEqual(graph.topological_sort(), [7, 5, 11, 3, 10, 8, 9, 2])
def test_no_weighted_hamiltonian(self):
"""test_known_no_hamiltonian_weighted: Test a weighted directed graph with no
hamiltonian cycles
"""
node0 = WeightedNode(0, [1, 3], {(0, 1): 4, (0, 3): 5})
node1 = WeightedNode(1, [0, 3, 4, 2], {
(1, 0): 2,
(1, 3): 3,
(1, 4): 6,
(1, 2): 1
})
node2 = WeightedNode(2, [1, 4], {(2, 1): 2, (2, 4): 5})
node3 = WeightedNode(3, [0, 1], {(3, 0): 2, (3, 1): 5})
node4 = WeightedNode(4, [1, 2], {(4, 1): 3, (4, 2): 5})
graph = WeightedGraph([node0, node1, node2, node3, node4])
self.assertEqual(graph.get_hamiltonian_cycles(), [])
def test_prims_lazy_mst():
w_graph = WeightedGraph(4)
w_graph.add_edge(1, 0, -10)
w_graph.add_edge(1, 2, -35)
w_graph.add_edge(0, 2, -15)
w_graph.add_edge(0, 3, -12)
w_graph.add_edge(1, 3, -11)
w_graph.add_edge(2, 3, -30)
prims_lazy = PrimsLazyMst(w_graph)
prims_lazy.get_mst()
def mst(wg: WeightedGraph, start: int = 0) -> Optional[WeightedPath]:
path: WeightedPath = []
visited: Set[V] = set()
pq: PriorityQueue = PriorityQueue()
visited.add(start)
for edge in wg.edges_for_index(start):
pq.push(edge)
while not pq.is_empty and len(visited) < wg.vertex_count:
edge: WeightedEdge = pq.pop()
if edge.v in visited:
continue
visited.add(edge.v)
path.append(edge)
for edge in wg.edges_for_index(edge.v):
pq.push(edge)
return path
def non_ref():
"""Create simple non referential graph."""
from weighted_graph import WeightedGraph
empty_wg = WeightedGraph()
empty_wg.add_edge('A', 'B', 5)
empty_wg.add_edge('A', 'C', 5)
empty_wg.add_edge('B', 'D', 5)
empty_wg.add_edge('B', 'E', 5)
empty_wg.add_edge('C', 'F', 5)
empty_wg.add_edge('C', 'G', 5)
return empty_wg
def make_graph_three():
my_graph = WeightedGraph()
my_graph.add_node('a')
my_graph.add_node('b')
my_graph.add_node('c')
my_graph.add_edge('a', 'c')
my_graph.add_edge('b', 'a')
return my_graph
def test_get_shortest_hamiltonian(self):
"""test_get_shortest_hamiltonian: Test finding the short hamiltonian path
or paths in a directed weighted graph
"""
node0 = WeightedNode(0, [1, 3], {(0, 1): 4, (0, 3): 3})
node1 = WeightedNode(1, [0, 3, 4, 2], {
(1, 0): 3,
(1, 3): 4,
(1, 4): 4,
(1, 2): 3
})
node2 = WeightedNode(2, [1, 4], {(2, 1): 1, (2, 4): 3})
node3 = WeightedNode(3, [0, 1, 4], {(3, 0): 5, (3, 1): 3, (3, 4): 6})
node4 = WeightedNode(4, [1, 2, 3], {(4, 1): 2, (4, 2): 6, (4, 3): 7})
graph = WeightedGraph([node0, node1, node2, node3, node4])
self.assertEqual(graph.get_shortest_hamiltonian_cycle(),
[([0, 3, 4, 2, 1, 0], 19), ([1, 0, 3, 4, 2, 1], 19),
([2, 1, 0, 3, 4, 2], 19), ([3, 4, 2, 1, 0, 3], 19),
([4, 2, 1, 0, 3, 4], 19)])
def test_known_weighted_hamiltonian(self):
"""test_known_weighted_hamiltonian_cycles: Weighted directed graph which is known
to have hamiltonian cycles
"""
node0 = WeightedNode(0, [1, 3], {(0, 1): 4, (0, 3): 3})
node1 = WeightedNode(1, [0, 3, 4, 2], {
(1, 0): 3,
(1, 3): 4,
(1, 4): 4,
(1, 2): 3
})
node2 = WeightedNode(2, [1, 4], {(2, 1): 1, (2, 4): 3})
node3 = WeightedNode(3, [0, 1, 4], {(3, 0): 5, (3, 1): 3, (3, 4): 6})
node4 = WeightedNode(4, [1, 2, 3], {(4, 1): 2, (4, 2): 6, (4, 3): 7})
graph = WeightedGraph([node0, node1, node2, node3, node4])
self.assertEqual(
graph.get_hamiltonian_cycles(),
[[0, 3, 4, 2, 1, 0], [0, 1, 2, 4, 3, 0], [1, 2, 4, 3, 0, 1],
[1, 0, 3, 4, 2, 1], [2, 4, 3, 0, 1, 2], [2, 1, 0, 3, 4, 2],
[3, 4, 2, 1, 0, 3], [3, 0, 1, 2, 4, 3], [4, 3, 0, 1, 2, 4],
[4, 2, 1, 0, 3, 4]])
def cyclic():
"""Create simple cyclic graph."""
from weighted_graph import WeightedGraph
empty_wg = WeightedGraph()
empty_wg.add_edge('A', 'B', 5)
empty_wg.add_edge('B', 'C', 5)
empty_wg.add_edge('C', 'A', 5)
return empty_wg
def get_global_hypothesis(self, tracks, conflicting_tracks):
"""
Generate a global hypothesis by finding the maximum weighted independent
set of a graph with tracks as vertices, and edges between conflicting tracks.
"""
gh_graph = WeightedGraph()
for index, track in enumerate(tracks):
s = track.get_track_score()
gh_graph.add_weighted_vertex(str(index), s)
gh_graph.set_edges(conflicting_tracks)
mwis_ids = gh_graph.mwis()
return mwis_ids
def test_kruskal():
w_graph = WeightedGraph(4)
w_graph.add_edge(1, 0, -10)
w_graph.add_edge(1, 2, -35)
w_graph.add_edge(0, 2, -15)
w_graph.add_edge(0, 3, -12)
w_graph.add_edge(1, 3, -11)
w_graph.add_edge(2, 3, -30)
'''
w_graph.add_edge(4,6,-1)
w_graph.add_edge(3,8,-2)
w_graph.add_edge(8,7,-5)
w_graph.add_edge(6,8,-8)
w_graph.add_edge(7,6,-17)
'''
k = KruskalMst(w_graph)
k.get_mst()
'''
def global_hypothesis(self, track_trees, conflicting_tracks):
"""
Generate a global hypothesis by finding the maximum weighted independent
set of a graph with tracks as vertices, and edges between conflicting tracks.
"""
logging.info("Running MWIS on weighted track trees...\n")
gh_graph = WeightedGraph()
for index, kalman_filter in enumerate(track_trees):
gh_graph.add_weighted_vertex(str(index),
kalman_filter.get_track_score())
gh_graph.set_edges(conflicting_tracks)
mwis_ids = gh_graph.mwis()
logging.info("Completed MWIS.\n")
return mwis_ids
def global_hypothesis(track_trees, t):
MWIS_tracks = []
gh_graph = WeightedGraph()
tracks = [item for sublist in track_trees for item in sublist]
if tracks:
conflicting_tracks = []
for track_index, track in enumerate(tracks):
for conflict_index, conflict_track in enumerate(
tracks[track_index:]):
conflict_index += track_index
if any(x in track.get_past_measurements()
for x in conflict_track.get_past_measurements()):
if track_index != conflict_index:
conflicting_tracks.append(
(track_index, conflict_index))
for index, kalman_filter in enumerate(tracks):
gh_graph.add_weighted_vertex(str(index),
kalman_filter.get_score(t))
gh_graph.set_edges(conflicting_tracks)
mwis_ids = gh_graph.mwis()
for index in list(mwis_ids):
MWIS_tracks.append([tracks[index]])
for track_index, track in enumerate(MWIS_tracks):
track = track[0]
for conflict_index, conflict_track in enumerate(MWIS_tracks):
conflict_track = conflict_track[0]
if abs(track.get_state() - conflict_track.get_state()
) < 10 and conflict_track.is_con() and track.is_con():
if track_index != conflict_index:
if track.get_score(t) > conflict_track.get_score(t):
track.kill()
return MWIS_tracks
def test_shortest_path(self):
"""test_shortest_path: Test that the shortest math is correctly generated using
the '_dijkstra' function
"""
node_0 = WeightedNode(0, [1, 4], {(0, 1): 1, (0, 4): 11})
node_1 = WeightedNode(1, [2], {(1, 2): 2})
node_2 = WeightedNode(2, [3], {(2, 3): 3})
node_3 = WeightedNode(3, [], {})
node_4 = WeightedNode(4, [5], {(4, 5): 14})
node_5 = WeightedNode(5, [3], {(5, 3): 12})
graph = WeightedGraph([node_0, node_1, node_2, node_3, node_4, node_5])
self.assertEqual(graph.shortest_path(0, 3), 'Path: [0, 1, 2, 3]\nDistance traveled: 6')
node_0 = WeightedNode(5, [11, 9], {(5, 11): 4, (5, 9): 1})
node_1 = WeightedNode(11, [2, 9, 10], {(11, 2): 6, (11, 9): 2, (11, 10): 9})
node_2 = WeightedNode(2, [5], {(2, 5): 2})
node_3 = WeightedNode(7, [8, 11], {(7, 8): 2, (7, 11): 5})
node_4 = WeightedNode(8, [9], {(8, 9): 5})
node_5 = WeightedNode(9, [2], {(9, 2): 4})
node_6 = WeightedNode(3, [8, 10], {(3, 8): 2, (3, 10): 7})
node_7 = WeightedNode(10, [9], {(10, 9): 4})
graph = WeightedGraph([node_0, node_1, node_2, node_3, node_4, node_5, node_6, node_7])
self.assertEqual(graph.shortest_path(5, 9), 'Path: [5, 9]\nDistance traveled: 1')
def empty_wg():
"""Create an empty graph."""
from weighted_graph import WeightedGraph
return WeightedGraph()
# Takes a dictionary of edges to reach each node and returns a list of
# edges that goes from `start` to `end`
def path_dict_to_path(start: int, end: int, path_dict: Dict[int, WeightedEdge]) -> WeightedPath:
if len(path_dict) == 0:
return []
edge_path: WeightedPath = []
e: WeightedEdge = path_dict[end]
edge_path.append(e)
while e.u != start:
e = path_dict[e.u]
edge_path.append(e)
return list(reversed(edge_path))
if __name__ == "__main__":
city_graph2: WeightedGraph[str] = WeightedGraph(["Seattle", "San Francisco", "Los Angeles", "Riverside", "Phoenix", "Chicago", "Boston", "New York", "Atlanta", "Miami", "Dallas", "Houston", "Detroit", "Philadelphia", "Washington"])
city_graph2.add_edge_by_vertices("Seattle", "Chicago", 1737)
city_graph2.add_edge_by_vertices("Seattle", "San Francisco", 678)
city_graph2.add_edge_by_vertices("San Francisco", "Riverside", 386)
city_graph2.add_edge_by_vertices("San Francisco", "Los Angeles", 348)
city_graph2.add_edge_by_vertices("Los Angeles", "Riverside", 50)
city_graph2.add_edge_by_vertices("Los Angeles", "Phoenix", 357)
city_graph2.add_edge_by_vertices("Riverside", "Phoenix", 307)
city_graph2.add_edge_by_vertices("Riverside", "Chicago", 1704)
city_graph2.add_edge_by_vertices("Phoenix", "Dallas", 887)
city_graph2.add_edge_by_vertices("Phoenix", "Houston", 1015)
city_graph2.add_edge_by_vertices("Dallas", "Chicago", 805)
city_graph2.add_edge_by_vertices("Dallas", "Atlanta", 721)
city_graph2.add_edge_by_vertices("Dallas", "Houston", 225)
city_graph2.add_edge_by_vertices("Houston", "Atlanta", 702)
weights = {
(0, 1): 3,
(1, 7): 4,
(7, 2): 2,
(2, 5): 1,
(5, 6): 8,
(0, 3): 2,
(3, 2): 6,
(3, 4): 1,
(4, 8): 8,
(8, 0): 4
}
vertex_values = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
weighted_graph = WeightedGraph(weights, vertex_values)
weighted_graph.build_from_edges()
'''
assert weighted_graph.calc_distance(8,4) == 7
assert [weighted_graph.calc_distance(8,n) for n in range(9)] == [
4, 7, 12, 6, 7, 13, 21, 11, 0]
print("PASSED")
'''
print("Asserting calc_shortest_path for WeightedGraph class")
assert weighted_graph.calc_shortest_path(8, 4) == [8, 0, 3, 4]
assert weighted_graph.calc_shortest_path(8, 7) == [8, 0, 1, 7]
assert weighted_graph.calc_shortest_path(8, 6) == [8, 0, 3, 2, 5, 6]
print("PASSED")
if visited[edge.v]:
continue # 방문한 곳이면 넘어간다.
result.append(edge) # 최소 가중치의 에지를 결과에 추가한다.
visit(edge.v) # 연결된 에지를 방문한다.
return result
def print_weighted_path(wg: WeightedGraph, wp: WeightedPath) -> None:
for edge in wp:
print(f"{wg.vertex_at(edge.u)} {edge.weight}> {wg.vertex_at(edge.v)}")
print(f"가중치 총합: {total_weight(wp)}")
if __name__ == "__main__":
city_graph2: WeightedGraph[str] = WeightedGraph(["시애틀", "샌프란시스코", "로스앤젤레스", "리버사이드", "피닉스", "시카고",
"보스턴", "뉴욕", "애틀랜타", "마이애미", "댈러스", "휴스턴", "디트로이트", "필라델피아", "워싱턴"])
city_graph2.add_edge_by_vertices("시애틀", "시카고", 1737)
city_graph2.add_edge_by_vertices("시애틀", "샌프란시스코", 678)
city_graph2.add_edge_by_vertices("샌프란시스코", "리버사이드", 386)
city_graph2.add_edge_by_vertices("샌프란시스코", "로스앤젤레스", 348)
city_graph2.add_edge_by_vertices("로스앤젤레스", "리버사이드", 50)
city_graph2.add_edge_by_vertices("로스앤젤레스", "피닉스", 357)
city_graph2.add_edge_by_vertices("리버사이드", "피닉스", 307)
city_graph2.add_edge_by_vertices("리버사이드", "시카고", 1704)
city_graph2.add_edge_by_vertices("피닉스", "댈러스", 887)
city_graph2.add_edge_by_vertices("피닉스", "휴스턴", 1015)
city_graph2.add_edge_by_vertices("댈러스", "시카고", 805)
city_graph2.add_edge_by_vertices("댈러스", "애틀랜타", 721)
city_graph2.add_edge_by_vertices("댈러스", "휴스턴", 225)
city_graph2.add_edge_by_vertices("휴스턴", "애틀랜타", 702)
def path_dict_to_path(start: int, end: int,
path_dict: Dict[int, WeightedEdge]) -> WeightedPath:
if not path_dict:
return []
edge_path = deque()
edge: WeightedEdge = path_dict[end]
edge_path.appendleft(edge)
while edge.u != start:
edge = path_dict[edge.u]
edge_path.appendleft(edge)
return list(edge_path)
if __name__ == "__main__":
city_graph2: WeightedGraph[City] = WeightedGraph(list(City))
city_graph2.add_edge_by_vertices(City.SEA, City.CHI, 1737)
city_graph2.add_edge_by_vertices(City.SEA, City.SFO, 678)
city_graph2.add_edge_by_vertices(City.SFO, City.RVS, 386)
city_graph2.add_edge_by_vertices(City.SFO, City.LAX, 348)
city_graph2.add_edge_by_vertices(City.LAX, City.RVS, 50)
city_graph2.add_edge_by_vertices(City.LAX, City.PHX, 357)
city_graph2.add_edge_by_vertices(City.RVS, City.PHX, 307)
city_graph2.add_edge_by_vertices(City.RVS, City.CHI, 1704)
city_graph2.add_edge_by_vertices(City.PHX, City.DAL, 887)
city_graph2.add_edge_by_vertices(City.PHX, City.HOU, 1015)
city_graph2.add_edge_by_vertices(City.DAL, City.CHI, 805)
city_graph2.add_edge_by_vertices(City.DAL, City.ATL, 721)
city_graph2.add_edge_by_vertices(City.DAL, City.HOU, 225)
city_graph2.add_edge_by_vertices(City.HOU, City.ATL, 702)
def make_graph_no_edges():
my_graph = WeightedGraph()
my_graph.add_node('a')
my_graph.add_node('b')
my_graph.add_node('c')
return my_graph
# на данный момент это минимальный вес, поэтому добавляем в дерево
result.append(edge)
# идем дальше
visit(edge.v)
return result
def print_weighted_graph(wg: WeightedGraph, wp: WeightedPath) -> None:
for edge in wp:
print(
f'{wg.vertex_at(edge.u)} {edge.weight} --> {wg.vertex_at(edge.v)}')
print(f'Total weight: {total_weight(wp)}')
if __name__ == '__main__':
city_graph2: WeightedGraph[str] = WeightedGraph(['Seattle', 'San Francisco', 'Los Angeles', 'Riverside', 'Phoenix', 'Chicago', \
'Boston', 'New York', 'Atlanta', 'Miami', 'Dallas', 'Houston', 'Detroit', 'Philadelphia', 'Washington'])
city_graph2.add_edge_by_vertices('Seattle', 'Chicago', 1737)
city_graph2.add_edge_by_vertices('Seattle', 'San Francisco', 678)
city_graph2.add_edge_by_vertices('San Francisco', 'Riverside', 386)
city_graph2.add_edge_by_vertices('San Francisco', 'Los Angeles', 348)
city_graph2.add_edge_by_vertices('Los Angeles', 'Riverside', 50)
city_graph2.add_edge_by_vertices('Los Angeles', 'Phoenix', 357)
city_graph2.add_edge_by_vertices('Riverside', 'Phoenix', 307)
city_graph2.add_edge_by_vertices('Riverside', 'Chicago', 1704)
city_graph2.add_edge_by_vertices('Phoenix', 'Dallas', 887)
city_graph2.add_edge_by_vertices('Phoenix', 'Houston', 1015)
city_graph2.add_edge_by_vertices('Dallas', 'Chicago', 805)
city_graph2.add_edge_by_vertices('Dallas', 'Atlanta', 721)
city_graph2.add_edge_by_vertices('Dallas', 'Houston', 225)
city_graph2.add_edge_by_vertices('Houston', 'Atlanta', 702)
city_graph2.add_edge_by_vertices('Houston', 'Miami', 968)
weight = weighted_graph.W[edge]
u, v = edge
if dist[v] > (dist[u] + weight):
dist[v] = dist[u] + weight
parent[v] = u
pq.update({v: dist[v]})
topo_sorted_vertexes = topological_sort(weighted_graph)
for v in topo_sorted_vertexes:
for e in weighted_graph.get_set_of_children(v):
relax((v,e))
print(dist)
if __name__ == "__main__":
print("====== Testing Weighted Graph =========")
WG = WeightedGraph(directed = True)
Vertices = ["a","b", "c", "d", "e"]
Edges = [(("a", "b"), 19), (("a", "c"), 7), (("b", "c"), 11), (("b", "d"), 4), (("d", "c"), 15), (("d", "e"), 13), (("c", "e"), 5)]
WG.make_graph(Vertices, Edges)
print(WG.W)
djikstra(WG, "a")
DAG_shortest_path(WG, "a")
from dlib_models import download_model, download_predictor, load_dlib_models
download_model()
download_predictor()
def get_descriptor(img, face_detect, shape_predictor, fpath):
detection = list(face_detect(img))[0]
print("found", fpath)
shape = shape_predictor(img, detection)
descriptor = np.array(face_rec_model.compute_face_descriptor(img, shape))
return fpath, descriptor
pics = os.listdir("./../images/")
image_data = [io.imread("./../images/" + pic) for pic in pics]
load_dlib_models()
from dlib_models import models
face_detect = models["face detect"]
face_rec_model = models["face rec"]
shape_predictor = models["shape predict"]
graph = WeightedGraph(
get_descriptor(image, face_detect, shape_predictor, pics[i])
for i, image in enumerate(image_data))
graph.whispers_loop(4)
for node in graph.nodes:
print(node.ID, node.fpath)
def print_path(wp: WeightedPath, wg: WeightedGraph) -> None:
vertex_ids = list(map(lambda x: x.u, wp))
result = list(map(lambda id: wg.vertex_at(id), vertex_ids))
print(result)
return result
def print_weighted_path(weighted_graph, weighted_path):
for edge in weighted_path:
print(
f'{weighted_graph.vertex_at(edge.u)} {edge.weight}> {weighted_graph.vertex_at(edge.v)}'
)
print(f'Total weight: {total_weight(weighted_path)}')
if __name__ == '__main__':
city_graph = WeightedGraph([
'Seattle', 'San Francisco', 'Los Angeles', 'Riverside', 'Phoenix',
'Chicago', 'Boston', 'New York', 'Atlanta', 'Miami', 'Dallas',
'Houston', 'Detroit', 'Philadelphia', 'Washington'
])
city_graph.add_edge_by_vertices('Seattle', 'Chicago', 1737)
city_graph.add_edge_by_vertices('Seattle', 'San Francisco', 678)
city_graph.add_edge_by_vertices('San Francisco', 'Riverside', 386)
city_graph.add_edge_by_vertices('San Francisco', 'Los Angeles', 348)
city_graph.add_edge_by_vertices('Los Angeles', 'Riverside', 50)
city_graph.add_edge_by_vertices('Los Angeles', 'Phoenix', 357)
city_graph.add_edge_by_vertices('Riverside', 'Phoenix', 307)
city_graph.add_edge_by_vertices('Riverside', 'Chicago', 1704)
city_graph.add_edge_by_vertices('Phoenix', 'Dallas', 887)
city_graph.add_edge_by_vertices('Phoenix', 'Houston', 1015)
city_graph.add_edge_by_vertices('Dallas', 'Chicago', 805)
city_graph.add_edge_by_vertices('Dallas', 'Atlanta', 721)
(1,7): 4,
(7,2): 2,
(2,5): 1,
(5,6): 8,
(0,3): 2,
(3,2): 6,
(3,4): 1,
(4,8): 8,
(8,0): 4
}
vertex_values = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
print('\nTesting...\n')
weighted_graph_1 = WeightedGraph(weights, vertex_values)
shortest_path_1 = weighted_graph_1.calc_shortest_path(8,4)
print(" Testing Weighted Graph 2's calc_shortest_path")
assert [node.index for node in shortest_path_1] == [8, 0, 3, 4], " Weighted Graph 1's calc_shortest_path was not right, it should be [8, 0, 3, 4], but was {}".format([node.index for node in shortest_path_1])
print(" Weighted Graph 1's row_indices Passed!!!\n")
weighted_graph_2 = WeightedGraph(weights, vertex_values)
shortest_path_2 = weighted_graph_2.calc_shortest_path(6,8)
print(" Testing Weighted Graph 2's calc_shortest_path")
assert [node.index for node in shortest_path_2] == [6, 5, 2, 3, 0, 8], " Weighted Graph 2's calc_shortest_path was not right, it should be [6, 5, 2, 3, 0, 8], but was {}".format([node.index for node in shortest_path_2])
print(" Weighted Graph 2's row_indices Passed!!!\n")
weighted_graph_3 = WeightedGraph(weights, vertex_values)
shortest_path_3 = weighted_graph_3.calc_shortest_path(7,4)
print(" Testing Weighted Graph 3's calc_shortest_path")
assert [node.index for node in shortest_path_3] == [7, 2, 3, 4], " Weighted Graph 3's calc_shortest_path was not right, it should be [7, 2, 3, 4], but was {}".format([node.index for node in shortest_path_3])
def make_graph_cycle():
g = WeightedGraph()
g.add_edge('a', 'b')
g.add_edge('b', 'c')
g.add_edge('c', 'a')
return g
