import numpy as np

# Einfache Implementierung einer Adjazenzmatrix
nodes = ['A', 'B', 'C', 'D']
n = len(nodes)
# Erstellen einer n x n Matrix mit Nullen
matrix = np.zeros((n, n), dtype=int)

# Indizierung der Knoten
node_indices = {nodes[i]: i for i in range(n)}

# Hinzufügen von Kanten
def add_edge_matrix(matrix, node1, node2, node_indices):
    i = node_indices[node1]
    j = node_indices[node2]
    matrix[i][j] = 1
    matrix[j][i] = 1  # Für ungerichtete Graphen

# Beispielkanten hinzufügen
add_edge_matrix(matrix, 'A', 'B', node_indices)
add_edge_matrix(matrix, 'A', 'C', node_indices)
add_edge_matrix(matrix, 'B', 'C', node_indices)
add_edge_matrix(matrix, 'B', 'D', node_indices)

print("Adjazenzmatrix:")
print(matrix)

import networkx as nx
import matplotlib.pyplot as plt

# Erstellen eines Graphen
G = nx.Graph()
G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')])

# Visualisierung mit verschiedenen Layout-Algorithmen
plt.figure(figsize=(12, 8))

# Spring Layout (kräftebasiert)
plt.subplot(221)
nx.draw(G, pos=nx.spring_layout(G), with_labels=True, node_color='lightblue', 
        node_size=500, font_weight='bold')
plt.title("Spring Layout")

# Circular Layout
plt.subplot(222)
nx.draw(G, pos=nx.circular_layout(G), with_labels=True, node_color='lightgreen', 
        node_size=500, font_weight='bold')
plt.title("Circular Layout")

# Random Layout
plt.subplot(223)
nx.draw(G, pos=nx.random_layout(G), with_labels=True, node_color='lightcoral', 
        node_size=500, font_weight='bold')
plt.title("Random Layout")

# Spectral Layout
plt.subplot(224)
nx.draw(G, pos=nx.spectral_layout(G), with_labels=True, node_color='lightyellow', 
        node_size=500, font_weight='bold')
plt.title("Spectral Layout")

plt.tight_layout()
plt.show()

import networkx as nx

# Erstellen eines Graphen
G = nx.Graph()  # ungerichtet
# G = nx.DiGraph()  # für gerichtete Graphen

# Hinzufügen von Knoten
G.add_node('A', role='source')  # Knoten mit Attributen
G.add_nodes_from(['B', 'C', 'D'])

# Hinzufügen von Kanten
G.add_edge('A', 'B', weight=0.6)  # Kante mit Gewicht
G.add_edges_from([('A', 'C'), ('B', 'C'), ('B', 'D')])

# Grundlegende Informationen
print(f"Knoten: {G.nodes()}")
print(f"Kanten: {G.edges()}")
print(f"Anzahl der Knoten: {G.number_of_nodes()}")
print(f"Anzahl der Kanten: {G.number_of_edges()}")

# Zugriff auf Nachbarn
print(f"Nachbarn von B: {list(G.neighbors('B'))}")

# Zentralitätsmaße
print(f"Betweenness Centrality: {nx.betweenness_centrality(G)}")
print(f"Degree Centrality: {nx.degree_centrality(G)}")

# Kürzeste Pfade
print(f"Kürzester Pfad von A nach D: {nx.shortest_path(G, 'A', 'D')}")
print(f"Alle kürzesten Pfade: {dict(nx.all_pairs_shortest_path(G))}")

import igraph as ig

# Erstellen eines Graphen
g = ig.Graph()
g.add_vertices(4)  # Indizes 0-3 statt Bezeichnern
g.vs["name"] = ["A", "B", "C", "D"]  # Namen zuweisen
g.add_edges([(0, 1), (0, 2), (1, 2), (1, 3)])  # Indizes nutzen

# Visualisierung
visual_style = {}
visual_style["vertex_size"] = 45
visual_style["vertex_label"] = g.vs["name"]
visual_style["edge_width"] = [1, 2, 3, 1]
visual_style["layout"] = g.layout("kk")
visual_style["bbox"] = (300, 300)
visual_style["margin"] = 40

ig.plot(g, **visual_style)

# Eigenschaften berechnen
print(f"Grad: {g.degree()}")
print(f"Durchmesser: {g.diameter()}")
print(f"Clustering-Koeffizient: {g.transitivity_undirected()}")

import networkx as nx
import holoviews as hv
from holoviews import opts
hv.extension('bokeh')

# Graph erstellen
G = nx.karate_club_graph()  # Ein klassischer Beispielgraph

# In HoloViews-Format konvertieren
graph = hv.Graph.from_networkx(G, nx.layout.spring_layout)

# Visualisierung anpassen
graph.opts(
    opts.Graph(width=600, height=400, xaxis=None, yaxis=None,
               edge_line_width=1, node_size=10, node_color='category'))

from collections import deque

def bfs(graph, start):
    """
    Führt eine Breitensuche auf dem Graphen durch, beginnend beim Startknoten.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der Startknoten
    
    Rückgabe:
    Eine Liste mit den besuchten Knoten in der Reihenfolge ihres Besuchs
    """
    # Initialisiere die Datenstrukturen
    visited = set()  # Menge zur Speicherung besuchter Knoten
    queue = deque([start])  # Queue mit dem Startknoten
    visited.add(start)  # Markiere den Startknoten als besucht
    
    # Liste zur Speicherung der Besuchsreihenfolge
    traversal_order = []
    
    # BFS-Algorithmus
    while queue:
        # Entferne den vordersten Knoten aus der Queue
        current_node = queue.popleft()
        traversal_order.append(current_node)
        
        # Füge alle unbesuchten Nachbarn zur Queue hinzu
        for neighbor in graph[current_node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    
    return traversal_order

# Beispielgraph
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# BFS durchführen
bfs_order = bfs(graph, 'A')
print("BFS-Reihenfolge:", bfs_order)

def bfs_shortest_paths(graph, start):
    """
    Berechnet die kürzesten Pfade von einem Startknoten zu allen anderen Knoten
    in einem ungewichteten Graphen mittels BFS.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der Startknoten
    
    Rückgabe:
    distances -- Dictionary mit Distanzen vom Startknoten
    predecessors -- Dictionary mit Vorgängerknoten für die Pfadrekonstruktion
    """
    # Initialisiere die Datenstrukturen
    visited = {start}  # Menge besuchter Knoten
    queue = deque([(start, 0)])  # Queue mit (Knoten, Distanz)
    
    # Distanzen und Vorgänger für die Pfadrekonstruktion
    distances = {start: 0}
    predecessors = {start: None}
    
    while queue:
        current_node, distance = queue.popleft()
        
        for neighbor in graph[current_node]:
            if neighbor not in visited:
                visited.add(neighbor)
                distances[neighbor] = distance + 1
                predecessors[neighbor] = current_node
                queue.append((neighbor, distance + 1))
    
    return distances, predecessors

def reconstruct_path(predecessors, start, end):
    """
    Rekonstruiert den Pfad vom Start- zum Zielknoten anhand der Vorgängerinformationen.
    
    Parameter:
    predecessors -- Dictionary mit Vorgängerknoten
    start -- Startknoten
    end -- Zielknoten
    
    Rückgabe:
    path -- Liste mit dem Pfad vom Start zum Ziel
    """
    if end not in predecessors:
        return None  # Zielknoten ist nicht erreichbar
    
    path = []
    current = end
    
    # Gehe vom Ziel zum Start zurück
    while current != start:
        path.append(current)
        current = predecessors[current]
    
    path.append(start)  # Füge den Startknoten hinzu
    path.reverse()  # Drehe den Pfad um
    
    return path

# Anwendung
distances, predecessors = bfs_shortest_paths(graph, 'A')
print("Distanzen von A:", distances)

# Kürzesten Pfad von A nach F berechnen
path_to_F = reconstruct_path(predecessors, 'A', 'F')
print("Kürzester Pfad von A nach F:", path_to_F)

def dfs_recursive(graph, start, visited=None, traversal_order=None):
    """
    Führt eine rekursive Tiefensuche auf dem Graphen durch.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der aktuelle Knoten
    visited -- Menge bereits besuchter Knoten
    traversal_order -- Liste zur Speicherung der Besuchsreihenfolge
    
    Rückgabe:
    Die Liste mit den besuchten Knoten in DFS-Reihenfolge
    """
    # Initialisiere visited und traversal_order beim ersten Aufruf
    if visited is None:
        visited = set()
    if traversal_order is None:
        traversal_order = []
    
    # Markiere den aktuellen Knoten als besucht
    visited.add(start)
    traversal_order.append(start)
    
    # Rekursiver Aufruf für alle unbesuchten Nachbarn
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs_recursive(graph, neighbor, visited, traversal_order)
    
    return traversal_order

# DFS rekursiv durchführen
dfs_recursive_order = dfs_recursive(graph, 'A')
print("Rekursive DFS-Reihenfolge:", dfs_recursive_order)

def dfs_iterative(graph, start):
    """
    Führt eine iterative Tiefensuche auf dem Graphen durch.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der Startknoten
    
    Rückgabe:
    Eine Liste mit den besuchten Knoten in DFS-Reihenfolge
    """
    # Initialisiere die Datenstrukturen
    visited = set()
    stack = [start]  # Initialisiere den Stack mit dem Startknoten
    traversal_order = []
    
    while stack:
        # Entferne den obersten Knoten vom Stack
        current_node = stack.pop()
        
        # Wenn der Knoten noch nicht besucht wurde
        if current_node not in visited:
            visited.add(current_node)
            traversal_order.append(current_node)
            
            # Füge alle unbesuchten Nachbarn zum Stack hinzu (in umgekehrter Reihenfolge)
            for neighbor in reversed(graph[current_node]):
                if neighbor not in visited:
                    stack.append(neighbor)
    
    return traversal_order

# DFS iterativ durchführen
dfs_iterative_order = dfs_iterative(graph, 'A')
print("Iterative DFS-Reihenfolge:", dfs_iterative_order)

import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from collections import deque

def create_visualization(graph, start, algorithm="bfs"):
    """
    Erstellt eine Animation der Graph-Traversierung.
    
    Parameter:
    graph -- Der Graph als Adjazenzliste
    start -- Der Startknoten
    algorithm -- "bfs" oder "dfs"
    """
    # Erstelle einen NetworkX-Graphen
    G = nx.Graph()
    for node in graph:
        for neighbor in graph[node]:
            G.add_edge(node, neighbor)
    
    # Berechne das Layout (Positionen der Knoten)
    pos = nx.spring_layout(G, seed=42)
    
    # Initialisiere Figure
    fig, ax = plt.subplots(figsize=(10, 8))
    
    # Sammle die Frames für die Animation
    frames = []
    
    if algorithm == "bfs":
        # BFS-Animation
        visited = set([start])
        queue = deque([start])
        
        # Anfangszustand
        node_colors = ['red' if node == start else 'lightblue' for node in G.nodes()]
        edge_colors = ['black' for _ in G.edges()]
        frames.append((node_colors.copy(), edge_colors.copy()))
        
        while queue:
            current = queue.popleft()
            
            for neighbor in graph[current]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append(neighbor)
                    
                    # Aktualisiere Farben
                    node_colors = ['red' if node in visited else 'lightblue' for node in G.nodes()]
                    edge_colors = ['red' if (u, v) == (current, neighbor) or (u, v) == (neighbor, current) 
                                   else 'red' if any((u == node and v in visited and node in visited) or
                                                    (v == node and u in visited and node in visited) 
                                                    for node in visited)
                                   else 'black' 
                                   for u, v in G.edges()]
                    
                    frames.append((node_colors.copy(), edge_colors.copy()))
    
    else:  # DFS
        # DFS-Animation
        visited = set()
        stack = [start]
        
        # Anfangszustand
        node_colors = ['red' if node == start else 'lightblue' for node in G.nodes()]
        edge_colors = ['black' for _ in G.edges()]
        frames.append((node_colors.copy(), edge_colors.copy()))
        
        while stack:
            current = stack.pop()
            
            if current not in visited:
                visited.add(current)
                
                for neighbor in reversed(graph[current]):
                    if neighbor not in visited:
                        stack.append(neighbor)
                
                # Aktualisiere Farben
                node_colors = ['red' if node in visited else 'lightblue' for node in G.nodes()]
                edge_colors = ['red' if any((u == node and v in visited and node in visited) or
                                           (v == node and u in visited and node in visited) 
                                           for node in visited)
                              else 'black' 
                              for u, v in G.edges()]
                
                frames.append((node_colors.copy(), edge_colors.copy()))
    
    # Make sure we have frames before creating animation
    if not frames:
        print(f"Warning: No frames collected for {algorithm} animation!")
        # Add at least one dummy frame to avoid errors
        frames.append((['lightblue' for _ in G.nodes()], ['black' for _ in G.edges()]))
    
    # Erstelle Animation
    def update(frame_idx):
        ax.clear()
        node_colors, edge_colors = frames[frame_idx]
        nx.draw(G, pos, with_labels=True, node_color=node_colors, 
                edge_color=edge_colors, node_size=500, font_weight='bold', ax=ax)
        ax.set_title(f"{algorithm.upper()}-Traversierung (Schritt {frame_idx})")
        return ax
    
    # Use the correct number of frames
    ani = animation.FuncAnimation(fig, update, frames=len(frames), interval=1000)
    return ani

# BFS-Animation erstellen
bfs_animation = create_visualization(graph, 'A', "bfs")
# DFS-Animation erstellen
dfs_animation = create_visualization(graph, 'A', "dfs")

# Animationen speichern (optional)
bfs_animation.save('bfs_animation.gif', writer='pillow')
dfs_animation.save('dfs_animation.gif', writer='pillow')

plt.show()

import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
from collections import Counter
import os
import pickle

# Datei einlesen
print("Lade Superhelden-Netzwerk...")
df = pd.read_csv(os.path.join('data','hero-network.csv'))

# Schneller Überblick über die Daten
print("\nErste paar Zeilen der Datei:")
print(df.head(10))

print("\nInformationen zum DataFrame:")
print(df.info())

# Überprüfen auf doppelte Einträge
duplicate_count = df.duplicated().sum()
print(f"\nAnzahl doppelter Einträge: {duplicate_count}")

if duplicate_count > 0:
    print("Beispiele für doppelte Einträge:")
    print(df[df.duplicated(keep=False)].sort_values(by=['hero1', 'hero2']).head(10))

# Erstelle eine Liste aller eindeutigen Helden
all_heroes = pd.concat([df['hero1'], df['hero2']]).unique()
print(f"\nAnzahl eindeutiger Helden: {len(all_heroes)}")
print(f"Beispiele für Heldennamen: {all_heroes[:5]}")

# Zähle, wie oft jeder Held im Datensatz vorkommt
hero_occurrences = Counter(pd.concat([df['hero1'], df['hero2']]))

# Top 10 Helden nach Häufigkeit anzeigen
print("\nTop 10 Helden nach Anzahl der Verbindungen:")
for hero, count in hero_occurrences.most_common(10):
    print(f"{hero}: {count} Verbindungen")

# Überprüfen, ob es Paare gibt, die mehrfach vorkommen (implizite Gewichtung)
pair_counts = df.groupby(['hero1', 'hero2']).size().reset_index(name='weight')
multi_pairs = pair_counts[pair_counts['weight'] > 1]

print(f"\nAnzahl der Heldenpaare: {len(pair_counts)}")
print(f"Davon mit mehrfachen Verbindungen: {len(multi_pairs)}")

if len(multi_pairs) > 0:
    print("\nBeispiele für Paare mit mehrfachen Verbindungen:")
    print(multi_pairs.sort_values(by='weight', ascending=False).head(10))
    
    # Erstelle eine bereinigte Version mit Gewichten
    print("\nErstelle bereinigte Datenversion mit Gewichten...")
    network_with_weights = pair_counts
else:
    print("\nKeine mehrfachen Verbindungen gefunden, jedes Paar erscheint nur einmal.")
    # Füge eine Gewichtsspalte mit einheitlichem Wert 1 hinzu
    network_with_weights = pair_counts

# Check for self-loops
self_loops = df[df['hero1'] == df['hero2']]
print(f"\nAnzahl der Selbstverbindungen (Helden mit sich selbst verbunden): {len(self_loops)}")

if len(self_loops) > 0:
    print("Beispiele für Selbstverbindungen:")
    print(self_loops.head())
    
    # Filtere Selbstverbindungen aus dem bereinigten DataFrame
    network_with_weights = network_with_weights[network_with_weights['hero1'] != network_with_weights['hero2']]
    print(f"Bereinigte Anzahl der Heldenpaare: {len(network_with_weights)}")

# Erstelle einen NetworkX-Graphen
G = nx.Graph()

# Füge Knoten hinzu (alle eindeutigen Helden)
G.add_nodes_from(all_heroes)

# Füge Kanten mit Gewichten hinzu
for _, row in network_with_weights.iterrows():
    G.add_edge(row['hero1'], row['hero2'], weight=row['weight'])

# Grundlegende Netzwerkstatistiken
print("\nGrundlegende Netzwerkstatistiken:")
print(f"Anzahl der Knoten (Helden): {G.number_of_nodes()}")
print(f"Anzahl der Kanten (Verbindungen): {G.number_of_edges()}")
print(f"Ist das Netzwerk zusammenhängend? {nx.is_connected(G)}")

if not nx.is_connected(G):
    components = list(nx.connected_components(G))
    print(f"Anzahl der Zusammenhangskomponenten: {len(components)}")
    print(f"Größe der größten Komponente: {len(max(components, key=len))}")

# Speichere den Graphen für spätere Verwendung
print("\nSpeichere Netzwerkdaten für weitere Analysen...")

# Speichervorgang hier optional implementieren, z.B.:
# nx.write_graphml(G, "hero_network.graphml")
# Oder als Pickle-Datei:
# import pickle
with open(os.path.join("data","hero_network.pickle"), "wb") as f:
    pickle.dump(G, f)

print("\nDatenvorverarbeitung abgeschlossen. Bereit für weitere Analysen!")

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
from fa2 import ForceAtlas2
import pandas as pd
from matplotlib.cm import get_cmap
from tqdm import tqdm

def visualize_hero_network(G, method="subset"):
    """
    Visualisiert das Superhelden-Netzwerk mit verschiedenen Methoden.
    
    Parameter:
    G -- NetworkX Graph-Objekt
    method -- Visualisierungsmethode: "subset", "largest_component", oder "community"
    """
    print(f"Visualisiere Netzwerk mit Methode: {method}")
    
    if method == "subset":
        # 1. Visualisierung eines Teilgraphen (Top-Helden nach Grad)
        print("Erstelle Teilgraph basierend auf Knotengrad...")
        degrees = dict(G.degree())
        top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:100]  # Top 100
        subgraph = G.subgraph(top_nodes)
        
        print(f"Teilgraph erstellt mit {subgraph.number_of_nodes()} Knoten und {subgraph.number_of_edges()} Kanten")
        
        plt.figure(figsize=(15, 15))
        pos = nx.spring_layout(subgraph, seed=42)
        
        # Knotengröße basierend auf Grad
        node_size = [20 + 0.5 * degrees[n] for n in subgraph.nodes()]
        
        nx.draw_networkx(
            subgraph,
            pos=pos,
            node_size=node_size,
            node_color='lightblue',
            edge_color='gray',
            alpha=0.7,
            width=0.3,
            with_labels=False
        )
        
        # Nur für die Top 20 Knoten Namen anzeigen
        top20 = top_nodes[:20]
        nx.draw_networkx_labels(
            subgraph,
            pos,
            {node: node for node in top20},
            font_size=8,
            font_weight='bold'
        )
        
        plt.title("Teilgraph der Top-100 Superhelden (nach Grad)")
        plt.axis('off')
        plt.tight_layout()
        plt.savefig('top_heroes_network.png', dpi=300, bbox_inches='tight')
        plt.show()
        
    elif method == "largest_component":
        # 2. Visualisierung der größten Zusammenhangskomponente mit ForceAtlas2
        try:
            # Finde die größte Zusammenhangskomponente
            print("Identifiziere größte Zusammenhangskomponente...")
            largest_cc = max(nx.connected_components(G), key=len)
            largest_cc_graph = G.subgraph(largest_cc).copy()
            
            # Wähle zufällig 1000 Knoten aus, wenn die Komponente zu groß ist
            if largest_cc_graph.number_of_nodes() > 1000:
                print("Komponente zu groß für Visualisierung, wähle 1000 zufällige Knoten...")
                nodes = list(largest_cc_graph.nodes())
                np.random.seed(42)
                sampled_nodes = np.random.choice(nodes, 1000, replace=False)
                largest_cc_graph = largest_cc_graph.subgraph(sampled_nodes)
            
            print(f"Berechne Layout für Graphen mit {largest_cc_graph.number_of_nodes()} Knoten...")
            
            # Konvertiere zu NumPy für ForceAtlas2
            A = nx.to_numpy_array(largest_cc_graph)
            nodes = list(largest_cc_graph.nodes())
            
            # ForceAtlas2 Layout
            forceatlas2 = ForceAtlas2(
                outboundAttractionDistribution=True,  
                linLogMode=False,
                adjustSizes=False, 
                edgeWeightInfluence=1.0,
                jitterTolerance=1.0, 
                barnesHutOptimize=True,
                barnesHutTheta=1.2,
                multiThreaded=False
            )
            
            print("Berechne ForceAtlas2-Layout (kann einige Zeit dauern)...")
            positions = forceatlas2.forceatlas2_networkx_layout(largest_cc_graph, pos=None, iterations=100)
            
            # Visualisierung
            plt.figure(figsize=(20, 20))
            
            # Knotengröße basierend auf Degree-Centrality
            centrality = nx.degree_centrality(largest_cc_graph)
            node_size = [3000 * centrality[node] for node in largest_cc_graph.nodes()]
            
            # Knotenfarbe basierend auf Clustering-Koeffizient
            clustering = nx.clustering(largest_cc_graph)
            node_color = [clustering[node] for node in largest_cc_graph.nodes()]
            
            nx.draw_networkx_nodes(
                largest_cc_graph,
                positions,
                node_size=node_size,
                node_color=node_color,
                cmap=plt.cm.viridis,
                alpha=0.8
            )
            
            nx.draw_networkx_edges(
                largest_cc_graph,
                positions,
                width=0.1,
                alpha=0.1,
                edge_color='gray'
            )
            
            # Beschriftungen für die Top-50 Knoten nach Zentralität
            top_centrality = sorted(centrality.items(), key=lambda x: x[1], reverse=True)[:50]
            labels = {node: node for node, _ in top_centrality}
            nx.draw_networkx_labels(
                largest_cc_graph,
                positions,
                labels=labels,
                font_size=8,
                font_weight='bold'
            )
            
            plt.title("Größte Zusammenhangskomponente des Superhelden-Netzwerks")
            plt.axis('off')
            plt.tight_layout()
            plt.savefig('largest_component_network.png', dpi=300, bbox_inches='tight')
            plt.show()
            
        except ImportError:
            print("ForceAtlas2 nicht verfügbar. Verwende Standard-Layout...")
            # Fallback auf standard Spring-Layout
            visualize_hero_network(G, "subset")
        
    elif method == "community":
        # 3. Visualisierung mit Community-Erkennung (auf einem Teilgraphen)
        print("Führe Community-Erkennung auf einem Teilgraphen durch...")
        
        # Verwende einen Teilgraphen von angemessener Größe
        degrees = dict(G.degree())
        top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:500]  # Top 500
        subgraph = G.subgraph(top_nodes)
        
        # Community-Erkennung
        print(f"Erkenne Communities im Teilgraphen mit {subgraph.number_of_nodes()} Knoten...")
        
        try:
            from community import best_partition
            partition = best_partition(subgraph)
            
            # Anzahl der Communities
            communities = set(partition.values())
            print(f"Gefundene Communities: {len(communities)}")
            
            # Visualisierung
            plt.figure(figsize=(20, 20))
            pos = nx.spring_layout(subgraph, seed=42, k=0.3)
            
            # Farbzuordnung für Communities
            cmap = get_cmap('tab20')
            colors = [cmap(i % 20) for i in range(len(communities))]
            
            # Zeichne Knoten mit Community-Farben
            for i, comm in enumerate(communities):
                list_nodes = [node for node, com_id in partition.items() if com_id == comm]
                nx.draw_networkx_nodes(
                    subgraph,
                    pos,
                    nodelist=list_nodes,
                    node_color=[colors[i]] * len(list_nodes),
                    node_size=[100 + 10 * degrees[node] for node in list_nodes],
                    alpha=0.8,
                    label=f"Community {i+1}"
                )
            
            # Zeichne Kanten
            nx.draw_networkx_edges(
                subgraph,
                pos,
                width=0.2,
                alpha=0.2,
                edge_color='gray'
            )
            
            # Beschriftungen für die Top-50 Knoten nach Grad
            top_degree = sorted(degrees.items(), key=lambda x: x[1], reverse=True)[:50]
            top_nodes = [node for node, _ in top_degree if node in subgraph.nodes()]
            labels = {node: node for node in top_nodes}
            nx.draw_networkx_labels(
                subgraph,
                pos,
                labels=labels,
                font_size=8,
                font_weight='bold'
            )
            
            plt.title("Superhelden-Netzwerk mit Community-Struktur (Top 500 Knoten)")
            plt.axis('off')
            plt.legend(scatterpoints=1, loc='lower left')
            plt.tight_layout()
            plt.savefig('community_network.png', dpi=300, bbox_inches='tight')
            plt.show()
            
        except ImportError:
            print("Community-Erkennungspaket nicht verfügbar. Verwende einfachere Visualisierung...")
            visualize_hero_network(G, "subset")
    
    else:
        print(f"Unbekannte Methode: {method}. Verwende 'subset' stattdessen.")
        visualize_hero_network(G, "subset")


def create_2d_visualization_grid(G):
    """Erstellt ein 2x2-Grid mit verschiedenen Visualisierungen."""
    plt.figure(figsize=(20, 20))
    
    # 1. Subgraph der Top-100 Knoten nach Grad
    degrees = dict(G.degree())
    top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:100]
    subgraph = G.subgraph(top_nodes)
    
    # Spring Layout für alle Visualisierungen verwenden
    pos = nx.spring_layout(subgraph, seed=42)
    
    # Plot 1: Grundvisualisierung mit Knotengröße nach Grad
    plt.subplot(2, 2, 1)
    node_size = [20 + 0.5 * degrees[n] for n in subgraph.nodes()]
    nx.draw_networkx(
        subgraph,
        pos=pos,
        node_size=node_size,
        node_color='lightblue',
        edge_color='gray',
        alpha=0.7,
        width=0.3,
        with_labels=False
    )
    
    # Nur für die Top 10 Knoten Namen anzeigen
    top10 = top_nodes[:10]
    nx.draw_networkx_labels(
        subgraph,
        pos,
        {node: node for node in top10},
        font_size=8,
        font_weight='bold'
    )
    plt.title("Top-100 Superhelden nach Anzahl der Verbindungen")
    plt.axis('off')
    
    # Plot 2: Betweenness Centrality
    plt.subplot(2, 2, 2)
    betweenness = nx.betweenness_centrality(subgraph)
    node_color = [betweenness[n] for n in subgraph.nodes()]
    nx.draw_networkx(
        subgraph,
        pos=pos,
        node_size=node_size,
        node_color=node_color,
        cmap=plt.cm.YlOrRd,
        edge_color='gray',
        alpha=0.7,
        width=0.3,
        with_labels=False
    )
    
    # Top 10 nach Betweenness
    top_betweenness = sorted(betweenness.items(), key=lambda x: x[1], reverse=True)[:10]
    top_betweenness_nodes = [node for node, _ in top_betweenness]
    nx.draw_networkx_labels(
        subgraph,
        pos,
        {node: node for node in top_betweenness_nodes},
        font_size=8,
        font_weight='bold'
    )
    plt.title("Betweenness Centrality (Brücken im Netzwerk)")
    plt.axis('off')
    
    # Plot 3: Clustering Coefficient
    plt.subplot(2, 2, 3)
    clustering = nx.clustering(subgraph)
    node_color = [clustering[n] for n in subgraph.nodes()]
    nx.draw_networkx(
        subgraph,
        pos=pos,
        node_size=node_size,
        node_color=node_color,
        cmap=plt.cm.Blues,
        edge_color='gray',
        alpha=0.7,
        width=0.3,
        with_labels=False
    )
    
    # Top 10 nach Clustering
    top_clustering = sorted(clustering.items(), key=lambda x: x[1], reverse=True)[:10]
    top_clustering_nodes = [node for node, _ in top_clustering]
    nx.draw_networkx_labels(
        subgraph,
        pos,
        {node: node for node in top_clustering_nodes},
        font_size=8,
        font_weight='bold'
    )
    plt.title("Clustering Coefficient (Dichte lokaler Verbindungen)")
    plt.axis('off')
    
    # Plot 4: Versuche Community-Erkennung
    plt.subplot(2, 2, 4)
    try:
        from community import best_partition
        partition = best_partition(subgraph)
        communities = set(partition.values())
        node_color = [partition[n] for n in subgraph.nodes()]
        
        nx.draw_networkx(
            subgraph,
            pos=pos,
            node_size=node_size,
            node_color=node_color,
            cmap=plt.cm.tab20,
            edge_color='gray',
            alpha=0.7,
            width=0.3,
            with_labels=False
        )
        plt.title(f"Community-Struktur ({len(communities)} Communities)")
    except ImportError:
        # Alternative: Eigenvektor-Zentralität
        eigenvector = nx.eigenvector_centrality_numpy(subgraph)
        node_color = [eigenvector[n] for n in subgraph.nodes()]
        nx.draw_networkx(
            subgraph,
            pos=pos,
            node_size=node_size,
            node_color=node_color,
            cmap=plt.cm.plasma,
            edge_color='gray',
            alpha=0.7,
            width=0.3,
            with_labels=False
        )
        
        # Top 10 nach Eigenvektor-Zentralität
        top_eigenvector = sorted(eigenvector.items(), key=lambda x: x[1], reverse=True)[:10]
        top_eigenvector_nodes = [node for node, _ in top_eigenvector]
        nx.draw_networkx_labels(
            subgraph,
            pos,
            {node: node for node in top_eigenvector_nodes},
            font_size=8,
            font_weight='bold'
        )
        plt.title("Eigenvektor-Zentralität (Einfluss im Netzwerk)")
    plt.axis('off')
    
    plt.tight_layout()
    plt.savefig('hero_network_analysis_grid.png', dpi=300, bbox_inches='tight')
    plt.show()


def create_heatmap_visualization(G):
    """Erstellt eine Heatmap der Adjazenzmatrix für einen Teilgraphen."""
    # Wähle einen Teilgraphen der Top-50 Knoten
    degrees = dict(G.degree())
    top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:50]
    subgraph = G.subgraph(top_nodes)
    
    # Erstelle Adjazenzmatrix
    adj_matrix = nx.to_numpy_array(subgraph)
    
    # Knotennamen für die Achsenbeschriftung
    nodes_list = list(subgraph.nodes())
    
    plt.figure(figsize=(15, 15))
    plt.imshow(adj_matrix, cmap='Blues', interpolation='nearest')
    
    # Achsenbeschriftungen mit Knotennamen (gekürzt)
    shortened_names = [name[:15] + "..." if len(name) > 15 else name for name in nodes_list]
    plt.xticks(range(len(nodes_list)), shortened_names, rotation=90, fontsize=8)
    plt.yticks(range(len(nodes_list)), shortened_names, fontsize=8)
    
    plt.title("Adjazenzmatrix der Top-50 Superhelden")
    plt.colorbar(label="Verbindungsstärke")
    plt.tight_layout()
    plt.savefig('hero_adjacency_heatmap.png', dpi=300, bbox_inches='tight')
    plt.show()


# Hauptfunktion, die alle Visualisierungen erstellt
def visualize_full_hero_network(G):
    """Erstellt verschiedene Visualisierungen des Superhelden-Netzwerks."""
    print("Erstelle verschiedene Visualisierungen des Superhelden-Netzwerks...\n")
    
    # 1. Visualisierung eines Teilgraphen
    print("Visualisierung 1: Teilgraph der wichtigsten Superhelden")
    visualize_hero_network(G, "subset")
    
    # 2. Grid mit verschiedenen Zentralitätsmaßen
    print("\nVisualisierung 2: Analyseraster mit verschiedenen Metriken")
    create_2d_visualization_grid(G)
    
    # 3. Heatmap-Visualisierung
    print("\nVisualisierung 3: Heatmap der Adjazenzmatrix")
    create_heatmap_visualization(G)
    
    # 4. Versuch der ForceAtlas2-Visualisierung (wenn verfügbar)
    try:
        print("\nVisualisierung 4: Fortgeschrittene Visualisierung mit ForceAtlas2")
        visualize_hero_network(G, "largest_component")
    except Exception as e:
        print(f"ForceAtlas2-Visualisierung fehlgeschlagen: {e}")
    
    # 5. Community-Visualisierung (wenn verfügbar)
    try:
        print("\nVisualisierung 5: Community-Struktur des Netzwerks")
        visualize_hero_network(G, "community")
    except Exception as e:
        print(f"Community-Visualisierung fehlgeschlagen: {e}")
    
    print("\nAlle Visualisierungen abgeschlossen und gespeichert!")


# Beispielaufruf, wenn dieses Skript direkt ausgeführt wird
if __name__ == "__main__":
    # Lade das Netzwerk (falls es noch nicht geladen wurde)
    try:
        # Versuche zuerst, einen vorhandenen Graphen zu laden
        import pickle
        with open(os.path.join("data","hero_network.pickle"), "rb") as f:
            G = pickle.load(f)
        print("Netzwerk aus Pickle-Datei geladen.")
    except:
        # Falls kein gespeicherter Graph existiert, erstelle einen neuen
        print("Erstelle Netzwerk aus CSV-Datei...")
        
        # Code zum Laden und Erstellen des Netzwerks hier einfügen...
        # z.B.:
        import pandas as pd
        df = pd.read_csv('hero-network.csv')
        G = nx.Graph()
        for _, row in df.iterrows():
            G.add_edge(row['hero1'], row['hero2'])
        
        print(f"Netzwerk erstellt mit {G.number_of_nodes()} Knoten und {G.number_of_edges()} Kanten.")
    
    # Erstelle Visualisierungen
    visualize_full_hero_network(G)