import streamlit as st # import itertools as it import matplotlib.pyplot as plt import networkx as nx import numpy as np from operator import itemgetter import math # Import the math module from matplotlib import animation from mpl_toolkits.mplot3d import Axes3D from streamlit.components.v1 import html import matplotlib.colors as mpl # Sidebar for selecting an option sidebar_option = st.sidebar.radio("Select an option", ["Introductory Tutorial", "Basic: Properties", "Basic: Read and write graphs", "Basic: Simple graph", "Basic: Simple graph Directed", "Drawing: Custom Node Position", "Drawing: Cluster Layout", "Drawing: Degree Analysis", "Drawing: Ego Graph", "Drawing: Eigenvalues", "Drawing: Four Grids", "Drawing: House With Colors", "Drawing: Labels And Colors", "Drawing: Multipartite Layout", "Drawing: Node Colormap", "Drawing: Rainbow Coloring", "Drawing: Random Geometric Graph","Drawing: Self-loops", "Drawing: Simple Path", "Drawing: Spectral Embedding", "Drawing: Traveling Salesman Problem", "Drawing: Weighted Graph", "3D Drawing: Animations of 3D Rotation", "3D Drawing: Basic Matplotlib", "Graph: DAG - Topological Layout", "Graph: Erdos Renyi", "Graph: Karate Club", "Graph: Minimum Spanning Tree", "Graph: Triads", "Algorithms: Cycle Detection", "Algorithms: Greedy Coloring"]) # Display content when "Select an option" is chosen if sidebar_option == "Introductory Tutorial": st.title("Graph Visualization and Analysis Options") # Add content descriptions descriptions = [ ("Basic: Properties", "This option provides insights into the foundational aspects of a graph. You can count nodes (individual points) and edges (connections between nodes). For example, in a graph representing a social network, the nodes could be people, and the edges could represent friendships. The degree distribution tells how many connections each node has, helping identify influential nodes."), ("Basic: Read and Write Graphs", "This feature lets you load graphs from files or save your current graph for later use. For instance, if you have a graph stored in a GML file, you can load it and analyze it in your program. Similarly, you can save graphs as adjacency lists or edge lists for portability."), ("Basic: Simple Graph", "This generates simple, undirected graphs where edges don’t have a direction. For example, a graph showing roads between cities where travel is possible in both directions. You can create specific structures like a star graph (one central hub) or a cycle graph (nodes connected in a loop)."), ("Basic: Simple Graph Directed", "Directed graphs have edges with a direction. They are useful for workflows or dependencies. For example, in a project plan, a directed graph might show tasks with arrows indicating the order in which they need to be completed."), ("Drawing: Custom Node Position", "This feature allows you to manually set where each node appears on the graph. For example, in a family tree, you might want to position nodes to reflect generational hierarchies rather than relying on an automatic layout."), ("Drawing: Cluster Layout", "Nodes are grouped into clusters based on their connections. For instance, in a network of social media users, this could highlight friend groups. Each group would appear as a tight cluster in the visualization."), ("Drawing: Degree Analysis", "This visualizes the connections (or degree) of nodes. For example, in a transportation network, hubs like airports can be highlighted because they have the highest degree, representing more connections to other nodes. "), ("Drawing: Ego Graph", "Focuses on a single node and its immediate connections. For instance, if you want to see all direct friends of a specific person on a social network, this feature isolates that person and their relationships. "), ("Drawing: Eigenvalues", "Eigenvalues come from the graph’s Laplacian matrix and reveal structural properties. For example, in community detection, eigenvalues can help identify clusters or measure the connectivity of a graph. "), ("Drawing: House With Colors", "Displays a basic "house graph," a simple structure that resembles a house. For example, you could use it for teaching graph theory basics, with color-coded nodes and edges representing different parts of the structure. "), ("Drawing: Labels and Colors", "This lets you customize the appearance of nodes and edges by adding labels or colors. For example, in a roadmap, cities (nodes) can be color-coded by region, and roads (edges) can have labels for distance. "), ("Drawing: Multipartite Layout", "Creates multipartite graphs where nodes are divided into layers, and edges only connect nodes from different layers. For instance, in a university, one layer could represent professors and another students, with edges indicating which professor teaches which student. "), ("Drawing: Node Colormap", "Applies color gradients to nodes based on their properties, like degree or centrality. For example, nodes in a social network can be shaded to show influence, with darker colors for highly connected individuals. "), ("Drawing: Rainbow Coloring", "This colorful feature assigns different colors to edges, helping differentiate them. For example, in a circular graph, this can show the relative positions of connections, making it visually appealing. "), ("Drawing: Random Geometric Graph", "Generates graphs where nodes are connected if they’re within a specific distance. For example, in a wireless sensor network, nodes represent sensors, and edges show connectivity based on signal range. "), ("Drawing: Self-loops", "Visualizes edges that start and end at the same node. For example, in a citation network, a self-loop could represent a researcher citing their previous work. "), ("Drawing: Simple Path", "Displays simple linear graphs where nodes connect in a sequence. For example, it could represent a production line where each step depends on the previous one. "), ("Drawing: Spectral Embedding", "Uses a mathematical technique to arrange nodes in a lower-dimensional space. For example, you can visualize clusters in a high-dimensional dataset in a way that preserves their relationships. "), ("Drawing: Traveling Salesman Problem", "Visualizes solutions to the Traveling Salesman Problem (TSP), where the goal is to find the shortest route visiting every node once. For example, a delivery route optimization can use this to minimize travel costs. "), ("Drawing: Weighted Graph", "Shows graphs with weighted edges. For example, in a flight network, edge weights can represent ticket prices or distances, with thicker edges for higher weights. "), ("3D Drawing: Animations of 3D Rotation", "Generates 3D graphs with rotation animations. For example, you can visualize molecule structures or spatial relationships dynamically. "), ("3D Drawing: Basic Matplotlib", "Creates 3D graph visualizations using Matplotlib, letting you explore spatial relationships. For example, you could map a city’s buildings in 3D space. "), ("Graph: DAG - Topological Layout", "Displays Directed Acyclic Graphs (DAGs) in a topological order. For example, it can represent workflows or dependency graphs where tasks need to follow a sequence. "), ("Graph: Erdos Renyi", "Generates random graphs where edges appear based on a probability. For example, you can model random connections in a network to study statistical properties. "), ("Graph: Karate Club", "This graph is a classic benchmark in network science, showing relationships in a club. It’s often used for community detection and teaching graph analysis. "), ("Graph: Minimum Spanning Tree", "Extracts a tree from the graph connecting all nodes with the minimum total edge weight. For example, this is used in network design to minimize cable or pipeline costs. "), ("Graph: Triads", "Analyzes three-node structures (triads). For example, in social networks, closed triads (triangles) indicate strong relationships among three people. "), ("Algorithms: Cycle Detection", "Detects cycles in graphs, useful for spotting feedback loops or circular dependencies. For example, in a dependency graph, it can help identify tasks that reference each other. "), ("Algorithms: Greedy Coloring", "Colors nodes so that no two adjacent nodes share the same color. For example, in exam scheduling, this ensures no two overlapping exams are assigned the same room. ") ] for title, desc in descriptions: st.subheader(title) # Removed the ### here st.write(desc) st.write("---") def plot_greedy_coloring(graph): # Apply greedy coloring graph_coloring = nx.greedy_color(graph) unique_colors = set(graph_coloring.values()) # Assign colors to nodes based on the greedy coloring graph_color_to_mpl_color = dict(zip(unique_colors, mpl.TABLEAU_COLORS)) node_colors = [graph_color_to_mpl_color[graph_coloring[n]] for n in graph.nodes()] # Layout of the graph pos = nx.spring_layout(graph, seed=14) # Draw the graph nx.draw( graph, pos, with_labels=True, node_size=500, node_color=node_colors, edge_color="grey", font_size=12, font_color="#333333", width=2, ) plt.title("Greedy Coloring of Graph") st.pyplot(plt) def algorithms_greedy_coloring(): st.title("Algorithms: Greedy Coloring") # Option to choose between creating your own or using the default example graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="The default example shows a predefined graph, or you can create your own." ) if graph_mode == "Default Example": # Create a predefined graph (Dodecahedral graph) for the greedy coloring example G = nx.dodecahedral_graph() st.write("Default Graph: Dodecahedral Graph with Greedy Coloring.") plot_greedy_coloring(G) elif graph_mode == "Create Your Own": st.write("### Create Your Own Graph") # Input for creating a custom graph nodes_input = st.text_area("Enter nodes (e.g., 1, 2, 3, 4):") edges_input = st.text_area("Enter edges (e.g., (1, 2), (2, 3), (3, 4)):").strip() if st.button("Generate Graph"): if nodes_input and edges_input: try: # Clean and parse the input for nodes (strip spaces, remove empty strings) nodes = [node.strip() for node in nodes_input.split(",") if node.strip()] nodes = list(map(int, nodes)) # Clean and parse the input for edges (strip spaces and remove empty strings) edges = [edge.strip() for edge in edges_input.split("),") if edge.strip()] edges = [tuple(map(int, edge.strip("()").split(","))) for edge in edges] G = nx.Graph() G.add_nodes_from(nodes) G.add_edges_from(edges) st.write("Custom Graph:", G.edges()) plot_greedy_coloring(G) except Exception as e: st.error(f"Error creating the graph: {e}") else: st.error("Please enter valid nodes and edges.") if sidebar_option == "Algorithms: Greedy Coloring": algorithms_greedy_coloring() # Helper function to draw and display graph def draw_graph(G, pos=None, title="Graph Visualization"): plt.figure(figsize=(8, 6)) nx.draw(G, pos=pos, with_labels=True, node_color='lightblue', node_size=500, font_size=10, font_weight='bold') st.pyplot(plt) def plot_cycle_detection(graph): # Draw the graph pos = nx.spring_layout(graph, seed=8020) nx.draw(graph, pos, with_labels=True, node_size=2000, node_color="lightblue") # Find all cycles in the directed graph try: cycles = list(nx.simple_cycles(graph)) if cycles: st.write("Cycles Detected:") for cycle in cycles: st.write(cycle) # Highlight each cycle in red for cycle in cycles: edges_in_cycle = [(cycle[i], cycle[i + 1] if i + 1 < len(cycle) else cycle[0]) for i in range(len(cycle))] nx.draw_networkx_edges(graph, pos, edgelist=edges_in_cycle, edge_color="r", width=2) else: st.write("No cycles detected") except Exception as e: st.error(f"Error detecting cycles: {e}") # Display the graph plt.title("Cycle Detection in Directed Graph") st.pyplot(plt) def algorithms_cycle_detection(): st.title("Algorithms: Cycle Detection") # Option to choose between creating your own or using the default example graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="The default example shows a predefined graph, or you can create your own." ) if graph_mode == "Default Example": # Create a predefined graph with multiple cycles G = nx.DiGraph([(1, 2), (2, 3), (3, 4), (4, 2)]) st.write("Default Graph: A simple directed graph with multiple cycles.") plot_cycle_detection(G) elif graph_mode == "Create Your Own": st.write("### Create Your Own Graph") # Input for creating custom graph edges_input = st.text_area("Enter directed edges (e.g., (1, 2), (2, 3), (3, 1), (3, 4)):").strip() if st.button("Generate Graph"): if edges_input: try: edges = [] # Ensure correct formatting of the input string edge_strings = edges_input.split("),") for edge_str in edge_strings: edge_str = edge_str.strip() if edge_str: # Handle the case where the edge might be missing a closing parenthesis if edge_str[-1] != ")": edge_str += ")" # Remove the opening and closing parentheses edge_tuple = edge_str.strip("()").split(",") if len(edge_tuple) == 2: try: # Safely convert to integers and add the edge edge_tuple = tuple(map(int, edge_tuple)) edges.append(edge_tuple) except ValueError: st.error(f"Invalid edge format: {edge_str}") return if edges: # Create the graph G = nx.DiGraph(edges) st.write("Custom Graph:", G.edges()) plot_cycle_detection(G) else: st.error("No valid edges provided.") except Exception as e: st.error(f"Error creating the graph: {e}") else: st.error("Please enter valid directed edges.") # Display the corresponding page based on sidebar option if sidebar_option == "Algorithms: Cycle Detection": algorithms_cycle_detection() def triads_graph(): st.title("Graph: Triads") # Sidebar selection for Default Example or Custom Triads graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows predefined triads, or you can create your own triads." ) if graph_mode == "Default Example": # Define the triads triads = { "003": [], "012": [(1, 2)], "102": [(1, 2), (2, 1)], "021D": [(3, 1), (3, 2)], "021U": [(1, 3), (2, 3)], "021C": [(1, 3), (3, 2)], "111D": [(1, 2), (2, 1), (3, 1)], "111U": [(1, 2), (2, 1), (1, 3)], "030T": [(1, 2), (3, 2), (1, 3)], "030C": [(1, 3), (3, 2), (2, 1)], "201": [(1, 2), (2, 1), (3, 1), (1, 3)], "120D": [(1, 2), (2, 1), (3, 1), (3, 2)], "120U": [(1, 2), (2, 1), (1, 3), (2, 3)], "120C": [(1, 2), (2, 1), (1, 3), (3, 2)], "210": [(1, 2), (2, 1), (1, 3), (3, 2), (2, 3)], "300": [(1, 2), (2, 1), (2, 3), (3, 2), (1, 3), (3, 1)], } fig, axes = plt.subplots(4, 4, figsize=(10, 10)) for (title, triad), ax in zip(triads.items(), axes.flatten()): G = nx.DiGraph() G.add_nodes_from([1, 2, 3]) G.add_edges_from(triad) nx.draw_networkx( G, ax=ax, with_labels=True, # Labels the vertices node_color=["green"], node_size=200, arrowsize=20, width=2, pos=nx.planar_layout(G), ) ax.set_xlim(val * 1.2 for val in ax.get_xlim()) ax.set_ylim(val * 1.2 for val in ax.get_ylim()) ax.text( 0, 0, title, fontsize=15, fontweight="extra bold", horizontalalignment="center", bbox={"boxstyle": "square,pad=0.3", "fc": "none"}, ) fig.tight_layout() st.pyplot(fig) elif graph_mode == "Create Your Own": st.write("### Create Your Own Triads") # Input: Enter triads as a dictionary (e.g., {'triad_name': [(1, 2), (2, 1)]}) triad_input = st.text_area( "Enter your triads in the format: {'triad_name': [(edge1), (edge2), ...]}", value="{'003': [], '012': [(1, 2)]}" ) # Generate Button if st.button("Generate Graph"): # Try to evaluate the input as a dictionary of triads try: custom_triads = eval(triad_input) if isinstance(custom_triads, dict) and all(isinstance(value, list) and all(isinstance(edge, tuple) and len(edge) == 2 for edge in value) for value in custom_triads.values()): fig, axes = plt.subplots(len(custom_triads), 1, figsize=(10, len(custom_triads) * 5)) if len(custom_triads) == 1: # Handle case where only one triad is entered axes = [axes] for (title, triad), ax in zip(custom_triads.items(), axes): G = nx.DiGraph() G.add_nodes_from([1, 2, 3]) G.add_edges_from(triad) nx.draw_networkx( G, ax=ax, with_labels=True, # Labels the vertices node_color=["green"], node_size=200, arrowsize=20, width=2, pos=nx.planar_layout(G), ) ax.set_xlim(val * 1.2 for val in ax.get_xlim()) ax.set_ylim(val * 1.2 for val in ax.get_ylim()) ax.text( 0, 0, title, fontsize=15, fontweight="extra bold", horizontalalignment="center", bbox={"boxstyle": "square,pad=0.3", "fc": "none"}, ) fig.tight_layout() st.pyplot(fig) else: st.error("Invalid format. Please enter a dictionary of triads in the format {'triad_name': [(edge1), (edge2), ...]}.") except Exception as e: st.error(f"Error parsing input: {e}") # Display the corresponding page based on sidebar option if sidebar_option == "Graph: Triads": triads_graph() def minimum_spanning_tree_graph(): st.title("Graph: Minimum Spanning Tree") # Sidebar selection for Default Example or Custom Graph graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows a graph and its minimum spanning tree, or you can create your own graph." ) if graph_mode == "Default Example": # Create a default graph G = nx.Graph() G.add_edges_from( [ (0, 1, {"weight": 4}), (0, 7, {"weight": 8}), (1, 7, {"weight": 11}), (1, 2, {"weight": 8}), (2, 8, {"weight": 2}), (2, 5, {"weight": 4}), (2, 3, {"weight": 7}), (3, 4, {"weight": 9}), (3, 5, {"weight": 14}), (4, 5, {"weight": 10}), (5, 6, {"weight": 2}), (6, 8, {"weight": 6}), (7, 8, {"weight": 7}), ] ) # Find the minimum spanning tree T = nx.minimum_spanning_tree(G) # Visualize the graph and the minimum spanning tree pos = nx.spring_layout(G) fig, ax = plt.subplots(figsize=(8, 8)) nx.draw_networkx_nodes(G, pos, node_color="lightblue", node_size=500, ax=ax) nx.draw_networkx_edges(G, pos, edge_color="grey", ax=ax) nx.draw_networkx_labels(G, pos, font_size=12, font_family="sans-serif", ax=ax) nx.draw_networkx_edge_labels( G, pos, edge_labels={(u, v): d["weight"] for u, v, d in G.edges(data=True)}, ax=ax ) nx.draw_networkx_edges(T, pos, edge_color="green", width=2, ax=ax) ax.set_title("Graph and Minimum Spanning Tree") plt.axis("off") st.pyplot(fig) elif graph_mode == "Create Your Own": st.write("### Create Your Own Graph") # Allow user to input the number of nodes and edges for custom graph num_nodes = st.number_input("Number of nodes", min_value=2, value=5) num_edges = st.number_input("Number of edges", min_value=1, value=6) # Create empty graph G = nx.Graph() # Allow user to input the edges and their weights manually edges = [] for i in range(num_edges): source = st.number_input(f"Source node for edge {i+1}", min_value=0, max_value=num_nodes-1, key=f"source_{i}") dest = st.number_input(f"Destination node for edge {i+1}", min_value=0, max_value=num_nodes-1, key=f"dest_{i}") weight = st.number_input(f"Weight for edge ({source}, {dest})", min_value=1, value=1, key=f"weight_{i}") edges.append((source, dest, {"weight": weight})) # Add edges to the graph G.add_edges_from(edges) # Add nodes to the graph (to ensure all nodes are included, even if not explicitly added by the user) G.add_nodes_from(range(num_nodes)) # Button to generate the graph and calculate MST if st.button("Generate Graph"): # Find the minimum spanning tree T = nx.minimum_spanning_tree(G) # Visualize the graph and the minimum spanning tree pos = nx.spring_layout(G) fig, ax = plt.subplots(figsize=(8, 8)) nx.draw_networkx_nodes(G, pos, node_color="lightblue", node_size=500, ax=ax) nx.draw_networkx_edges(G, pos, edge_color="grey", ax=ax) nx.draw_networkx_labels(G, pos, font_size=12, font_family="sans-serif", ax=ax) nx.draw_networkx_edge_labels( G, pos, edge_labels={(u, v): d["weight"] for u, v, d in G.edges(data=True)}, ax=ax ) nx.draw_networkx_edges(T, pos, edge_color="green", width=2, ax=ax) ax.set_title("Custom Graph and Minimum Spanning Tree") plt.axis("off") st.pyplot(fig) # Display the corresponding page based on sidebar option if sidebar_option == "Graph: Minimum Spanning Tree": minimum_spanning_tree_graph() def karate_club_graph(): st.title("Graph: Karate Club") # Sidebar selection for Default Example or Custom Graph graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows the Karate Club graph, or you can create your own graph." ) if graph_mode == "Default Example": # Load the Karate Club graph G = nx.karate_club_graph() # Display node degree st.write("### Node Degree") for v in G: st.write(f"Node {v:4}: Degree = {G.degree(v)}") # Visualize the graph using circular layout st.write("### Graph Visualization") fig, ax = plt.subplots() nx.draw_circular(G, with_labels=True, ax=ax, node_color="skyblue", edge_color="gray") ax.set_title("Karate Club Graph") st.pyplot(fig) elif graph_mode == "Create Your Own": st.write("### Create Your Own Graph") # Allow user to input the number of nodes and edges for custom graph num_nodes = st.number_input("Number of nodes", min_value=2, value=10) num_edges = st.number_input("Number of edges", min_value=1, value=15) seed = st.number_input("Seed for Random Graph (optional)", value=20160) # Generate graph button if st.button("Generate Graph"): # Create random graph with user input G = nx.gnm_random_graph(num_nodes, num_edges, seed=seed) # Display node degree st.write("### Node Degree") for v in G: st.write(f"Node {v:4}: Degree = {G.degree(v)}") # Visualize the graph using circular layout st.write("### Graph Visualization") fig, ax = plt.subplots() nx.draw_circular(G, with_labels=True, ax=ax, node_color="lightgreen", edge_color="gray") ax.set_title("Custom Graph") st.pyplot(fig) # Display the corresponding page based on sidebar option if sidebar_option == "Graph: Karate Club": karate_club_graph() def erdos_renyi_graph(): st.title("Graph: Erdos Renyi") # Sidebar selection for Default Example or Custom Graph graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows a random graph, or you can create your own Erdos-Renyi graph." ) if graph_mode == "Default Example": # Default random graph parameters n = 10 # 10 nodes m = 20 # 20 edges seed = 20160 # seed random number generators for reproducibility # Create a button for generating the graph if st.button("Generate Graph"): # Create random graph G = nx.gnm_random_graph(n, m, seed=seed) # Display node properties st.write("### Node Degree and Clustering Coefficient") for v in nx.nodes(G): st.write(f"Node {v}: Degree = {nx.degree(G, v)}, Clustering Coefficient = {nx.clustering(G, v)}") # Display adjacency list st.write("### Adjacency List") adj_list = "\n".join([line for line in nx.generate_adjlist(G)]) st.text(adj_list) # Visualize the graph pos = nx.spring_layout(G, seed=seed) # Seed for reproducible layout fig, ax = plt.subplots() nx.draw(G, pos=pos, ax=ax, with_labels=True, node_color="skyblue", edge_color="gray") ax.set_title("Erdos-Renyi Random Graph") st.pyplot(fig) elif graph_mode == "Create Your Own": st.write("### Create Your Own Random Erdos-Renyi Graph") # Allow user to input the number of nodes and edges n = st.number_input("Number of nodes (n)", min_value=2, value=10) m = st.number_input("Number of edges (m)", min_value=1, value=20) seed = st.number_input("Seed", value=20160) # Create a button for generating the graph if st.button("Generate Graph"): # Create random graph G = nx.gnm_random_graph(n, m, seed=seed) # Display node properties st.write("### Node Degree and Clustering Coefficient") for v in nx.nodes(G): st.write(f"Node {v}: Degree = {nx.degree(G, v)}, Clustering Coefficient = {nx.clustering(G, v)}") # Display adjacency list st.write("### Adjacency List") adj_list = "\n".join([line for line in nx.generate_adjlist(G)]) st.text(adj_list) # Visualize the graph pos = nx.spring_layout(G, seed=seed) # Seed for reproducible layout fig, ax = plt.subplots() nx.draw(G, pos=pos, ax=ax, with_labels=True, node_color="skyblue", edge_color="gray") ax.set_title("Erdos-Renyi Random Graph") st.pyplot(fig) # Display the corresponding page based on sidebar option if sidebar_option == "Graph: Erdos Renyi": erdos_renyi_graph() def dag_topological_layout(): st.title("Graph: DAG - Topological Layout") # Sidebar selection for Default Example or Custom Graph graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows DAG layout in topological order, or you can create your own DAG." ) if graph_mode == "Default Example": # Default DAG example G = nx.DiGraph( [ ("f", "a"), ("a", "b"), ("a", "e"), ("b", "c"), ("b", "d"), ("d", "e"), ("f", "c"), ("f", "g"), ("h", "f"), ] ) # Add layer attribute for multipartite_layout for layer, nodes in enumerate(nx.topological_generations(G)): for node in nodes: G.nodes[node]["layer"] = layer # Compute the multipartite_layout using the "layer" node attribute pos = nx.multipartite_layout(G, subset_key="layer") # Draw the graph fig, ax = plt.subplots() nx.draw_networkx(G, pos=pos, ax=ax) ax.set_title("DAG layout in topological order") fig.tight_layout() st.pyplot(fig) elif graph_mode == "Create Your Own": st.write("### Custom DAG Creation") # Allow the user to input the number of nodes num_nodes = st.number_input("Enter the number of nodes", min_value=2, value=5) # Create node names based on the number of nodes nodes = [str(i) for i in range(num_nodes)] st.write(f"### Nodes: {nodes}") st.write("#### Add Edges between Nodes") # Allow the user to select pairs of nodes to add edges edges = [] for i in range(num_nodes): for j in range(i + 1, num_nodes): edge = (nodes[i], nodes[j]) if st.checkbox(f"Add edge from {edge[0]} to {edge[1]}", value=False): edges.append(edge) # Create the custom DAG G_custom = nx.DiGraph() G_custom.add_edges_from(edges) # Add layer attribute for multipartite_layout for layer, nodes in enumerate(nx.topological_generations(G_custom)): for node in nodes: G_custom.nodes[node]["layer"] = layer # Compute the multipartite_layout using the "layer" node attribute pos_custom = nx.multipartite_layout(G_custom, subset_key="layer") # Draw the custom DAG fig_custom, ax_custom = plt.subplots() nx.draw_networkx(G_custom, pos=pos_custom, ax=ax_custom) ax_custom.set_title("Custom DAG layout in topological order") fig_custom.tight_layout() st.pyplot(fig_custom) # Display the corresponding page based on sidebar option if sidebar_option == "Graph: DAG - Topological Layout": dag_topological_layout() if sidebar_option == "3D Drawing: Animations of 3D Rotation": st.title("3D Drawing: Animations of 3D Rotation") # Provide options for Default Example or Custom Graph graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows a dodecahedral graph, or you can create your own custom graph." ) # Define the function to create animation def generate_animation(G, pos, frames=100): nodes = np.array([pos[v] for v in G]) edges = np.array([(pos[u], pos[v]) for u, v in G.edges()]) fig = plt.figure() ax = fig.add_subplot(111, projection="3d") def init(): ax.scatter(*nodes.T, alpha=0.2, s=100, color="blue") for vizedge in edges: ax.plot(*vizedge.T, color="gray") ax.grid(False) ax.set_axis_off() plt.tight_layout() return def _frame_update(index): ax.view_init(index * 0.2, index * 0.5) return ani = animation.FuncAnimation( fig, _frame_update, init_func=init, interval=50, cache_frame_data=False, frames=frames, ) return ani # Default Example if graph_mode == "Default Example": G = nx.dodecahedral_graph() pos = nx.spectral_layout(G, dim=3) ani = generate_animation(G, pos) # Create Your Own Example else: st.write("### Customize Your Graph") num_nodes = st.slider("Number of Nodes", min_value=5, max_value=50, value=20) edge_prob = st.slider("Edge Probability", min_value=0.1, max_value=1.0, value=0.3) # Generate custom graph G = nx.erdos_renyi_graph(num_nodes, edge_prob) pos = nx.spectral_layout(G, dim=3) ani = generate_animation(G, pos) # Display animation in Streamlit with st.spinner("Rendering animation..."): ani.save("animation.gif", writer="imagemagick") st.image("animation.gif", caption="3D Graph Rotation", use_container_width=True) # Default example code def default_example(): G = nx.cycle_graph(20) # 3d spring layout pos = nx.spring_layout(G, dim=3, seed=779) # Extract node and edge positions from the layout node_xyz = np.array([pos[v] for v in sorted(G)]) edge_xyz = np.array([(pos[u], pos[v]) for u, v in G.edges()]) # Create the 3D figure fig = plt.figure() ax = fig.add_subplot(111, projection="3d") # Plot the nodes - alpha is scaled by "depth" automatically ax.scatter(*node_xyz.T, s=100, ec="w") # Plot the edges for vizedge in edge_xyz: ax.plot(*vizedge.T, color="tab:gray") def _format_axes(ax): """Visualization options for the 3D axes.""" # Turn gridlines off ax.grid(False) # Suppress tick labels for dim in (ax.xaxis, ax.yaxis, ax.zaxis): dim.set_ticks([]) # Set axes labels ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("z") _format_axes(ax) fig.tight_layout() st.pyplot(fig) # Create your own graph option def create_own_graph(): # Input fields to customize the graph nodes = st.number_input("Number of nodes", min_value=2, max_value=50, value=20) seed = st.number_input("Seed for layout", value=779) # Add a button to generate the graph generate_button = st.button("Generate Graph") if generate_button: # Generate graph and layout G = nx.cycle_graph(nodes) pos = nx.spring_layout(G, dim=3, seed=seed) # Extract node and edge positions node_xyz = np.array([pos[v] for v in sorted(G)]) edge_xyz = np.array([(pos[u], pos[v]) for u, v in G.edges()]) # Create the 3D figure fig = plt.figure() ax = fig.add_subplot(111, projection="3d") # Plot the nodes ax.scatter(*node_xyz.T, s=100, ec="w") # Plot the edges for vizedge in edge_xyz: ax.plot(*vizedge.T, color="tab:gray") def _format_axes(ax): """Visualization options for the 3D axes.""" ax.grid(False) for dim in (ax.xaxis, ax.yaxis, ax.zaxis): dim.set_ticks([]) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("z") _format_axes(ax) fig.tight_layout() st.pyplot(fig) if sidebar_option == "3D Drawing: Basic Matplotlib": st.title("3D Drawing: Basic Matplotlib") # Provide options for Default Example or Custom Graph graph_mode = st.radio( "Choose a Mode:", ("Default Example", "Create Your Own"), help="Default example shows a cycle graph, or you can create your own custom graph." ) # Display the chosen option if graph_mode == "Default Example": default_example() elif graph_mode == "Create Your Own": create_own_graph() # Function to display Weighted Graph def display_weighted_graph(): st.title("Drawing: Weighted Graph") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Default weighted graph example G = nx.Graph() G.add_edge("a", "b", weight=0.6) G.add_edge("a", "c", weight=0.2) G.add_edge("c", "d", weight=0.1) G.add_edge("c", "e", weight=0.7) G.add_edge("c", "f", weight=0.9) G.add_edge("a", "d", weight=0.3) elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] > 0.5] esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d["weight"] <= 0.5] pos = nx.spring_layout(G, seed=7) # positions for all nodes - seed for reproducibility # nodes nx.draw_networkx_nodes(G, pos, node_size=700) # edges nx.draw_networkx_edges(G, pos, edgelist=elarge, width=6) nx.draw_networkx_edges( G, pos, edgelist=esmall, width=6, alpha=0.5, edge_color="b", style="dashed" ) # node labels nx.draw_networkx_labels(G, pos, font_size=20, font_family="sans-serif") # edge weight labels edge_labels = nx.get_edge_attributes(G, "weight") nx.draw_networkx_edge_labels(G, pos, edge_labels) ax = plt.gca() ax.margins(0.08) plt.axis("off") plt.tight_layout() st.pyplot(plt) elif option == "Create your own": # User can create their own graph with edges and weights edge_input = st.text_area( "Enter edges with weights (format: node1,node2,weight;node1,node2,weight;...)", "a,b,0.6;a,c,0.2;c,d,0.1;c,e,0.7;c,f,0.9;a,d,0.3" ) # Parse the input string edges = edge_input.split(";") edge_list = [] for edge in edges: node1, node2, weight = edge.split(",") edge_list.append((node1.strip(), node2.strip(), float(weight.strip()))) # Add a button to generate the graph generate_button = st.button("Generate Graph") if generate_button: G_custom = nx.Graph() # Add edges to the graph for node1, node2, weight in edge_list: G_custom.add_edge(node1, node2, weight=weight) # Create layout for visualization pos = nx.spring_layout(G_custom, seed=7) # Determine edges based on weight elarge = [(u, v) for (u, v, d) in G_custom.edges(data=True) if d["weight"] > 0.5] esmall = [(u, v) for (u, v, d) in G_custom.edges(data=True) if d["weight"] <= 0.5] # Draw the graph nx.draw_networkx_nodes(G_custom, pos, node_size=700) nx.draw_networkx_edges(G_custom, pos, edgelist=elarge, width=6) nx.draw_networkx_edges( G_custom, pos, edgelist=esmall, width=6, alpha=0.5, edge_color="b", style="dashed" ) nx.draw_networkx_labels(G_custom, pos, font_size=20, font_family="sans-serif") edge_labels = nx.get_edge_attributes(G_custom, "weight") nx.draw_networkx_edge_labels(G_custom, pos, edge_labels) ax = plt.gca() ax.margins(0.08) plt.axis("off") plt.tight_layout() st.pyplot(plt) # Display Drawing: Weighted Graph if selected if sidebar_option == "Drawing: Weighted Graph": display_weighted_graph() from networkx.algorithms.approximation import christofides # Function to display Traveling Salesman Problem def display_tsp(): st.title("Drawing: Traveling Salesman Problem") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Default example of random geometric graph with TSP solution G = nx.random_geometric_graph(20, radius=0.4, seed=3) pos = nx.get_node_attributes(G, "pos") # Depot should be at (0.5, 0.5) pos[0] = (0.5, 0.5) H = G.copy() # Calculating the distances between the nodes as edge's weight. for i in range(len(pos)): for j in range(i + 1, len(pos)): dist = math.hypot(pos[i][0] - pos[j][0], pos[i][1] - pos[j][1]) dist = dist G.add_edge(i, j, weight=dist) # Find TSP cycle using Christofides' approximation cycle = christofides(G, weight="weight") edge_list = list(nx.utils.pairwise(cycle)) # Draw closest edges on each node only nx.draw_networkx_edges(H, pos, edge_color="blue", width=0.5) # Draw the route nx.draw_networkx( G, pos, with_labels=True, edgelist=edge_list, edge_color="red", node_size=200, width=3, ) st.pyplot(plt) st.write("The route of the traveler is:", cycle) elif option == "Create your own": # User can create their own graph num_nodes = st.slider("Number of nodes:", min_value=3, max_value=30, value=20) radius = st.slider("Edge radius:", min_value=0.1, max_value=1.0, value=0.4) # Add a button to generate a new graph generate_button = st.button("Generate Graph") if generate_button: # Create random geometric graph based on user input G_custom = nx.random_geometric_graph(num_nodes, radius, seed=3) pos = nx.get_node_attributes(G_custom, "pos") # Depot should be at (0.5, 0.5) pos[0] = (0.5, 0.5) H = G_custom.copy() # Calculating the distances between the nodes as edge's weight. for i in range(len(pos)): for j in range(i + 1, len(pos)): dist = math.hypot(pos[i][0] - pos[j][0], pos[i][1] - pos[j][1]) dist = dist G_custom.add_edge(i, j, weight=dist) # Find TSP cycle using Christofides' approximation cycle = christofides(G_custom, weight="weight") edge_list = list(nx.utils.pairwise(cycle)) # Draw closest edges on each node only nx.draw_networkx_edges(H, pos, edge_color="blue", width=0.5) # Draw the TSP route nx.draw_networkx( G_custom, pos, with_labels=True, edgelist=edge_list, edge_color="red", node_size=200, width=3, ) st.pyplot(plt) st.write("The route of the traveler is:", cycle) # Display Drawing: Traveling Salesman Problem if selected if sidebar_option == "Drawing: Traveling Salesman Problem": display_tsp() # Function to display Drawing: Spectral Embedding def display_spectral_embedding(): st.title("Drawing: Spectral Embedding") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Default example of spectral embedding with a grid graph options = {"node_color": "C0", "node_size": 100} # No labels G = nx.grid_2d_graph(6, 6) fig, axs = plt.subplots(3, 3, figsize=(12, 12)) axs = axs.flatten() for i in range(7): # Looping over 7 images if i == 0: nx.draw_spectral(G, **options, ax=axs[i]) elif i == 1: G.remove_edge((2, 2), (2, 3)) nx.draw_spectral(G, **options, ax=axs[i]) elif i == 2: G.remove_edge((3, 2), (3, 3)) nx.draw_spectral(G, **options, ax=axs[i]) elif i == 3: G.remove_edge((2, 2), (3, 2)) nx.draw_spectral(G, **options, ax=axs[i]) elif i == 4: G.remove_edge((2, 3), (3, 3)) nx.draw_spectral(G, **options, ax=axs[i]) elif i == 5: G.remove_edge((1, 2), (1, 3)) nx.draw_spectral(G, **options, ax=axs[i]) elif i == 6: G.remove_edge((4, 2), (4, 3)) nx.draw_spectral(G, **options, ax=axs[i]) # Hide the last two subplots (8th and 9th) for j in range(7, 9): fig.delaxes(axs[j]) # Delete the extra axes st.pyplot(fig) elif option == "Create your own": # User can interactively modify the grid and see the results grid_size = st.slider("Choose grid size (n x n):", min_value=3, max_value=10, value=6) G_custom = nx.grid_2d_graph(grid_size, grid_size) # List all edges to allow removal all_edges = list(G_custom.edges()) # Collect user input for edges to remove (before showing the "Generate" button) selected_edges_per_graph = [] for i in range(7): # Loop over 7 graphs selected_edges = st.multiselect(f"Select edges to remove for graph {i+1}:", options=[str(edge) for edge in all_edges]) selected_edges_per_graph.append(selected_edges) # Add "Generate" button after edge selection generate_button = st.button("Generate Graph") if generate_button: fig, axs = plt.subplots(3, 3, figsize=(12, 12)) axs = axs.flatten() # Loop through each subplot and allow edge removal individually for i in range(7): # Loop over 7 graphs edges_to_remove = [tuple(eval(edge)) for edge in selected_edges_per_graph[i]] # Remove the selected edges G_custom_copy = G_custom.copy() G_custom_copy.remove_edges_from(edges_to_remove) # Draw the graph with removed edges nx.draw_spectral(G_custom_copy, **{"node_color": "C0", "node_size": 100}, ax=axs[i]) # Hide the last two subplots (8th and 9th) for j in range(7, 9): fig.delaxes(axs[j]) # Delete the extra axes st.pyplot(fig) # Display Drawing: Spectral Embedding if selected if sidebar_option == "Drawing: Spectral Embedding": display_spectral_embedding() # Function to display Drawing: Simple Path def display_simple_path(): st.title("Drawing: Simple Path") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Default example of a simple path graph G = nx.path_graph(8) pos = nx.spring_layout(G, seed=47) # Seed layout for reproducibility # Draw the graph nx.draw(G, pos=pos) st.pyplot(plt) elif option == "Create your own": # User can create their own path graph with a custom number of nodes num_nodes = st.number_input("Number of nodes in the path:", min_value=2, max_value=50, value=8) if st.button("Generate Graph"): # Generate a path graph with user-specified number of nodes G_custom = nx.path_graph(num_nodes) pos = nx.spring_layout(G_custom, seed=47) # Seed layout for reproducibility # Draw the graph nx.draw(G_custom, pos=pos) st.pyplot(plt) # Display Drawing: Simple Path if selected if sidebar_option == "Drawing: Simple Path": display_simple_path() # Function to display Drawing: Self-loops def display_self_loops(): st.title("Drawing: Self-loops") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Default example of a graph with self-loops G = nx.complete_graph(3, create_using=nx.DiGraph) G.add_edge(0, 0) # Add a self-loop to node 0 pos = nx.circular_layout(G) # Draw the graph nx.draw(G, pos, with_labels=True) # Add self-loops to the remaining nodes edgelist = [(1, 1), (2, 2)] G.add_edges_from(edgelist) # Draw the newly added self-loops with different formatting nx.draw_networkx_edges(G, pos, edgelist=edgelist, arrowstyle="<|-", style="dashed") st.pyplot(plt) elif option == "Create your own": # User can create their own graph with self-loops num_nodes = st.number_input("Number of nodes:", min_value=2, max_value=20, value=3) add_self_loops = st.checkbox("Add self-loops to all nodes?", value=True) if st.button("Generate Graph"): # Generate a complete graph G = nx.complete_graph(num_nodes, create_using=nx.DiGraph) # Optionally add self-loops to all nodes if add_self_loops: for node in G.nodes(): G.add_edge(node, node) pos = nx.circular_layout(G) # Draw the graph with self-loops nx.draw(G, pos, with_labels=True) # Style self-loops differently edgelist = [(node, node) for node in G.nodes()] nx.draw_networkx_edges(G, pos, edgelist=edgelist, arrowstyle="<|-", style="dashed") st.pyplot(plt) # Display Drawing: Self-loops if selected if sidebar_option == "Drawing: Self-loops": display_self_loops() # Function to display Drawing: Random Geometric Graph def display_random_geometric_graph(): st.title("Drawing: Random Geometric Graph") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Default random geometric graph example G = nx.random_geometric_graph(200, 0.125, seed=896803) pos = nx.get_node_attributes(G, "pos") # Find node near the center (0.5, 0.5) dmin = 1 ncenter = 0 for n in pos: x, y = pos[n] d = (x - 0.5) ** 2 + (y - 0.5) ** 2 if d < dmin: ncenter = n dmin = d # Color by path length from node near center p = dict(nx.single_source_shortest_path_length(G, ncenter)) plt.figure(figsize=(8, 8)) nx.draw_networkx_edges(G, pos, alpha=0.4) nx.draw_networkx_nodes( G, pos, nodelist=list(p.keys()), node_size=80, node_color=list(p.values()), cmap=plt.cm.Reds_r, ) plt.xlim(-0.05, 1.05) plt.ylim(-0.05, 1.05) plt.axis("off") st.pyplot(plt) elif option == "Create your own": # User can create their own random geometric graph num_nodes = st.number_input("Number of nodes:", min_value=2, max_value=500, value=200) distance = st.slider("Edge distance threshold (between 0 and 1):", 0.01, 1.0, 0.125) if st.button("Generate Graph"): # Generate the graph with user input G = nx.random_geometric_graph(num_nodes, distance, seed=896803) pos = nx.get_node_attributes(G, "pos") # Find node near the center (0.5, 0.5) dmin = 1 ncenter = 0 for n in pos: x, y = pos[n] d = (x - 0.5) ** 2 + (y - 0.5) ** 2 if d < dmin: ncenter = n dmin = d # Color by path length from node near center p = dict(nx.single_source_shortest_path_length(G, ncenter)) plt.figure(figsize=(8, 8)) nx.draw_networkx_edges(G, pos, alpha=0.4) nx.draw_networkx_nodes( G, pos, nodelist=list(p.keys()), node_size=80, node_color=list(p.values()), cmap=plt.cm.Reds_r, ) plt.xlim(-0.05, 1.05) plt.ylim(-0.05, 1.05) plt.axis("off") st.pyplot(plt) # Display Drawing: Random Geometric Graph if selected if sidebar_option == "Drawing: Random Geometric Graph": display_random_geometric_graph() # Function to display Drawing: Rainbow Coloring def display_rainbow_coloring(): st.title("Drawing: Rainbow Coloring") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Rainbow Coloring with default parameters node_dist_to_color = { 1: "tab:red", 2: "tab:orange", 3: "tab:olive", 4: "tab:green", 5: "tab:blue", 6: "tab:purple", } nnodes = 13 G = nx.complete_graph(nnodes) n = (nnodes - 1) // 2 ndist_iter = list(range(1, n + 1)) ndist_iter += ndist_iter[::-1] def cycle(nlist, n): return nlist[-n:] + nlist[:-n] nodes = list(G.nodes()) for i, nd in enumerate(ndist_iter): for u, v in zip(nodes, cycle(nodes, i + 1)): G[u][v]["color"] = node_dist_to_color[nd] pos = nx.circular_layout(G) # Create a figure with 1:1 aspect ratio to preserve the circle. fig, ax = plt.subplots(figsize=(8, 8)) node_opts = {"node_size": 500, "node_color": "w", "edgecolors": "k", "linewidths": 2.0} nx.draw_networkx_nodes(G, pos, **node_opts) nx.draw_networkx_labels(G, pos, font_size=14) # Extract color from edge data edge_colors = [edgedata["color"] for _, _, edgedata in G.edges(data=True)] nx.draw_networkx_edges(G, pos, width=2.0, edge_color=edge_colors) ax.set_axis_off() fig.tight_layout() st.pyplot(plt) elif option == "Create your own": nnodes = st.number_input("Number of nodes (max=14):", min_value=2, max_value=50, value=13) # Allow users to create their own color map red = st.color_picker("Select a color for Red (1)", "#ff0000") orange = st.color_picker("Select a color for Orange (2)", "#ff7f00") olive = st.color_picker("Select a color for Olive (3)", "#808000") green = st.color_picker("Select a color for Green (4)", "#008000") blue = st.color_picker("Select a color for Blue (5)", "#0000ff") purple = st.color_picker("Select a color for Purple (6)", "#800080") node_dist_to_color = { 1: red, 2: orange, 3: olive, 4: green, 5: blue, 6: purple, } if st.button("Generate Graph"): G = nx.complete_graph(nnodes) n = (nnodes - 1) // 2 ndist_iter = list(range(1, n + 1)) ndist_iter += ndist_iter[::-1] def cycle(nlist, n): return nlist[-n:] + nlist[:-n] nodes = list(G.nodes()) for i, nd in enumerate(ndist_iter): for u, v in zip(nodes, cycle(nodes, i + 1)): G[u][v]["color"] = node_dist_to_color[nd] pos = nx.circular_layout(G) # Create a figure with 1:1 aspect ratio to preserve the circle. fig, ax = plt.subplots(figsize=(8, 8)) node_opts = {"node_size": 500, "node_color": "w", "edgecolors": "k", "linewidths": 2.0} nx.draw_networkx_nodes(G, pos, **node_opts) nx.draw_networkx_labels(G, pos, font_size=14) # Extract color from edge data edge_colors = [edgedata["color"] for _, _, edgedata in G.edges(data=True)] nx.draw_networkx_edges(G, pos, width=2.0, edge_color=edge_colors) ax.set_axis_off() fig.tight_layout() st.pyplot(plt) # Display Drawing: Rainbow Coloring if selected if sidebar_option == "Drawing: Rainbow Coloring": display_rainbow_coloring() # Function to display Drawing: Node Colormap def display_node_colormap(): st.title("Drawing: Node Colormap") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": G = nx.cycle_graph(24) pos = nx.circular_layout(G) nx.draw(G, pos, node_color=range(24), node_size=800, cmap=plt.cm.Blues) st.pyplot(plt) elif option == "Create your own": num_nodes = st.number_input("Number of nodes:", min_value=2, max_value=100, value=24) color_map = st.selectbox("Select a colormap:", plt.colormaps(), index=plt.colormaps().index('Blues')) if st.button("Generate Graph"): # Create cycle graph with custom number of nodes G_custom = nx.cycle_graph(num_nodes) pos = nx.circular_layout(G_custom) nx.draw(G_custom, pos, node_color=range(num_nodes), node_size=800, cmap=plt.get_cmap(color_map)) st.pyplot(plt) # Display Drawing: Node Colormap if selected if sidebar_option == "Drawing: Node Colormap": display_node_colormap() # Function to create a multipartite graph def multilayered_graph(*subset_sizes): G = nx.Graph() layers = len(subset_sizes) node_id = 0 # Create nodes for each subset and add edges between nodes in adjacent layers for i, size in enumerate(subset_sizes): for j in range(size): G.add_node(node_id, layer=i) # Assign a layer attribute node_id += 1 # Add edges between nodes in adjacent layers node_ids = list(G.nodes()) for i in range(layers - 1): layer_nodes = [node for node in node_ids if G.nodes[node]["layer"] == i] next_layer_nodes = [node for node in node_ids if G.nodes[node]["layer"] == i + 1] for node in layer_nodes: for next_node in next_layer_nodes: G.add_edge(node, next_node) return G # Function to display Multipartite Layout def display_multipartite_layout(): st.title("Drawing: Multipartite Layout") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": subset_sizes = [5, 5, 4, 3, 2, 4, 4, 3] subset_color = [ "gold", "violet", "violet", "violet", "violet", "limegreen", "limegreen", "darkorange" ] # Generate and plot multipartite graph G = multilayered_graph(*subset_sizes) color = [subset_color[data["layer"]] for v, data in G.nodes(data=True)] pos = nx.multipartite_layout(G, subset_key="layer") plt.figure(figsize=(8, 8)) nx.draw(G, pos, node_color=color, with_labels=False) plt.axis("equal") st.pyplot(plt) elif option == "Create your own": # Let the user input the subset sizes and colors st.write("Enter the subset sizes and colors to create your own multipartite graph.") subset_sizes_input = st.text_area("Enter subset sizes (comma-separated, e.g., 5,5,4,3):", value="5,5,4,3,2,4,4,3") subset_sizes = list(map(int, subset_sizes_input.split(','))) subset_colors_input = st.text_area("Enter subset colors (comma-separated, e.g., gold,violet,green):", value="gold,violet,violet,violet,violet,limegreen,limegreen,darkorange") subset_colors = subset_colors_input.split(',') # Check if the number of colors matches the number of subsets if len(subset_sizes) != len(subset_colors): st.error("The number of colors should match the number of subsets.") else: # Add a button to generate the graph if st.button("Generate Graph"): # Generate and plot multipartite graph G = multilayered_graph(*subset_sizes) color = [subset_colors[data["layer"]] for v, data in G.nodes(data=True)] pos = nx.multipartite_layout(G, subset_key="layer") plt.figure(figsize=(8, 8)) nx.draw(G, pos, node_color=color, with_labels=False) plt.axis("equal") st.pyplot(plt) # Display Drawing: Multipartite Layout if selected if sidebar_option == "Drawing: Multipartite Layout": display_multipartite_layout() # Function to display Labels and Colors def display_labels_and_colors(): st.title("Drawing: Labels And Colors") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Create a cubical graph G = nx.cubical_graph() pos = nx.spring_layout(G, seed=3113794652) # positions for all nodes # Draw nodes with different colors options = {"edgecolors": "tab:gray", "node_size": 800, "alpha": 0.9} nx.draw_networkx_nodes(G, pos, nodelist=[0, 1, 2, 3], node_color="tab:red", **options) nx.draw_networkx_nodes(G, pos, nodelist=[4, 5, 6, 7], node_color="tab:blue", **options) # Draw edges nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5) nx.draw_networkx_edges( G, pos, edgelist=[(0, 1), (1, 2), (2, 3), (3, 0)], width=8, alpha=0.5, edge_color="tab:red", ) nx.draw_networkx_edges( G, pos, edgelist=[(4, 5), (5, 6), (6, 7), (7, 4)], width=8, alpha=0.5, edge_color="tab:blue", ) # Add labels for nodes labels = {0: r"$a$", 1: r"$b$", 2: r"$c$", 3: r"$d$", 4: r"$\alpha$", 5: r"$\beta$", 6: r"$\gamma$", 7: r"$\delta$"} nx.draw_networkx_labels(G, pos, labels, font_size=22, font_color="whitesmoke") plt.tight_layout() plt.axis("off") st.pyplot(plt) elif option == "Create your own": # Let the user input the nodes and edges of the graph st.write("Enter the nodes and edges to create your own labeled graph.") nodes = st.text_area("Enter node labels (comma-separated, e.g., a,b,c,d):", value="a,b,c,d") node_labels = nodes.split(',') edges = st.text_area("Enter edges (format: node1-node2, comma-separated, e.g., a-b,b-c):", value="a-b,b-c,c-d") edge_list = [tuple(edge.split('-')) for edge in edges.split(',')] # Let user choose colors for nodes and edges node_color = st.color_picker("Pick a color for nodes:", "#FF6347") edge_color = st.color_picker("Pick a color for edges:", "#4682B4") # Add a button to generate the graph if st.button("Generate Graph"): # Generate graph based on user input G_custom = nx.Graph() G_custom.add_nodes_from(node_labels) G_custom.add_edges_from(edge_list) # Generate layout for the nodes pos_custom = nx.spring_layout(G_custom) # Draw the graph nx.draw_networkx_nodes(G_custom, pos_custom, node_color=node_color, node_size=800, edgecolors="gray", alpha=0.9) nx.draw_networkx_edges(G_custom, pos_custom, edge_color=edge_color, width=2, alpha=0.7) # Create custom labels custom_labels = {node: f"${node}$" for node in node_labels} nx.draw_networkx_labels(G_custom, pos_custom, labels=custom_labels, font_size=22, font_color="whitesmoke") plt.tight_layout() plt.axis("off") st.pyplot(plt) # Display Drawing: Labels And Colors if selected if sidebar_option == "Drawing: Labels And Colors": display_labels_and_colors() # Function to display Drawing: House With Colors def display_house_with_colors(): st.title("Drawing: House With Colors") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Create the house graph and explicitly set positions G = nx.house_graph() pos = {0: (0, 0), 1: (1, 0), 2: (0, 1), 3: (1, 1), 4: (0.5, 2.0)} # Plot nodes with different properties for the "wall" and "roof" nodes nx.draw_networkx_nodes(G, pos, node_size=3000, nodelist=[0, 1, 2, 3], node_color="tab:blue") nx.draw_networkx_nodes(G, pos, node_size=2000, nodelist=[4], node_color="tab:orange") nx.draw_networkx_edges(G, pos, alpha=0.5, width=6) # Customize axes ax = plt.gca() ax.margins(0.11) plt.tight_layout() plt.axis("off") st.pyplot(plt) elif option == "Create your own": # Allow the user to specify node positions and colors st.write("Specify positions for the house graph nodes.") positions = {} for i in range(5): x = st.number_input(f"X-coordinate for node {i}:", min_value=-10.0, max_value=10.0, value=0.0, step=0.1) y = st.number_input(f"Y-coordinate for node {i}:", min_value=-10.0, max_value=10.0, value=0.0, step=0.1) positions[i] = (x, y) # Allow the user to specify colors for wall and roof nodes wall_color = st.color_picker("Wall color:", "#0000FF") roof_color = st.color_picker("Roof color:", "#FFA500") if st.button("Generate"): # Create the house graph with the specified positions G_custom = nx.house_graph() # Plot nodes with user-defined properties for wall and roof nodes nx.draw_networkx_nodes(G_custom, positions, node_size=3000, nodelist=[0, 1, 2, 3], node_color=wall_color) nx.draw_networkx_nodes(G_custom, positions, node_size=2000, nodelist=[4], node_color=roof_color) nx.draw_networkx_edges(G_custom, positions, alpha=0.5, width=6) # Customize axes ax = plt.gca() ax.margins(0.11) plt.tight_layout() plt.axis("off") st.pyplot(plt) # Display Drawing: House With Colors if selected if sidebar_option == "Drawing: House With Colors": display_house_with_colors() # Function to display Four Grids visualization for Drawing: Four Grids def display_four_grids(): st.title("Drawing: Four Grids") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Generate a 4x4 grid graph G = nx.grid_2d_graph(4, 4) # 4x4 grid pos = nx.spring_layout(G, iterations=100, seed=39775) # Create a 2x2 subplot fig, all_axes = plt.subplots(2, 2) ax = all_axes.flat # Draw graphs in 4 different styles nx.draw(G, pos, ax=ax[0], font_size=8) nx.draw(G, pos, ax=ax[1], node_size=0, with_labels=False) nx.draw( G, pos, ax=ax[2], node_color="tab:green", edgecolors="tab:gray", # Node surface color edge_color="tab:gray", # Color of graph edges node_size=250, with_labels=False, width=6, ) H = G.to_directed() nx.draw( H, pos, ax=ax[3], node_color="tab:orange", node_size=20, with_labels=False, arrowsize=10, width=2, ) # Set margins for the axes so that nodes aren't clipped for a in ax: a.margins(0.10) fig.tight_layout() st.pyplot(fig) elif option == "Create your own": # Allow the user to customize the grid dimensions rows = st.number_input("Number of rows:", min_value=2, max_value=20, value=4) cols = st.number_input("Number of columns:", min_value=2, max_value=20, value=4) if st.button("Generate"): # Generate a custom grid graph G_custom = nx.grid_2d_graph(rows, cols) # Create the grid graph pos = nx.spring_layout(G_custom, iterations=100, seed=39775) # Create a 2x2 subplot fig, all_axes = plt.subplots(2, 2) ax = all_axes.flat # Draw graphs in 4 different styles nx.draw(G_custom, pos, ax=ax[0], font_size=8) nx.draw(G_custom, pos, ax=ax[1], node_size=0, with_labels=False) nx.draw( G_custom, pos, ax=ax[2], node_color="tab:green", edgecolors="tab:gray", # Node surface color edge_color="tab:gray", # Color of graph edges node_size=250, with_labels=False, width=6, ) H = G_custom.to_directed() nx.draw( H, pos, ax=ax[3], node_color="tab:orange", node_size=20, with_labels=False, arrowsize=10, width=2, ) # Set margins for the axes so that nodes aren't clipped for a in ax: a.margins(0.10) fig.tight_layout() st.pyplot(fig) # Display Drawing: Four Grids if selected if sidebar_option == "Drawing: Four Grids": display_four_grids() # Function to display Eigenvalue analysis for Drawing: Eigenvalues def display_eigenvalue_analysis(): st.title("Drawing: Eigenvalues") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Generate random graph with 1000 nodes and 5000 edges n = 1000 m = 5000 G = nx.gnm_random_graph(n, m, seed=5040) # Seed for reproducibility # Calculate the normalized Laplacian matrix L = nx.normalized_laplacian_matrix(G) eigenvalues = np.linalg.eigvals(L.toarray()) # Print largest and smallest eigenvalues st.write(f"Largest eigenvalue: {max(eigenvalues)}") st.write(f"Smallest eigenvalue: {min(eigenvalues)}") # Display the histogram of eigenvalues st.write("### Eigenvalue Histogram") plt.hist(eigenvalues, bins=100) plt.xlim(0, 2) # Eigenvalues between 0 and 2 st.pyplot(plt) elif option == "Create your own": # Allow the user to customize the number of nodes and edges n_nodes = st.number_input("Number of nodes:", min_value=2, max_value=1000, value=100) m_edges = st.number_input("Number of edges:", min_value=1, max_value=n_nodes*(n_nodes-1)//2, value=500) if st.button("Generate"): # Generate a random graph with the custom number of nodes and edges G_custom = nx.gnm_random_graph(n_nodes, m_edges, seed=5040) # Seed for reproducibility # Calculate the normalized Laplacian matrix L = nx.normalized_laplacian_matrix(G_custom) eigenvalues = np.linalg.eigvals(L.toarray()) # Print largest and smallest eigenvalues st.write(f"Largest eigenvalue: {max(eigenvalues)}") st.write(f"Smallest eigenvalue: {min(eigenvalues)}") # Display the histogram of eigenvalues st.write("### Eigenvalue Histogram") plt.hist(eigenvalues, bins=100) plt.xlim(0, 2) # Eigenvalues between 0 and 2 st.pyplot(plt) # Display Drawing: Eigenvalues if selected if sidebar_option == "Drawing: Eigenvalues": display_eigenvalue_analysis() # Function to display properties and graph for Basic: Properties def display_graph_properties(G): pathlengths = [] st.write("### Source vertex {target:length, }") for v in G.nodes(): spl = dict(nx.single_source_shortest_path_length(G, v)) st.write(f"Vertex {v}: {spl}") for p in spl: pathlengths.append(spl[p]) avg_path_length = sum(pathlengths) / len(pathlengths) st.write(f"### Average shortest path length: {avg_path_length}") dist = {} for p in pathlengths: dist[p] = dist.get(p, 0) + 1 st.write("### Length #paths") for d in sorted(dist.keys()): st.write(f"Length {d}: {dist[d]} paths") st.write("### Properties") st.write(f"Radius: {nx.radius(G)}") st.write(f"Diameter: {nx.diameter(G)}") st.write(f"Eccentricity: {nx.eccentricity(G)}") st.write(f"Center: {nx.center(G)}") st.write(f"Periphery: {nx.periphery(G)}") st.write(f"Density: {nx.density(G)}") # Visualize the graph st.write("### Graph Visualization") pos = nx.spring_layout(G, seed=3068) # Seed layout for reproducibility draw_graph(G, pos) # Function to display graph for Basic: Read and write graphs def display_read_write_graph(G): st.write("### Adjacency List:") for line in nx.generate_adjlist(G): st.write(line) # Write the graph's edge list to a file st.write("### Writing Edge List to 'grid.edgelist' file:") nx.write_edgelist(G, path="grid.edgelist", delimiter=":") # Save edge list st.write("Edge list written to 'grid.edgelist'") # Read the graph from the edge list st.write("### Reading Edge List from 'grid.edgelist' file:") H = nx.read_edgelist(path="grid.edgelist", delimiter=":") st.write("Edge list read into graph H") # Visualize the graph st.write("### Graph Visualization:") pos = nx.spring_layout(H, seed=200) # Seed for reproducibility draw_graph(H, pos) # Function to display Simple Graphs for Basic: Simple graph def display_simple_graph(G, pos=None): options = { "font_size": 36, "node_size": 3000, "node_color": "white", "edgecolors": "black", "linewidths": 5, "width": 5, } # Draw the network nx.draw_networkx(G, pos, **options) # Set margins for the axes so that nodes aren't clipped ax = plt.gca() ax.margins(0.20) plt.axis("off") st.pyplot(plt) # Function to display Simple Directed Graphs for Basic: Simple graph Directed def display_simple_directed_graph(G, pos=None): options = { "node_size": 500, "node_color": "lightblue", "arrowsize": 20, "width": 2, "edge_color": "gray", } # Draw the directed graph with the given positions and options nx.draw_networkx(G, pos, **options) # Set margins for the axes so that nodes aren't clipped ax = plt.gca() ax.margins(0.20) plt.axis("off") st.pyplot(plt) # Function to display Custom Node Position Graphs for Drawing: Custom Node Position def display_custom_node_position(): st.title("Drawing: Custom Node Position") # Default example graph (path graph with custom node position) G = nx.path_graph(20) center_node = 5 edge_nodes = set(G) - {center_node} # Ensure the nodes around the circle are evenly distributed pos = nx.circular_layout(G.subgraph(edge_nodes)) pos[center_node] = np.array([0, 0]) # Manually specify node position # Draw the graph draw_graph(G, pos) # Function to display Cluster Layout for Drawing: Cluster Layout def display_cluster_layout(): st.title("Drawing: Cluster Layout") G = nx.davis_southern_women_graph() # Example graph communities = nx.community.greedy_modularity_communities(G) # Compute positions for the node clusters as if they were themselves nodes in a supergraph using a larger scale factor supergraph = nx.cycle_graph(len(communities)) superpos = nx.spring_layout(G, scale=50, seed=429) # Use the "supernode" positions as the center of each node cluster centers = list(superpos.values()) pos = {} for center, comm in zip(centers, communities): pos.update(nx.spring_layout(nx.subgraph(G, comm), center=center, seed=1430)) # Nodes colored by cluster for nodes, clr in zip(communities, ("tab:blue", "tab:orange", "tab:green")): nx.draw_networkx_nodes(G, pos=pos, nodelist=nodes, node_color=clr, node_size=100) nx.draw_networkx_edges(G, pos=pos) plt.tight_layout() st.pyplot(plt) # Function to display Degree Analysis for Drawing: Degree Analysis def display_degree_analysis(): st.title("Drawing: Degree Analysis") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": G = nx.gnp_random_graph(100, 0.02, seed=10374196) degree_sequence = sorted((d for n, d in G.degree()), reverse=True) dmax = max(degree_sequence) fig = plt.figure("Degree of a random graph", figsize=(8, 8)) # Create a gridspec for adding subplots of different sizes axgrid = fig.add_gridspec(5, 4) ax0 = fig.add_subplot(axgrid[0:3, :]) Gcc = G.subgraph(sorted(nx.connected_components(G), key=len, reverse=True)[0]) pos = nx.spring_layout(Gcc, seed=10396953) nx.draw_networkx_nodes(Gcc, pos, ax=ax0, node_size=20) nx.draw_networkx_edges(Gcc, pos, ax=ax0, alpha=0.4) ax0.set_title("Connected components of G") ax0.set_axis_off() ax1 = fig.add_subplot(axgrid[3:, :2]) ax1.plot(degree_sequence, "b-", marker="o") ax1.set_title("Degree Rank Plot") ax1.set_ylabel("Degree") ax1.set_xlabel("Rank") ax2 = fig.add_subplot(axgrid[3:, 2:]) ax2.bar(*np.unique(degree_sequence, return_counts=True)) ax2.set_title("Degree histogram") ax2.set_xlabel("Degree") ax2.set_ylabel("# of Nodes") fig.tight_layout() st.pyplot(fig) elif option == "Create your own": n_nodes = st.number_input("Number of nodes:", min_value=2, max_value=500, value=100) p_edge = st.slider("Edge probability:", min_value=0.0, max_value=1.0, value=0.02) if st.button("Generate"): if n_nodes >= 2: G_custom = nx.gnp_random_graph(n_nodes, p_edge, seed=10374196) degree_sequence = sorted((d for n, d in G_custom.degree()), reverse=True) dmax = max(degree_sequence) fig = plt.figure("Degree of a random graph", figsize=(8, 8)) # Create a gridspec for adding subplots of different sizes axgrid = fig.add_gridspec(5, 4) ax0 = fig.add_subplot(axgrid[0:3, :]) Gcc = G_custom.subgraph(sorted(nx.connected_components(G_custom), key=len, reverse=True)[0]) pos = nx.spring_layout(Gcc, seed=10396953) nx.draw_networkx_nodes(Gcc, pos, ax=ax0, node_size=20) nx.draw_networkx_edges(Gcc, pos, ax=ax0, alpha=0.4) ax0.set_title("Connected components of G") ax0.set_axis_off() ax1 = fig.add_subplot(axgrid[3:, :2]) ax1.plot(degree_sequence, "b-", marker="o") ax1.set_title("Degree Rank Plot") ax1.set_ylabel("Degree") ax1.set_xlabel("Rank") ax2 = fig.add_subplot(axgrid[3:, 2:]) ax2.bar(*np.unique(degree_sequence, return_counts=True)) ax2.set_title("Degree histogram") ax2.set_xlabel("Degree") ax2.set_ylabel("# of Nodes") fig.tight_layout() st.pyplot(fig) # Function to display Ego Graph for Drawing: Ego Graph def display_ego_graph(): st.title("Drawing: Ego Graph") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": # Create a BA model graph - use seed for reproducibility n = 1000 m = 2 seed = 20532 G = nx.barabasi_albert_graph(n, m, seed=seed) # Find node with largest degree node_and_degree = G.degree() (largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1] # Create ego graph of main hub hub_ego = nx.ego_graph(G, largest_hub) # Draw graph pos = nx.spring_layout(hub_ego, seed=seed) # Seed layout for reproducibility nx.draw(hub_ego, pos, node_color="b", node_size=50, with_labels=False) # Draw ego as large and red options = {"node_size": 300, "node_color": "r"} nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], **options) plt.tight_layout() st.pyplot(plt) elif option == "Create your own": n_nodes = st.number_input("Number of nodes:", min_value=2, max_value=1000, value=100) m_edges = st.number_input("Edges per node:", min_value=1, max_value=10, value=2) if st.button("Generate"): if n_nodes >= 2: G_custom = nx.barabasi_albert_graph(n_nodes, m_edges, seed=20532) # Find node with largest degree node_and_degree = G_custom.degree() (largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1] # Create ego graph of main hub hub_ego = nx.ego_graph(G_custom, largest_hub) # Draw graph pos = nx.spring_layout(hub_ego, seed=20532) # Seed layout for reproducibility nx.draw(hub_ego, pos, node_color="b", node_size=50, with_labels=False) # Draw ego as large and red options = {"node_size": 300, "node_color": "r"} nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], **options) plt.tight_layout() st.pyplot(plt) # Display Drawing: Ego Graph if selected if sidebar_option == "Drawing: Ego Graph": display_ego_graph() # Display Basic: Properties if selected elif sidebar_option == "Basic: Properties": st.title("Basic: Properties") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": G = nx.lollipop_graph(4, 6) display_graph_properties(G) elif option == "Create your own": num_nodes = st.number_input("Number of nodes:", min_value=2, max_value=50, value=5) num_edges = st.number_input("Number of edges per group (for lollipop graph):", min_value=1, max_value=10, value=3) if st.button("Generate"): if num_nodes >= 2 and num_edges >= 1: G_custom = nx.lollipop_graph(num_nodes, num_edges) display_graph_properties(G_custom) # Display Basic: Read and write graphs if selected elif sidebar_option == "Basic: Read and write graphs": st.title("Basic: Read and write graphs") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": G = nx.grid_2d_graph(5, 5) display_read_write_graph(G) elif option == "Create your own": rows = st.number_input("Number of rows:", min_value=2, max_value=20, value=5) cols = st.number_input("Number of columns:", min_value=2, max_value=20, value=5) if st.button("Generate"): if rows >= 2 and cols >= 2: G_custom = nx.grid_2d_graph(rows, cols) display_read_write_graph(G_custom) # Display Basic: Simple Graph if selected elif sidebar_option == "Basic: Simple graph": st.title("Basic: Simple graph") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": G = nx.Graph() G.add_edge(1, 2) G.add_edge(1, 3) G.add_edge(1, 5) G.add_edge(2, 3) G.add_edge(3, 4) G.add_edge(4, 5) pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, 0.255), 5: (5, 0.03)} display_simple_graph(G, pos) elif option == "Create your own": edges = [] edge_input = st.text_area("Edges:", value="1,2\n1,3\n2,3") if edge_input: edge_list = edge_input.split("\n") for edge in edge_list: u, v = map(int, edge.split(",")) edges.append((u, v)) if st.button("Generate"): G_custom = nx.Graph() G_custom.add_edges_from(edges) pos = nx.spring_layout(G_custom, seed=42) display_simple_graph(G_custom, pos) # Display Basic: Simple Directed Graph if selected elif sidebar_option == "Basic: Simple graph Directed": st.title("Basic: Simple graph Directed") option = st.radio("Choose a graph type:", ("Default Example", "Create your own")) if option == "Default Example": G = nx.DiGraph([(0, 3), (1, 3), (2, 4), (3, 5), (3, 6), (4, 6), (5, 6)]) left_nodes = [0, 1, 2] middle_nodes = [3, 4] right_nodes = [5, 6] pos = {n: (0, i) for i, n in enumerate(left_nodes)} pos.update({n: (1, i + 0.5) for i, n in enumerate(middle_nodes)}) pos.update({n: (2, i + 0.5) for i, n in enumerate(right_nodes)}) display_simple_directed_graph(G, pos) elif option == "Create your own": edges = [] edge_input = st.text_area("Edges:", value="1,2\n1,3\n2,3") if edge_input: edge_list = edge_input.split("\n") for edge in edge_list: u, v = map(int, edge.split(",")) edges.append((u, v)) if st.button("Generate"): G_custom = nx.DiGraph() G_custom.add_edges_from(edges) pos = nx.spring_layout(G_custom, seed=42) display_simple_directed_graph(G_custom, pos) # Display Drawing: Custom Node Position if selected elif sidebar_option == "Drawing: Custom Node Position": display_custom_node_position() # Display Drawing: Cluster Layout if selected elif sidebar_option == "Drawing: Cluster Layout": display_cluster_layout() # Display Drawing: Degree Analysis if selected elif sidebar_option == "Drawing: Degree Analysis": display_degree_analysis()