Add files via upload

Author: haarit19058

graphs/VisualizeGraph.py

@@ -1,179 +1,194 @@
 import networkx as nx
 import matplotlib.pyplot as plt
-# https://networkx.org/documentation/latest/tutorial.html
-# Link for tutorial
 
 
- 
-def visualize_graph_from_adjacency_matrix(adj_matrix):
-    # Create an empty graph
-    G = nx.Graph()
-
-    # Add nodes and edges from adjacency matrix
-    for i in range(len(adj_matrix)):
-        for j in range(i, len(adj_matrix)):  # Iterate only over upper triangle for undirected graph
-            if adj_matrix[i][j] > 0:  # There's an edge between node i and j
-                G.add_edge(i, j, weight=adj_matrix[i][j])
+# For tutorial of networkx visit https://networkx.org/documentation/latest/tutorial.html
 
-    # Set up layout for the graph visualization
-    pos = nx.spring_layout(G, seed=42)  # Spring layout for better visualization
 
-    # Plot the graph
-    plt.figure(figsize=(8, 8))
-    
-    # Draw the graph with node colors and edge colors
-    nx.draw(G, pos, with_labels=True, node_color='skyblue', node_size=700, edge_color='gray', width=2)
 
-    # Optionally draw edge labels if the graph is weighted
-    edge_labels = nx.get_edge_attributes(G, 'weight')
-    if edge_labels:
-        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
-
-    # Display the graph
-    plt.title("Graph Visualization from Adjacency Matrix", size=15)
-    plt.axis('off')
-    plt.show()
+def undirected_visualize_from_adjmat(adjmat):
+    size = len(adjmat)
 
-
-def visualize(n):
+    # Create a graph object
     G = nx.Graph()
 
-    # Add edges where i is divisible by j
-    for i in range(1, n + 1):
-        for j in range(1, n + 1):
-            if i % j == 0 and i != j:
-                G.add_edge(i, j, weight=1)
+    for i in range(size):
+        for j in range(size):
+            if adjmat[i][j] != 0:
+                # Add edge to the graph object
+                G.add_edge(i, j, weight=adjmat[i][j])
+
 
-    # Set up layout for better spacing between nodes
-    pos = nx.spring_layout(G, seed=42)
+    # Specify the layout of graph
+    pos = nx.spring_layout(G)
 
-    # Create a figure
     plt.figure(figsize=(10, 10))
 
-    # Customize node colors with a color map
-    node_colors = range(1, n + 1)
-    cmap = plt.cm.viridis  # Use a color map (e.g., 'viridis', 'plasma')
-
-    # Draw nodes with color mapping, size scaling
-    nx.draw_networkx_nodes(G, pos, node_color=node_colors, cmap=cmap, node_size=800)
-
-    # Draw edges with custom width and transparency
-    nx.draw_networkx_edges(G, pos, width=2.5, edge_color="slategrey")
-
-    # Add labels to nodes with larger font size
-    nx.draw_networkx_labels(G, pos, font_size=14, font_color="white", font_weight="bold")
+    # Draw the vertices
+    nx.draw_networkx_nodes(G, pos, node_size=700, node_color='skyblue', alpha=0.9)
+    
+    # Draw the edges
+    nx.draw_networkx_edges(G, pos, width=2, alpha=0.5, edge_color='gray')
+    
+    # Draw the Vertices Labels
+    nx.draw_networkx_labels(G, pos, font_size=12, font_color='black', font_family='sans-serif')
 
-    # Optionally draw edge labels (for weighted edges if applicable)
+    # Draw the weights of edges
     edge_labels = nx.get_edge_attributes(G, 'weight')
-    if edge_labels:
-        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
-
-    # Add a title with larger font
-    plt.title(f"Divisibility Graph Visualization (n = {n})", size=20, color="darkblue", pad=20)
-    
-    # Turn off the axis
-    plt.axis("off")
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='black', font_size=10)
 
-    # Display the graph
+    plt.title("Undirected Graph Visualization", size=15)
+    plt.axis('off')
     plt.show()
 
 
-def condition(G,n):
-    # Dynamically add edges where i is divisible by j, skip j=1 for clarity
-    for i in range(1, n + 1):
-        for j in range(2, n + 1):  # Skip j=1 to avoid self-loop-like behavior
-            if i % j == 0 and i != j:
-                G.add_edge(j, i, weight=1)  # Directed edge from j to i
-
-def visualize_dag(n):
-    G = nx.DiGraph()  # Create a directed graph (DAG)
-
-    condition(G,n)    
-    
-    # Calculate the actual nodes included in the graph
-    node_list = list(G.nodes())
 
-    # Set up layout for better spacing between nodes
-    pos = nx.spring_layout(G, seed=42)
-    # pos = nx.circular_layout(G)
-    # pos = nx.shell_layout(G)
-    # pos = nx.random_layout(G)
-    # pos = nx.kamada_kawai_layout(G)
-    # pos = nx.planar_layout(G)
-    # pos = nx.spectral_layout(G,seed = 42)
-    # pos = nx.spiral_layout(G,seed = 42)
-    # pos = nx.multipartite_layout(G,seed = 42)
 
+def directed_visualize_from_adjmat(adjmat):
+    size = len(adjmat)
 
+    # Create a Digraph object
+    G = nx.DiGraph()
 
+    for i in range(size):
+        for j in range(size):
+            if adjmat[i][j] != 0:
+                # Add edges to the graph object
+                G.add_edge(i, j, weight=adjmat[i][j])
 
+    # Specify the layout to use while plotting the graph 
+    pos = nx.spring_layout(G)
 
-    # Create a figure
     plt.figure(figsize=(10, 10))
 
-    # Customize node colors with a color map
-    node_colors = range(len(node_list))  # Range over dynamically created nodes
-    cmap = plt.cm.viridis  # Use a color map (e.g., 'viridis', 'plasma')
-
-    # Draw nodes with color mapping, size scaling
-    nx.draw_networkx_nodes(G, pos, node_color=node_colors, cmap=cmap, node_size=800)
-
-    # Draw edges with arrows, custom width, and transparency
-    nx.draw_networkx_edges(G, pos, edgelist=G.edges(), width=2.5, edge_color="slategrey", arrows=True, arrowstyle='->', arrowsize=20)
-
-    # Add labels to nodes with larger font size
-    nx.draw_networkx_labels(G, pos, font_size=14, font_color="white", font_weight="bold")
+    # Draw the vertices
+    nx.draw_networkx_nodes(G, pos, node_size=700, node_color='skyblue', alpha=0.9)
+    
+    # Draw the labels for vertices
+    nx.draw_networkx_edges(G, pos,arrowstyle='-|>', arrowsize=30, width=2, alpha=0.5, edge_color='gray')
+    
+    # Draw the weights
+    nx.draw_networkx_labels(G, pos, font_size=12, font_color='black', font_family='sans-serif')
 
-    # Optionally draw edge labels (for weighted edges if applicable)
+    # Draw the weights
     edge_labels = nx.get_edge_attributes(G, 'weight')
-    if edge_labels:
-        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='black', font_size=10)
 
-    # Add a title with larger font
-    plt.title(f"DAG Visualization with Dynamic Nodes (n = {n})", size=20, color="darkblue", pad=20)
-    
-    # Turn off the axis
-    plt.axis("off")
-
-    # Display the graph
+    plt.title("Directed Graph Visualization", size=15)
+    plt.axis('off')
     plt.show()
 
-# Visualize the DAG for a given n
-# visualize_dag(12)
-
-
-
-
-
-
-
-
-
-
-
-
-# Example adjacency matrix (unweighted graph)
-adj_matrix = [
-    [0, 1, 0, 0, 1],
-    [1, 0, 1, 1, 1],
-    [0, 1, 0, 1, 0],
-    [0, 1, 1, 0, 1],
-    [1, 1, 0, 1, 0]
-]
-
-# Visualize the graph
-# visualize_graph_from_adjacency_matrix(adj_matrix)
-
-
-
-# Visualize the graph for a given n
-# visualize(12)
-
-
-
-# Visualize the DAG for a given n
-visualize_dag(15)
-
-    
-
 
+def visualize_from_adjmat(adjmat,isdirected):
+    if isdirected:
+        directed_visualize_from_adjmat(adjmat)
+    else:
+        undirected_visualize_from_adjmat(adjmat)
+
+
+
+
+def edges_to_adjacency_matrix(vertex_count, edge_count, is_directed):
+    '''
+    Takes input in form of edges and convert it to adjacency matrix.
+    '''
+
+    adjacency_matrix = [[0] * vertex_count for _ in range(vertex_count)]
+    for _ in range(edge_count):
+        u, v, weight = map(int, input().split())
+        adjacency_matrix[u][v] = weight
+        if not is_directed:
+            adjacency_matrix[v][u] = weight
+    return adjacency_matrix
+
+def matinput(vertex_count, edge_count, is_directed):
+    '''
+    Takes input in form of adjacency matrix and convert it to adjacency matrix.
+    '''
+
+    adjacency_matrix = []
+    print("Enter the adjacency matrix row by row:")
+    for _ in range(vertex_count):
+        row = list(map(int, input().split()))
+        adjacency_matrix.append(row)
+    return adjacency_matrix
+
+def list_to_adjacency_matrix(vertex_count, edge_count, is_directed):
+    '''
+    Takes input in form of adjacency list and convert it to adjacency matrix.
+    '''
+
+    adjacency_matrix = [[0] * vertex_count for _ in range(vertex_count)]
+    print("Enter the adjacency list:")
+    for u in range(vertex_count):
+        print("Neighbours of ",u,end=": ")
+        neighbours = input().split()
+        for neigh in neighbours:
+            v,weight = map(int,neigh.split(','))
+            adjacency_matrix[u][v] = weight
+            if not is_directed:
+                adjacency_matrix[v][u] = weight
+    return adjacency_matrix
+
+
+def main():
+    vertex_count = int(input("Enter the number of vertices: "))
+    edge_count = int(input("Enter the number of edges: "))
+    is_directed = int(input("Is the graph Directed?? 1 or 0 :"))
+
+    print("Enter the type of input:")
+    print("1: Edge List")
+    print("2: Adjacency Matrix")
+    print("3: Adjacency List")
+    input_type = int(input())
+
+    if input_type == 1:
+        print("The expected input is of the form u v w where w is the weight.")
+        adjacency_matrix = edges_to_adjacency_matrix(vertex_count, edge_count, is_directed)
+    elif input_type == 2:
+        print("Expected input is of the form V columns and V rows with the weights of the edges.")
+        adjacency_matrix = matinput(vertex_count, edge_count, is_directed)
+    elif input_type == 3:
+        print("Expected input is of the form for neighbour vertex v,w")
+        adjacency_matrix = list_to_adjacency_matrix(vertex_count, edge_count, is_directed)
+    else:
+        print("Enter valid input.")
+        return
+
+    visualize_from_adjmat(adjacency_matrix, is_directed)
+
+if __name__ == "__main__":
+    main()
+
+
+
+'''
+Example Inputs:
+
+1) Edge List:
+
+The expected input is of the form u v w where w is the weight.
+0 1 1
+0 2 1
+0 3 1
+3 1 1
+3 2 1
+
+2) Adj Mat:
+
+Expected input is of the form V columns and V rows with the weights of the edges.
+Enter the adjacency matrix row by row:
+0 1 1 1
+1 0 0 1
+1 0 0 1
+1 1 1 0
+
+3) Adj List:
+Expected input is of the form for neighbour vertex v,w
+Enter the adjacency list:
+Neighbours of  0: 1,2 2,3 3,-3
+Neighbours of  1: 2,3
+Neighbours of  2: 3,-3
+Neighbours of  3: 
+
+'''