dinic + capacity scaling + test environment

Author: nik1as

README.md

@@ -0,0 +1 @@
+# Visualization of max flow algorithms

graph.py

@@ -42,19 +42,22 @@ def __init__(self, n: int):
         self.edges = [[] for _ in range(n)]
         self.n = n
 
-    def add_edge(self, source: int, target: int, capacity: int):
-        edge = Edge(source, target, capacity)
-        rev_edge = Edge(target, source, reverse=True)
+    def add_edge(self, start: int, end: int, capacity: int):
+        edge = Edge(start, end, capacity)
+        rev_edge = Edge(end, start, reverse=True)
 
         edge.reverse_edge = rev_edge
         rev_edge.reverse_edge = edge
 
-        self.edges[source].append(edge)
-        self.edges[target].append(rev_edge)
+        self.edges[start].append(edge)
+        self.edges[end].append(rev_edge)
 
     def get_edges_by_node(self, node: int):
         return self.edges[node]
 
+    def get_degree(self, node: int):
+        return len(self.edges[node])
+
     def get_edges(self):
         for i in range(self.n):
             for edge in self.get_edges_by_node(i):
@@ -71,3 +74,9 @@ def get_nodes(self):
 
     def number_of_nodes(self):
         return self.n
+
+    def copy(self):
+        new_graph = Graph(self.number_of_nodes())
+        for edge in self.get_edges():
+            new_graph.add_edge(edge.start, edge.end, edge.capacity)
+        return new_graph

gui.py

@@ -1,32 +1,38 @@
-import random
 import tkinter as tk
 from tkinter import messagebox
 from tkinter import ttk
 
+from tabulate import tabulate
+
 import max_flow
 import random_graph
 import utils
 
+ALGORITHMS_MAP = {"Ford-Fulkerson": max_flow.FordFulkerson,
+                  "Edmonds-Karp": max_flow.EdmondsKarp,
+                  "Capacity Scaling": max_flow.CapacityScaling,
+                  "Dinic": max_flow.Dinic,
+                  # TODO
+                  # "Goldberg-Tarjan": max_flow.GoldbergTarjan
+                  }
+ALGORITHMS = list(ALGORITHMS_MAP.keys())
+
 
 class Visualization(tk.Frame):
-    ALGORITHMS_MAP = {"Ford-Fulkerson": max_flow.FordFulkerson,
-                      "Edmonds-Karp": max_flow.EdmondsKarp,
-                      "Dinic": max_flow.Dinic,
-                      "Goldberg-Tarjan": max_flow.GoldbergTarjan}
-    ALGORITHMS = list(ALGORITHMS_MAP.keys())
     DEFAULT_NODES = 6
     DEFAULT_MAX_CAPACITY = 5
-    NODE_RADIUS = 5
+    NODE_RADIUS = 8
 
     def __init__(self, parent):
         super().__init__(parent)
 
         config_bar = tk.Frame(self)
 
         self.algo_variable = tk.StringVar(config_bar)
-        self.algo_variable.set(self.ALGORITHMS[0])
+        self.algo_variable.set(ALGORITHMS[0])
 
-        self.opt_algorithm = tk.OptionMenu(config_bar, self.algo_variable, *self.ALGORITHMS)
+        self.opt_algorithm = tk.OptionMenu(config_bar, self.algo_variable, *ALGORITHMS)
+        self.opt_algorithm.config(width=20)
         self.opt_algorithm.grid(row=0, column=0, padx=10)
         self.max_flow_algo = None
 
@@ -59,6 +65,9 @@ def __init__(self, parent):
         self.btn_stop = tk.Button(text="stop", master=config_bar, command=self.stop)
         self.btn_stop.grid(row=0, column=9, padx=10)
 
+        self.btn_help = tk.Button(text="help", master=config_bar, command=self.help)
+        self.btn_help.grid(row=0, column=9, padx=11)
+
         config_bar.pack(anchor=tk.N)
 
         self.canvas = tk.Canvas(self, bg="white")
@@ -78,8 +87,8 @@ def render(self):
 
         self.canvas.create_rectangle(0, 0, width, height, fill="white")
 
-        self.render_nodes()
         self.render_edges()
+        self.render_nodes()
         self.render_text()
 
     def render_nodes(self):
@@ -123,9 +132,45 @@ def render_edges(self):
 
         for edge in self.graph.get_edges():
             if not edge.reverse:
+                # TODO move arrow start and end to the outline of the node circles
                 p1 = utils.absolute_position(self.graph.get_nodes()[edge.start], width, height)
                 p2 = utils.absolute_position(self.graph.get_nodes()[edge.end], width, height)
-                self.canvas.create_line(p1, p2, width=3, fill="black", arrow=tk.LAST, arrowshape=(10, 15, 5))
+                self.canvas.create_line(p1, p2, width=3, fill="black", arrow=tk.LAST, arrowshape=(10, 10, 5))
+
+    def render_step(self, result):
+        self.render()
+
+        width = self.canvas.winfo_width()
+        height = self.canvas.winfo_height()
+
+        if self.algo_variable.get() == "Dinic":
+            edges, level = result
+            for node in self.graph.get_nodes():
+                position = utils.absolute_position(node, width, height)
+                self.canvas.create_text(*position,
+                                        text=f"{level[node.node_id]}",
+                                        fill="white",
+                                        font=('Helvetica', '10', 'bold'))
+        else:
+            edges = result
+
+        for edge in edges:
+            p1 = utils.absolute_position(self.graph.get_nodes()[edge.start], width, height)
+            p2 = utils.absolute_position(self.graph.get_nodes()[edge.end], width, height)
+            self.canvas.create_line(p1, p2, width=3, fill="red", arrow=tk.LAST, arrowshape=(10, 15, 5))
+        self.render_text()
+
+    def algorithm_terminated(self):
+        self.btn_stop["state"] = tk.DISABLED
+        self.btn_step["state"] = tk.DISABLED
+        self.btn_start["state"] = tk.DISABLED
+        self.ent_time["state"] = tk.DISABLED
+        self.render()
+        if self._jop is not None:
+            window.after_cancel(self._jop)
+            self._jop = None
+        flow_value = sum(e.flow for e in self.graph.get_edges_by_node(self.source))
+        messagebox.showinfo("Info", f"algorithm terminated!\nmax-flow value: {flow_value}")
 
     def reset(self):
         try:
@@ -136,41 +181,37 @@ def reset(self):
             self.render()
 
             self.opt_algorithm["state"] = tk.NORMAL
+            self.btn_step["state"] = tk.NORMAL
+            self.btn_start["state"] = tk.NORMAL
+            self.btn_stop["state"] = tk.NORMAL
+            self.ent_time["state"] = tk.NORMAL
+
             self.max_flow_algo = None
         except ValueError:
             messagebox.showerror("Error", "nodes and capacity must be an integer")
 
     def step(self):
         if self.max_flow_algo is None:
-            self.source, self.target = random.sample(range(self.graph.number_of_nodes()), 2)  # TODO
-            self.max_flow_algo = self.ALGORITHMS_MAP[self.algo_variable.get()](self.graph, self.source, self.target)
-
-        self.opt_algorithm["state"] = tk.DISABLED
-
-        if path := self.max_flow_algo.step():
-            self.render()
-
-            for edge in path:
-                width = self.canvas.winfo_width()
-                height = self.canvas.winfo_height()
+            self.source, self.target = utils.get_source_and_target(self.graph)
+            self.max_flow_algo = ALGORITHMS_MAP[self.algo_variable.get()](self.graph, self.source, self.target)
+            self.opt_algorithm["state"] = tk.DISABLED
 
-                p1 = utils.absolute_position(self.graph.get_nodes()[edge.start], width, height)
-                p2 = utils.absolute_position(self.graph.get_nodes()[edge.end], width, height)
-                self.canvas.create_line(p1, p2, width=3, fill="red", arrow=tk.LAST, arrowshape=(10, 15, 5))
-            self.render_text()
+        if result := self.max_flow_algo.step():
+            self.render_step(result)
         else:
-            messagebox.showinfo("Info", "algorithm terminated!")
+            self.algorithm_terminated()
 
     def start(self):
         try:
             intervall = int(self.ent_time.get())
 
             self.opt_algorithm["state"] = tk.DISABLED
             self.btn_step["state"] = tk.DISABLED
+            self.btn_start["state"] = tk.DISABLED
             self.ent_time["state"] = tk.DISABLED
 
-            self.step()
             self._jop = window.after(intervall, self.start)
+            self.step()
         except ValueError:
             messagebox.showerror("Error", "intervall must be an integer")
 
@@ -182,29 +223,98 @@ def stop(self):
             window.after_cancel(self._jop)
             self._jop = None
 
+    def help(self):
+        messagebox.showinfo("Help", """
+Max-Flow Visualization
+
+notation:
+n: number of nodes\tm: number of edges
+F: max-flow value\tC: max capacity
 
-class TestEnvoirement(tk.Frame):
+implemented algorithms:
+Ford-Fulkerson: O(m F)
+Edmonds-Karp: O(n m^2)
+Capacity Scaling: O(n m logC)
+Dinic: O(m n^2)
+Goldberg-Tarjan: O()
+""")
+
+
+class TestEnviroment(tk.Frame):
 
     def __init__(self, parent):
         super().__init__(parent)
 
         self.btn_start = tk.Button(text="start", master=self, command=self.start_test)
         self.btn_start.pack(fill="x")
 
+        lbl_info = tk.Label(text="Please enter one comma separated triple per line: instances, nodes, capacity",
+                            master=self)
+        lbl_info.pack(fill="x")
+
         self.txt_triples = tk.Text(master=self)
         self.txt_triples.insert(tk.END, "10, 5, 5")
         self.txt_triples.pack(fill="x")
 
-        self.lbl_output = tk.Label(text="Hello World", master=self)
-        self.lbl_output.pack(fill="both")
+        scroll_output = tk.Scrollbar(orient='vertical', master=self)
+        scroll_output.pack(side=tk.RIGHT, fill='both')
+
+        self.txt_output = tk.Text(yscrollcommand=scroll_output.set, master=self)
+        scroll_output.config(command=self.txt_output.yview)
+        self.txt_output.pack(fill="both")
 
     def start_test(self):
+        self.txt_output.delete(1.0, "end-1c")
+
         triples = self.txt_triples.get(1.0, "end-1c")
         for line in triples.split("\n"):
-            instances, nodes, capacity = map(int, line.split(","))
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                instances, nodes, capacity = map(int, line.split(","))
+            except ValueError:
+                messagebox.showerror("Error", "invalid input")
+                return
+
             for _ in range(instances):
                 graph = random_graph.generate(nodes, capacity)
-                # TODO Flusserhaltung, Kapazitätsbedingung, Flusswerte unterschiedlich
+                source, target = utils.get_source_and_target(graph)
+
+                result = [["Algorithm", "flow preservation", "capacity bound", "max flow"]]
+                flow_values = []
+
+                for name, algo_class in ALGORITHMS_MAP.items():
+                    result_graph = graph.copy()
+                    algo = algo_class(result_graph, source, target)
+
+                    while algo_result := algo.step():
+                        pass
+
+                    # capacity bound check
+                    capacity_bound = True
+                    flow_in = [0 for _ in range(result_graph.number_of_nodes())]
+                    flow_out = [0 for _ in range(result_graph.number_of_nodes())]
+
+                    for edge in result_graph.get_edges():
+                        if not edge.reverse:
+                            flow_out[edge.start] += edge.flow
+                            flow_in[edge.end] += edge.flow
+                            if edge.flow > edge.capacity:
+                                capacity_bound = False
+
+                    # flow preservation check
+                    flow_preservation = all(flow_in[i] == flow_out[i] for i in range(result_graph.number_of_nodes())
+                                            if i not in (source, target))
+
+                    flow = sum(edge.flow for edge in result_graph.get_edges() if not edge.reverse)
+                    flow_values.append(flow)
+
+                    result.append([name, flow_preservation, capacity_bound, flow])
+
+                self.txt_output.insert("end-1c", "\n" +
+                                       tabulate(result, headers="firstrow", tablefmt="fancy_grid") +
+                                       f"\nidetical max flow: {len(set(flow_values)) == 1}\n")
 
 
 window = tk.Tk()
@@ -222,7 +332,7 @@ def start_test(self):
 frame_visualization.pack()
 tabs.add(frame_visualization, text="Visualization")
 
-frame_test_envoirement = TestEnvoirement(tabs)
+frame_test_envoirement = TestEnviroment(tabs)
 frame_test_envoirement.pack()
 tabs.add(frame_test_envoirement, text="Test enviroment")