add gif

Author: NiloofarShahbaz

.gitignore

@@ -1,30 +1,75 @@
 import random
 from copy import deepcopy
+import networkx as nx
+import matplotlib.pyplot as plt
+import glob
+import imageio
+import os
+import cv2
+import numpy as np
 
 
 class FindMaximumMatching:
     def __init__(self, edges, vertices):
+        self.graph = nx.Graph()
         self.edges = edges
         self.vertices = set(vertices)
         self.matching = []
         self.saturated_vertices = set()
         self.separate = False
+        self.graph.add_nodes_from(self.vertices)
+        self.graph.add_edges_from(self.edges)
+        self.pos = nx.spring_layout(self.graph)
+        self.x = 0
+        self.images = []
+        self.draw_graph()
+
+    def draw_graph(self, augmenting_path=None):
+
+        nx.draw(self.graph, self.pos, with_labels=True, font_weight='bold', node_size=1000, node_color='#efc20e', width=4,
+                edge_color='#82807b', alpha=0.8, font_size=16)
+        temp = []
+        if augmenting_path:
+            for edge in augmenting_path:
+                temp.append(tuple(edge))
+            nx.draw_networkx_edges(self.graph, self.pos,
+                                   edgelist=temp,
+                                   width=8, alpha=0.5, edge_color='r')
+
+        for edge in self.matching:
+            temp.append(tuple(edge))
+        nx.draw_networkx_edges(self.graph, self.pos,
+                               edgelist=temp,
+                               width=8, alpha=0.5, edge_color='b')
+        nx.draw_networkx_nodes(self.graph, self.pos, nodelist=list(self.saturated_vertices), node_color='#207c36',
+                               node_size=1000, alpha=0.8)
+
+        string = 'Matching Number: ' + str(len(self.matching))
+        plt.axis('off')
+        plt.text(-1, 1, string)
+
+        plt.savefig('img{}.png'.format(self.x), dpi=120, bbox_inches='tight')
+        self.x = self.x + 1
+        plt.close()
 
     def find_maximum_matching(self):
         print('matching', self.matching)
         fake_matching = []
+        useless_edges = set()
         reveiw_augmenting_path = False
         i = 0
         while True:
             print('--------------', i, '--------------')
             i = i + 1
             unsaturated = self.vertices.difference(self.saturated_vertices)
+            if reveiw_augmenting_path:
+                unsaturated = unsaturated.difference(useless_edges)
+
             if len(unsaturated) <= 1:
                 print('yaaay')
                 return
             if reveiw_augmenting_path:
                 print('reveiwwwww')
-                print('fucking unsaturated', unsaturated)
                 start = unsaturated.pop()
                 for finish in unsaturated:
                     path = self.bfs_find_path_between(start, finish)
@@ -42,15 +87,19 @@ def find_maximum_matching(self):
                             for j in range(0, len(augmenting_vertices) - 1):
                                 augmenting_path.append({augmenting_vertices[j], augmenting_vertices[j + 1]})
                             print(augmenting_path)
+                            self.draw_graph(augmenting_path)
+
                             for edge in augmenting_path:
                                 if edge in self.matching:
                                     self.matching.remove(edge)
                                 else:
                                     self.matching.append(edge)
                             print('matching', self.matching)
+                            self.draw_graph()
+
                             break
                 else:
-                    self.vertices.remove(start)
+                    useless_edges.add(start)
 
             else:
                 if not self.separate:
@@ -63,8 +112,10 @@ def find_maximum_matching(self):
                         for j in range(0, len(augmenting_vertices) - 1):
                             augmenting_path.append({augmenting_vertices[j], augmenting_vertices[j + 1]})
                         print(augmenting_path)
+                        self.draw_graph(augmenting_path)
                         self.matching = [edge for edge in augmenting_path if edge not in self.matching]
                         print('matching', self.matching)
+                        self.draw_graph()
                     else:
                         self.separate = True
                         fake_matching = []
@@ -83,13 +134,15 @@ def find_maximum_matching(self):
                         for j in range(0, len(augmenting_vertices) - 1):
                             augmenting_path.append({augmenting_vertices[j], augmenting_vertices[j + 1]})
                         print(augmenting_path)
+                        self.draw_graph(augmenting_path)
                         for edge in augmenting_path:
                             if edge in self.matching:
                                 self.matching.remove(edge)
                             else:
                                 self.matching.append(edge)
 
                         print('matching', self.matching)
+                        self.draw_graph()
                         fake_matching = [edge for edge in augmenting_path if edge not in fake_matching]
                         print('fake matching ', fake_matching)
                     else:
@@ -157,9 +210,7 @@ def bfs_find_path_between(self, start, finish):
             visited.append(node)
 
     def dfs(self, depth, vertices, v, is_matching, fake_matching=None, finish=None):
-        print("depth ", depth, "vertices", vertices, "v", v, is_matching)
         if finish is not None:
-            print('aaaaa')
             if depth is 0 and v is finish:
                 return [v]
         else:
@@ -175,15 +226,13 @@ def dfs(self, depth, vertices, v, is_matching, fake_matching=None, finish=None):
 
             else:
                 connected_edges = [edge for edge in connected_edges if edge in self.matching]
-            print(connected_edges)
             vertices.remove(v)
             if len(connected_edges) is 1:
                 v1, v2 = connected_edges[0]
                 if v1 == v:
                     path = self.dfs(depth - 1, deepcopy(vertices), v2, not is_matching, fake_matching, finish)
                 else:
                     path = self.dfs(depth - 1, deepcopy(vertices), v1, not is_matching, fake_matching, finish)
-                # print('pp', path)
                 if path:
                     path.append(v)
                     return path
@@ -192,15 +241,13 @@ def dfs(self, depth, vertices, v, is_matching, fake_matching=None, finish=None):
                 connected_edges = [edge for edge in connected_edges if edge not in fake_matching]
             else:
                 connected_edges = [edge for edge in connected_edges if edge not in self.matching]
-            print(connected_edges)
             vertices.remove(v)
             for edge in connected_edges:
                 v1, v2 = edge
                 if v1 == v:
                     path = self.dfs(depth - 1, deepcopy(vertices), v2, not is_matching, fake_matching, finish)
                 else:
                     path = self.dfs(depth - 1, deepcopy(vertices), v1, not is_matching, fake_matching, finish)
-                # print('p', path)
                 if path:
                     path.append(v)
                     return path
@@ -219,11 +266,37 @@ def find_connected_edges_to_vertex(self, vertex, vertices):
         return result
 
 
-vertices = [1, 2, 3, 4, 5, 6, 7, 8]
-# edges = [{1, 6}, {1, 7}, {1, 9}, {1, 10}, {2, 6}, {2, 7}, {2, 9}, {2, 10}, {3, 8}, {3, 10}, {4, 6}, {4, 10}, {5, 10}]
+def make_circuit_video(movie_filename, fps):
+    # sorting filenames in order
+    filenames = glob.glob('img*.png')
+    filenames_sort_indices = np.argsort([int(os.path.basename(filename).split('.')[0][3:]) for filename in filenames])
+    filenames = [filenames[i] for i in filenames_sort_indices]
+
+    # make movie
+    with imageio.get_writer(movie_filename, mode='I', fps=fps) as writer:
+        for filename in filenames:
+            image = imageio.imread(filename)
+            cv2.imshow('hel', image)
+            key = cv2.waitKey(1000)  # ~ 30 frames per second
+
+            os.remove(filename)
+            writer.append_data(image)
+
+
+
+# sample 1
+vertices = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+edges = [{1, 6}, {1, 7}, {1, 9}, {1, 10}, {2, 6}, {2, 7}, {2, 9}, {2, 10}, {3, 8}, {3, 10}, {4, 6}, {4, 10}, {5, 10}]
+
+## sample 2
+# vertices = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 # edges = [{1, 6}, {1, 7}, {2, 7}, {2, 9}, {3, 8}, {3, 6}, {4, 7}, {4, 10}, {5, 10}, {5, 8}]
-edges = [{1, 3}, {1, 6}, {1, 8}, {2, 4}, {2, 6}, {2, 7}, {2, 8}]
+
+## sample 3
+# vertices = [1, 2, 3, 4, 5, 6, 7, 8]
+# edges = [{1, 4}, {1, 5}, {1, 6}, {2, 5}, {2, 7}, {2, 8}, {3, 5}, {3, 8}]
 
 f = FindMaximumMatching(edges, vertices)
 f.find_maximum_matching()
 print(f.matching)
+make_circuit_video('animation.gif', fps=1)

LICENSE

@@ -0,0 +1,13 @@
+cycler==0.10.0
+decorator==4.4.0
+imageio==2.5.0
+kiwisolver==1.1.0
+matplotlib==3.0.3
+networkx==2.3
+numpy==1.16.3
+opencv-contrib-python==4.1.0.25
+Pillow==6.0.0
+pyparsing==2.4.0
+python-dateutil==2.8.0
+python-igraph==0.7.1.post6
+six==1.12.0