Graph Centrality Analyzer: A Python Desktop App for Network Analysis

 

Graph Centrality Analyzer: A Python Desktop App for Network Analysis

In the modern data-driven world, analyzing complex networks has become crucial across multiple fields such as social networks, transportation systems, biological networks, and communication networks. One of the most powerful ways to understand these networks is through graph centrality measures, which help identify the most important nodes within a network. To simplify this process, I developed a Graph Centrality Analyzer desktop app in Python that makes network analysis easy, interactive, and visual.

Why Centrality Analysis Matters

Centrality analysis is a fundamental concept in graph theory. It allows us to understand the influence and importance of individual nodes in a network. Different centrality measures provide unique insights:

• Degree Centrality shows how connected a node is.

• Closeness Centrality identifies nodes that can quickly interact with all others.

• Betweenness Centrality highlights nodes that serve as bridges or critical connectors.

• Eigenvector Centrality finds nodes connected to other highly connected nodes.

By using these measures, analysts can detect influential nodes, potential bottlenecks, or critical points in any network structure.

Features of the Graph Centrality Analyzer

The Graph Centrality Analyzer desktop app is built with Python and designed for ease of use. Here’s what makes it stand out:

1. Interactive GUI – The app has a user-friendly interface where users can input the number of nodes and define edges in the network. No advanced technical knowledge is needed.

2. Comprehensive Centrality Measures – It calculates all major centralities including degree, closeness, betweenness, and eigenvector, providing a holistic view of network dynamics.

3. Visual Graph Representation – Along with numerical results, the app generates a clear visual of the network, allowing users to quickly grasp network structure and relationships.

4. Quick Analysis – The app processes the input efficiently, making it suitable for small to medium-sized networks for academic, professional, or hobbyist purposes.

5. Extensible and Customizable – Built on Python with NetworkX and Matplotlib, it can easily be extended to include directed networks, weighted edges, or additional centrality metrics.

How to Use the App

Using the Graph Centrality Analyzer is simple:

1. Enter the total number of nodes in the network.

2. Define edges by specifying the connections between nodes in a simple format.

3. Click the “Calculate Centrality” button.

4. Instantly view the results for all centrality measures along with a visual representation of the graph.

This simplicity makes it a perfect tool for students learning graph theory, data analysts exploring social networks, or professionals working with networked systems.

Conclusion

The Graph Centrality Analyzer is more than just a tool; it’s a bridge between theoretical network concepts and practical visualization. By combining Python’s powerful libraries with a user-friendly desktop interface, the app makes complex centrality analysis accessible to anyone. Whether for learning, research, or practical applications, this tool helps users uncover the hidden patterns and influential nodes in any network.

# Filename: graph_centrality_analyzer.py

import tkinter as tk

from tkinter import ttk, messagebox

import networkx as nx

import matplotlib.pyplot as plt

# Function to calculate centrality

def calculate_centrality():

    try:

        nodes = int(nodes_entry.get())

        edges_input = edges_text.get("1.0", tk.END).strip().split("\n")

        

        G = nx.Graph()

        G.add_nodes_from(range(1, nodes+1))

        

        for edge in edges_input:

            u, v = map(int, edge.strip().split(','))

            G.add_edge(u, v)

        

        degree_centrality = nx.degree_centrality(G)

        closeness_centrality = nx.closeness_centrality(G)

        betweenness_centrality = nx.betweenness_centrality(G)

        eigenvector_centrality = nx.eigenvector_centrality(G, max_iter=500)

        

        result_text.delete("1.0", tk.END)

        result_text.insert(tk.END, "Degree Centrality:\n")

        result_text.insert(tk.END, f"{degree_centrality}\n\n")

        result_text.insert(tk.END, "Closeness Centrality:\n")

        result_text.insert(tk.END, f"{closeness_centrality}\n\n")

        result_text.insert(tk.END, "Betweenness Centrality:\n")

        result_text.insert(tk.END, f"{betweenness_centrality}\n\n")

        result_text.insert(tk.END, "Eigenvector Centrality:\n")

        result_text.insert(tk.END, f"{eigenvector_centrality}\n\n")

        

        # Draw Graph

        plt.figure(figsize=(6,5))

        nx.draw(G, with_labels=True, node_color='lightblue', edge_color='gray', node_size=800)

        plt.show()

        

    except Exception as e:

        messagebox.showerror("Error", f"Invalid input! Details:\n{e}")

# Tkinter window

root = tk.Tk()

root.title("Graph Centrality Analyzer")

root.geometry("600x700")

# Number of nodes input

tk.Label(root, text="Number of Nodes:").pack(pady=5)

nodes_entry = tk.Entry(root)

nodes_entry.pack(pady=5)

# Edges input

tk.Label(root, text="Edges (one per line, format: u,v):").pack(pady=5)

edges_text = tk.Text(root, height=10)

edges_text.pack(pady=5)

# Calculate button

calc_btn = tk.Button(root, text="Calculate Centrality", command=calculate_centrality)

calc_btn.pack(pady=10)

# Result display

tk.Label(root, text="Centrality Results:").pack(pady=5)

result_text = tk.Text(root, height=20)

result_text.pack(pady=5)

root.mainloop()

https://github.com/gagandeep44489/DiscreteStrucutreAndAlgoApp/blob/main/Graph%20Centrality%20Analyzer.py