網路視覺化佈局優化：社群與殼層佈局策略

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
import community as nxcom # 假設 community 模組已安裝 (pip install python-louvain)
from pathlib import Path
import pandas as pd

# --- 載入 Zachary 空手道俱樂部網路 
---
try:
    G_karate = nx.karate_club_graph()
    print(f"成功載入 Zachary 空手道俱樂部網路: {G_karate.number_of_nodes()} 個節點, {G_karate.number_of_edges()} 條邊。")
except Exception as e:
    print(f"載入 Zachary 空手道俱樂部網路時發生錯誤: {e}")
    G_karate = nx.Graph()

# --- 社群導向的圓形佈局函數 (接續前文) 
---
# 假設 get_color 函數已定義，這裡我們模擬一個
def get_color(community_index, num_communities=4): # 假設最多4個社群
    cmap = plt.get_cmap('viridis', num_communities)
    return cmap(community_index % num_communities)

def community_net_optimized(G_in):
    """
    識別社群，並準備節點顏色和社群映射，用於視覺化。
    返回: node_color 列表, node_community 字典, G_out (節點列表)
    """
    if G_in.number_of_nodes() == 0:
        return [], {}, []

    node_color_list = []
    node_community_map = {}
    
    try:
        communities = list(nxcom.greedy_modularity_communities(G_in))
        num_communities = len(communities)
        print(f"偵測到 {num_communities} 個社群。")
    except Exception as e:
        print(f"計算社群時發生錯誤: {e}")
        communities = [[node] for node in G_in.nodes()] # 退化為每個節點一個社群
        num_communities = len(communities)

    # 創建節點到社群索引的映射，並準備顏色列表
    for i, community in enumerate(communities):
        for node in community:
            node_community_map[node] = i
            node_color_list.append(get_color(i, num_communities)) # 獲取顏色

    # 為了讓 circular_layout 根據社群順序排列，我們需要一個排序後的節點列表
    # 將節點按社群索引排序，然後在社群內部按節點 ID 排序
    sorted_nodes_by_community = []
    for i in range(num_communities):
        community_nodes = sorted([node for node, comm_idx in node_community_map.items() if comm_idx == i])
        sorted_nodes_by_community.extend(community_nodes)

    # 確保所有節點都被包含，即使是孤立節點
    all_nodes = list(G_in.nodes())
    if len(sorted_nodes_by_community) < len(all_nodes):
        remaining_nodes = sorted([node for node in all_nodes if node not in node_community_map])
        sorted_nodes_by_community.extend(remaining_nodes)
        # 為這些節點分配一個預設社群索引（例如 -1 或 num_communities）
        for node in remaining_nodes:
            node_community_map[node] = num_communities # 或 -1

    # 為了讓 nx.draw_networkx 使用這個排序，我們需要一個自訂佈局
    # 這裡我們返回節點列表和顏色，讓外部繪圖函數處理佈局
    return node_color_list, node_community_map, sorted_nodes_by_community # 返回排序後的節點列表

# --- 繪製社群導向的圓形佈局 (使用排序後的節點) 
---
def draw_optimized_circular_layout(G_in, title="Optimized Circular Layout by Community"):
    if G_in.number_of_nodes() == 0:
        print("圖為空，無法繪製優化圓形佈局。")
        return

    node_colors, node_community_map, sorted_nodes = community_net_optimized(G_in)
    
    # 創建一個基於 sorted_nodes 的自訂佈局
    # 這裡我們使用 nx.circular_layout，但確保節點順序是我們想要的
    # NetworkX 的 circular_layout 函數實際上會根據 G.nodes() 的順序來排列
    # 所以我們需要一個方法來傳遞排序後的節點順序
    
    # 一種方法是創建一個新的圖，節點順序是我們想要的，然後應用 circular_layout
    G_ordered = nx.Graph()
    G_ordered.add_nodes_from(sorted_nodes)
    G_ordered.add_edges_from(G_in.edges()) # 添加邊

    pos = nx.circular_layout(G_ordered) # 在排序後的圖上生成佈局

    plt.figure(figsize=(8, 8))
    nx.draw_networkx(
        G_in, # 使用原始圖 G_in 繪製，但 pos 是基於 G_ordered 的
        pos=pos, 
        with_labels=True, 
        node_size=300, 
        node_color=node_colors, # 使用社群顏色
        edge_color='gray', 
        alpha=0.7, 
        width=0.5
    )
    plt.title(title, fontsize=16)
    plt.axis('off')
    plt.show()

print("\n--- 社群導向的圓形佈局 
---
")
draw_optimized_circular_layout(G_karate, title="Zachary Karate Club: Optimized Circular Layout")

# --- 殼層佈局 (Shell Layout) 
---
print("\n--- 殼層佈局 (Shell Layout) 
---
")

def draw_shell_layout(G, title="Shell Layout"):
    """
    繪製網路的殼層佈局。
    """
    if G.number_of_nodes() == 0:
        print("圖為空，無法繪製殼層佈局。")
        return

    # --- 結合社群偵測來構建殼層 
---
    try:
        communities = list(nxcom.greedy_modularity_communities(G))
        num_communities = len(communities)
        
        # 創建 nlist：將每個社群的節點放入一個殼層
        nlist = []
        for community in communities:
            # 對社群內的節點進行排序，以確保佈局的可重複性
            nlist.append(sorted(list(community))) 
        
        # 如果節點數量不足以填滿多個殼層，可以調整 nlist 的結構
        # 例如，如果社群數量少於預期的殼層數，可以將較大的社群拆分或合併
        # 這裡為了簡化，我們假設每個社群就是一個殼層
        
        # 確保所有節點都被包含，即使是孤立節點
        all_nodes_in_shells = [node for shell in nlist for node in shell]
        all_graph_nodes = list(G.nodes())
        if len(all_nodes_in_shells) < len(all_graph_nodes):
            isolated_nodes = sorted([node for node in all_graph_nodes if node not in all_nodes_in_shells])
            if isolated_nodes:
                nlist.append(isolated_nodes) # 將孤立節點放在最後一個殼層
                print(f"將 {len(isolated_nodes)} 個孤立節點添加到最後一個殼層。")
        
        print(f"使用 {len(nlist)} 個殼層進行佈局。")
        
        pos = nx.shell_layout(G, nlist=nlist)
        
    except Exception as e:
        print(f"構建殼層或計算 shell_layout 時發生錯誤: {e}")
        print("退回到預設的 shell_layout。")
        pos = nx.shell_layout(G) # 退回到預設佈局

    # --- 繪製 
---
    plt.figure(figsize=(8, 8))
    
    # 為了讓殼層佈局更清晰，可以考慮根據社群給節點上色
    node_colors = []
    community_map = {}
    for i, shell in enumerate(nlist):
        for node in shell:
            community_map[node] = i
    
    num_shells = len(nlist)
    cmap = plt.get_cmap('tab10', num_shells) # 使用不同的顏色映射
    for node in G.nodes():
        community_idx = community_map.get(node, -1) # 獲取節點所屬殼層/社群索引
        if community_idx != -1:
            node_colors.append(cmap(community_idx % num_shells))
        else:
            node_colors.append('gray') # 孤立節點或未分類節點

    nx.draw_networkx(
        G, 
        pos=pos, 
        with_labels=True, 
        node_size=300, 
        node_color=node_colors, # 使用根據殼層/社群的顏色
        edge_color='gray', 
        alpha=0.7, 
        width=0.5
    )
    plt.title(title, fontsize=16)
    plt.axis('off')
    plt.show()

# 繪製結合社群的殼層佈局
draw_shell_layout(G_karate, title="Zachary Karate Club: Shell Layout by Community")

print("\n--- 殼層佈局的優勢與局限 
---
")
print("優勢: 空間利用率高，可容納更多節點；中心節點可放置於內層，傳達中心性資訊。")
print("局限: 對社群結構的捕捉不如專門的社群佈局；可能掩蓋部分邊。")
print("結合社群偵測有助於將相關節點分組到相似的殼層，提升視覺效果。")