refactoring the graph visualizer

bump version format format
2025-02-03 22:08:25 +08:00
parent c07b5522fe
commit 460a2cda02
6 changed files with 1340 additions and 666 deletions
--- a/extra/VisualizationTOol/GraphVisualizer.py
+++ b/extra/VisualizationTOol/GraphVisualizer.py
@@ -1,666 +0,0 @@
 """
 3D GraphML Viewer
 Author: LoLLMs
 Description: An interactive 3D GraphML viewer using PyQt5 and pyqtgraph
 Version: 2.2
 """
 from pathlib import Path
 from typing import Optional, Tuple, Dict, List, Any
 import pipmaster as pm
 # Install all required dependencies
 REQUIRED_PACKAGES = [
    "PyQt5",
    "pyqtgraph",
    "numpy",
    "PyOpenGL",
    "PyOpenGL_accelerate",
    "networkx",
    "matplotlib",
    "python-louvain",
    "ascii_colors",
 ]
 def setup_dependencies():
    """
    Ensure all required packages are installed
    """
    for package in REQUIRED_PACKAGES:
        if not pm.is_installed(package):
            print(f"Installing {package}...")
            pm.install(package)
 # Install dependencies
 setup_dependencies()
 import networkx as nx
 import numpy as np
 import matplotlib.pyplot as plt
 import community
 from PyQt5.QtWidgets import (
    QApplication,
    QMainWindow,
    QWidget,
    QVBoxLayout,
    QHBoxLayout,
    QPushButton,
    QFileDialog,
    QLabel,
    QMessageBox,
    QSpinBox,
    QComboBox,
    QCheckBox,
    QTableWidget,
    QTableWidgetItem,
    QSplitter,
    QDockWidget,
    QTextEdit,
 )
 from PyQt5.QtCore import Qt
 import pyqtgraph.opengl as gl
 from ascii_colors import trace_exception
 class Point:
    """Simple point class to handle coordinates"""
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y
 class NodeState:
    """Data class for node visual state"""
    NORMAL_SCALE = 1.0
    HOVER_SCALE = 1.2
    SELECTED_SCALE = 1.3
    NORMAL_OPACITY = 0.8
    HOVER_OPACITY = 1.0
    SELECTED_OPACITY = 1.0
    # Increase base node size (was 0.05)
    BASE_SIZE = 0.2
    SELECTED_COLOR = (1.0, 1.0, 0.0, 1.0)
    HOVER_COLOR = (1.0, 0.8, 0.0, 1.0)
 class Node3D:
    """Class representing a 3D node in the graph"""
    def __init__(
        self,
        position: np.ndarray,
        color: Tuple[float, float, float, float],
        label: str,
        node_type: str,
        size: float,
    ):
        self.position = position
        self.base_color = color
        self.color = color
        self.label = label
        self.node_type = node_type
        self.size = size
        self.mesh_item = None
        self.label_item = None
        self.is_highlighted = False
        self.is_selected = False
    def highlight(self):
        """Highlight the node"""
        if not self.is_highlighted and not self.is_selected:
            self.color = NodeState.HOVER_COLOR
            self.update_appearance(NodeState.HOVER_SCALE)
            self.is_highlighted = True
    def unhighlight(self):
        """Remove highlight from node"""
        if self.is_highlighted and not self.is_selected:
            self.color = self.base_color
            self.update_appearance(NodeState.NORMAL_SCALE)
            self.is_highlighted = False
    def select(self):
        """Select the node"""
        self.is_selected = True
        self.color = NodeState.SELECTED_COLOR
        self.update_appearance(NodeState.SELECTED_SCALE)
    def deselect(self):
        """Deselect the node"""
        self.is_selected = False
        self.color = self.base_color
        self.update_appearance(NodeState.NORMAL_SCALE)
    def update_appearance(self, scale: float = 1.0):
        """Update node visual appearance"""
        if self.mesh_item:
            self.mesh_item.setData(
                color=np.array([self.color]), size=np.array([self.size * scale * 5])
            )
 class NodeDetailsWidget(QWidget):
    """Widget to display node details"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.init_ui()
    def init_ui(self):
        """Initialize the UI"""
        layout = QVBoxLayout(self)
        # Properties text edit
        self.properties = QTextEdit()
        self.properties.setReadOnly(True)
        layout.addWidget(QLabel("Properties:"))
        layout.addWidget(self.properties)
        # Connections table
        self.connections = QTableWidget()
        self.connections.setColumnCount(3)
        self.connections.setHorizontalHeaderLabels(
            ["Connected Node", "Relationship", "Direction"]
        )
        layout.addWidget(QLabel("Connections:"))
        layout.addWidget(self.connections)
    def update_node_info(self, node_data: Dict, connections: Dict):
        """Update the display with node information"""
        # Update properties
        properties_text = "Node Properties:\n"
        for key, value in node_data.items():
            properties_text += f"{key}: {value}\n"
        self.properties.setText(properties_text)
        # Update connections
        self.connections.setRowCount(len(connections))
        for idx, (neighbor, edge_data) in enumerate(connections.items()):
            self.connections.setItem(idx, 0, QTableWidgetItem(str(neighbor)))
            self.connections.setItem(
                idx, 1, QTableWidgetItem(edge_data.get("relationship", "unknown"))
            )
            self.connections.setItem(idx, 2, QTableWidgetItem("outgoing"))
 class GraphMLViewer3D(QMainWindow):
    """Main window class for 3D GraphML visualization"""
    def __init__(self):
        super().__init__()
        self.graph: Optional[nx.Graph] = None
        self.nodes: Dict[str, Node3D] = {}
        self.edges: List[gl.GLLinePlotItem] = []
        self.edge_labels: List[gl.GLTextItem] = []
        self.selected_node = None
        self.communities = None
        self.community_colors = None
        self.mouse_pos_last = None
        self.mouse_buttons_pressed = set()
        self.distance = 20  # Initial camera distance
        self.center = np.array([0, 0, 0])  # View center point
        self.elevation = 30  # Initial camera elevation
        self.azimuth = 45  # Initial camera azimuth
        self.init_ui()
    def init_ui(self):
        """Initialize the user interface"""
        self.setWindowTitle("3D GraphML Viewer")
        self.setGeometry(100, 100, 1600, 900)
        # Create main splitter
        self.main_splitter = QSplitter(Qt.Horizontal)
        self.setCentralWidget(self.main_splitter)
        # Create left panel for 3D view
        left_widget = QWidget()
        left_layout = QVBoxLayout(left_widget)
        # Create controls
        self.create_toolbar(left_layout)
        # Create 3D view
        self.view = gl.GLViewWidget()
        self.view.setMouseTracking(True)
        # Connect mouse events
        self.view.mousePressEvent = self.on_mouse_press
        self.view.mouseMoveEvent = self.on_mouse_move
        left_layout.addWidget(self.view)
        self.main_splitter.addWidget(left_widget)
        # Create details widget
        self.details = NodeDetailsWidget()
        details_dock = QDockWidget("Node Details", self)
        details_dock.setWidget(self.details)
        self.addDockWidget(Qt.RightDockWidgetArea, details_dock)
        # Add status bar
        self.statusBar().showMessage("Ready")
        # Add initial grid
        grid = gl.GLGridItem()
        grid.setSize(x=20, y=20, z=20)
        grid.setSpacing(x=1, y=1, z=1)
        self.view.addItem(grid)
        # Set initial camera position
        self.view.setCameraPosition(
            distance=self.distance, elevation=self.elevation, azimuth=self.azimuth
        )
        # Connect all mouse events
        self.view.mousePressEvent = self.on_mouse_press
        self.view.mouseReleaseEvent = self.on_mouse_release
        self.view.mouseMoveEvent = self.on_mouse_move
        self.view.wheelEvent = self.on_mouse_wheel
    def calculate_node_sizes(self) -> Dict[str, float]:
        """Calculate node sizes based on number of connections"""
        if not self.graph:
            return {}
        # Get degree (number of connections) for each node
        degrees = dict(self.graph.degree())
        # Calculate size scaling
        max_degree = max(degrees.values())
        min_degree = min(degrees.values())
        # Normalize sizes between 0.5 and 2.0
        sizes = {}
        for node, degree in degrees.items():
            if max_degree == min_degree:
                sizes[node] = 1.0
            else:
                # Normalize and scale size
                normalized = (degree - min_degree) / (max_degree - min_degree)
                sizes[node] = 0.5 + normalized * 1.5
        return sizes
    def create_toolbar(self, layout: QVBoxLayout):
        """Create the toolbar with controls"""
        toolbar = QHBoxLayout()
        # Load button
        load_btn = QPushButton("Load GraphML")
        load_btn.clicked.connect(self.load_graphml)
        toolbar.addWidget(load_btn)
        # Reset view button
        reset_btn = QPushButton("Reset View")
        reset_btn.clicked.connect(lambda: self.view.setCameraPosition(distance=20))
        toolbar.addWidget(reset_btn)
        # Layout selector
        self.layout_combo = QComboBox()
        self.layout_combo.addItems(["Spring", "Circular", "Shell", "Random"])
        self.layout_combo.currentTextChanged.connect(self.refresh_layout)
        toolbar.addWidget(QLabel("Layout:"))
        toolbar.addWidget(self.layout_combo)
        # Node size control
        self.node_size = QSpinBox()
        self.node_size.setRange(1, 100)
        self.node_size.setValue(20)
        self.node_size.valueChanged.connect(self.refresh_layout)
        toolbar.addWidget(QLabel("Node Size:"))
        toolbar.addWidget(self.node_size)
        # Show labels checkbox
        self.show_labels = QCheckBox("Show Labels")
        self.show_labels.setChecked(True)
        self.show_labels.stateChanged.connect(self.refresh_layout)
        toolbar.addWidget(self.show_labels)
        layout.addLayout(toolbar)
        # Reset view button
        reset_btn = QPushButton("Reset View")
        reset_btn.clicked.connect(self.reset_view)  # Use the new reset_view method
        toolbar.addWidget(reset_btn)
    def load_graphml(self) -> None:
        """Load and visualize a GraphML file"""
        try:
            file_path, _ = QFileDialog.getOpenFileName(
                self, "Open GraphML file", "", "GraphML files (*.graphml)"
            )
            if file_path:
                self.graph = nx.read_graphml(Path(file_path))
                self.refresh_layout()
                self.statusBar().showMessage(f"Loaded: {file_path}")
        except Exception as e:
            trace_exception(e)
            QMessageBox.critical(self, "Error", f"Error loading file: {str(e)}")
    def calculate_layout(self) -> Dict[str, np.ndarray]:
        """Calculate node positions based on selected layout"""
        layout_type = self.layout_combo.currentText().lower()
        # Detect communities for coloring
        self.communities = community.best_partition(self.graph)
        num_communities = len(set(self.communities.values()))
        self.community_colors = plt.cm.rainbow(np.linspace(0, 1, num_communities))
        if layout_type == "spring":
            pos = nx.spring_layout(
                self.graph, dim=3, k=2.0, iterations=100, weight=None
            )
        elif layout_type == "circular":
            pos_2d = nx.circular_layout(self.graph)
            pos = {node: np.array([x, y, 0.0]) for node, (x, y) in pos_2d.items()}
        elif layout_type == "shell":
            comm_lists = [[] for _ in range(num_communities)]
            for node, comm in self.communities.items():
                comm_lists[comm].append(node)
            pos_2d = nx.shell_layout(self.graph, comm_lists)
            pos = {node: np.array([x, y, 0.0]) for node, (x, y) in pos_2d.items()}
        else:  # random
            pos = {node: np.random.rand(3) * 2 - 1 for node in self.graph.nodes()}
        # Scale positions
        positions = np.array(list(pos.values()))
        if len(positions) > 0:
            scale = 10.0 / max(1.0, np.max(np.abs(positions)))
            return {node: coords * scale for node, coords in pos.items()}
        return pos
    def get_node_color(self, node_id: str) -> Tuple[float, float, float, float]:
        """Get RGBA color based on community"""
        if hasattr(self, "communities") and node_id in self.communities:
            comm_id = self.communities[node_id]
            color = self.community_colors[comm_id]
            return tuple(color)
        return (0.5, 0.5, 0.5, 0.8)
    def create_node(self, node_id: str, position: np.ndarray, node_type: str) -> Node3D:
        """Create a 3D node with interaction capabilities"""
        color = self.get_node_color(node_id)
        # Get size multiplier based on connections
        size_multiplier = self.node_sizes.get(node_id, 1.0)
        size = NodeState.BASE_SIZE * self.node_size.value() / 50.0 * size_multiplier
        node = Node3D(position, color, str(node_id), node_type, size)
        node.mesh_item = gl.GLScatterPlotItem(
            pos=np.array([position]),
            size=np.array([size * 8]),
            color=np.array([color]),
            pxMode=False,
        )
        # Enable picking and set node ID
        node.mesh_item.setGLOptions("translucent")
        node.mesh_item.node_id = node_id
        if self.show_labels.isChecked():
            node.label_item = gl.GLTextItem(
                pos=position,
                text=str(node_id),
                color=(1, 1, 1, 1),
            )
        return node
    def mapToView(self, pos) -> Point:
        """Convert screen coordinates to world coordinates"""
        # Get the viewport size
        width = self.view.width()
        height = self.view.height()
        # Normalize coordinates
        x = (pos.x() / width - 0.5) * 20  # Scale factor of 20 matches the grid size
        y = -(pos.y() / height - 0.5) * 20
        return Point(x, y)
    def on_mouse_move(self, event):
        """Handle mouse movement for pan, rotate and hover"""
        if self.mouse_pos_last is None:
            self.mouse_pos_last = event.pos()
            return
        pos = event.pos()
        dx = pos.x() - self.mouse_pos_last.x()
        dy = pos.y() - self.mouse_pos_last.y()
        # Handle right button drag for panning
        if Qt.RightButton in self.mouse_buttons_pressed:
            # Scale the pan amount based on view distance
            scale = self.distance / 1000.0
            # Calculate pan in view coordinates
            right = np.cross([0, 0, 1], self.view.cameraPosition())
            right = right / np.linalg.norm(right)
            up = np.cross(self.view.cameraPosition(), right)
            up = up / np.linalg.norm(up)
            pan = -right * dx * scale + up * dy * scale
            self.center += pan
            self.view.pan(dx, dy, 0)
        # Handle middle button drag for rotation
        elif Qt.MiddleButton in self.mouse_buttons_pressed:
            self.azimuth += dx * 0.5  # Adjust rotation speed as needed
            self.elevation -= dy * 0.5
            # Clamp elevation to prevent gimbal lock
            self.elevation = np.clip(self.elevation, -89, 89)
            self.view.setCameraPosition(
                distance=self.distance, elevation=self.elevation, azimuth=self.azimuth
            )
        # Handle hover events when no buttons are pressed
        elif not self.mouse_buttons_pressed:
            # Get the mouse position in world coordinates
            mouse_pos = self.mapToView(pos)
            # Check for hover
            min_dist = float("inf")
            hovered_node = None
            for node_id, node in self.nodes.items():
                # Calculate distance to mouse in world coordinates
                dx = mouse_pos.x - node.position[0]
                dy = mouse_pos.y - node.position[1]
                dist = np.sqrt(dx * dx + dy * dy)
                if dist < min_dist and dist < 0.5:  # Adjust threshold as needed
                    min_dist = dist
                    hovered_node = node_id
            # Update hover states
            for node_id, node in self.nodes.items():
                if node_id == hovered_node:
                    node.highlight()
                    self.statusBar().showMessage(f"Node: {node_id} ({node.node_type})")
                else:
                    if not node.is_selected:
                        node.unhighlight()
            self.mouse_pos_last = pos
    def on_mouse_press(self, event):
        """Handle mouse press events"""
        self.mouse_pos_last = event.pos()
        self.mouse_buttons_pressed.add(event.button())
        # Handle left click for node selection
        if event.button() == Qt.LeftButton:
            pos = event.pos()
            mouse_pos = self.mapToView(pos)
            # Find closest node
            min_dist = float("inf")
            clicked_node = None
            for node_id, node in self.nodes.items():
                dx = mouse_pos.x - node.position[0]
                dy = mouse_pos.y - node.position[1]
                dist = np.sqrt(dx * dx + dy * dy)
                if dist < min_dist and dist < 0.5:  # Adjust threshold as needed
                    min_dist = dist
                    clicked_node = node_id
            # Handle selection
            if clicked_node:
                if self.selected_node and self.selected_node in self.nodes:
                    self.nodes[self.selected_node].deselect()
                self.nodes[clicked_node].select()
                self.selected_node = clicked_node
                if self.graph:
                    self.details.update_node_info(
                        self.graph.nodes[clicked_node], self.graph[clicked_node]
                    )
    def on_mouse_release(self, event):
        """Handle mouse release events"""
        self.mouse_buttons_pressed.discard(event.button())
        self.mouse_pos_last = None
    def on_mouse_wheel(self, event):
        """Handle mouse wheel for zooming"""
        delta = event.angleDelta().y()
        # Adjust zoom speed based on current distance
        zoom_speed = self.distance / 100.0
        # Update distance with limits
        self.distance -= delta * zoom_speed
        self.distance = np.clip(self.distance, 1.0, 100.0)
        self.view.setCameraPosition(
            distance=self.distance, elevation=self.elevation, azimuth=self.azimuth
        )
    def reset_view(self):
        """Reset camera to default position"""
        self.distance = 20
        self.elevation = 30
        self.azimuth = 45
        self.center = np.array([0, 0, 0])
        self.view.setCameraPosition(
            distance=self.distance, elevation=self.elevation, azimuth=self.azimuth
        )
    def create_edge(
        self,
        start_pos: np.ndarray,
        end_pos: np.ndarray,
        color: Tuple[float, float, float, float] = (0.3, 0.3, 0.3, 0.2),
    ) -> gl.GLLinePlotItem:
        """Create a 3D edge between nodes"""
        return gl.GLLinePlotItem(
            pos=np.array([start_pos, end_pos]),
            color=color,
            width=1,
            antialias=True,
            mode="lines",
        )
    def handle_node_hover(self, event: Any, node_id: str) -> None:
        """Handle node hover events"""
        if node_id in self.nodes:
            node = self.nodes[node_id]
            if event.isEnter():
                node.highlight()
                self.statusBar().showMessage(f"Node: {node_id} ({node.node_type})")
            elif event.isExit():
                node.unhighlight()
                self.statusBar().showMessage("")
    def handle_node_click(self, event: Any, node_id: str) -> None:
        """Handle node click events"""
        if event.button() != Qt.LeftButton or node_id not in self.nodes:
            return
        if self.selected_node and self.selected_node in self.nodes:
            self.nodes[self.selected_node].deselect()
        node = self.nodes[node_id]
        node.select()
        self.selected_node = node_id
        if self.graph:
            self.details.update_node_info(
                self.graph.nodes[node_id], self.graph[node_id]
            )
    def refresh_layout(self) -> None:
        """Refresh the graph visualization"""
        if not self.graph:
            return
        self.positions = self.calculate_layout()
        self.node_sizes = self.calculate_node_sizes()
        self.view.clear()
        self.nodes.clear()
        self.edges.clear()
        self.edge_labels.clear()
        grid = gl.GLGridItem()
        grid.setSize(x=20, y=20, z=20)
        grid.setSpacing(x=1, y=1, z=1)
        self.view.addItem(grid)
        positions = self.calculate_layout()
        for node_id in self.graph.nodes():
            node_type = self.graph.nodes[node_id].get("type", "default")
            node = self.create_node(node_id, positions[node_id], node_type)
            self.view.addItem(node.mesh_item)
            if node.label_item:
                self.view.addItem(node.label_item)
            self.nodes[node_id] = node
        for source, target in self.graph.edges():
            edge = self.create_edge(positions[source], positions[target])
            self.view.addItem(edge)
            self.edges.append(edge)
            if self.show_labels.isChecked():
                mid_point = (positions[source] + positions[target]) / 2
                relationship = self.graph.edges[source, target].get("relationship", "")
                if relationship:
                    label = gl.GLTextItem(
                        pos=mid_point,
                        text=relationship,
                        color=(0.8, 0.8, 0.8, 0.8),
                    )
                    self.view.addItem(label)
                    self.edge_labels.append(label)
 def main():
    """Application entry point"""
    import sys
    app = QApplication(sys.argv)
    viewer = GraphMLViewer3D()
    viewer.show()
    sys.exit(app.exec_())
 if __name__ == "__main__":
    main()
--- a/extra/VisualizationTool/README-zh.md
+++ b/extra/VisualizationTool/README-zh.md
@@ -0,0 +1,95 @@
 # 3D GraphML Viewer
 一个基于 Dear ImGui 和 ModernGL 的交互式 3D 图可视化工具。
 ## 功能特点
 - **3D 交互式可视化**: 使用 ModernGL 实现高性能的 3D 图形渲染
 - **多种布局算法**: 支持多种图布局方式
  - Spring 布局
  - Circular 布局
  - Shell 布局
  - Random 布局
 - **社区检测**: 支持图社区结构的自动检测和可视化
 - **交互控制**:
  - WASD + QE 键控制相机移动
  - 鼠标右键拖拽控制视角
  - 节点选择和高亮
  - 可调节节点大小和边宽度
  - 可控制标签显示
  - 可在节点的Connections间快速跳转
 - **社区检测**: 支持图社区结构的自动检测和可视化
 - **交互控制**:
  - WASD + QE 键控制相机移动
  - 鼠标右键拖拽控制视角
  - 节点选择和高亮
  - 可调节节点大小和边宽度
  - 可控制标签显示
 ## 技术栈
 - **imgui_bundle**: 用户界面
 - **ModernGL**: OpenGL 图形渲染
 - **NetworkX**: 图数据结构和算法
 - **NumPy**: 数值计算
 - **community**: 社区检测
 ## 使用方法
 1. **启动程序**:
   ```bash
   python -m pip install -r requirements.txt
   python graph_visualizer.py
   ```
 2. **加载字体**:
   - 将中文字体文件 `font.ttf` 放置在 `assets` 目录下
   - 或者修改 `CUSTOM_FONT` 常量来使用其他字体文件
 3. **加载图文件**:
   - 点击界面上的 "Load GraphML" 按钮
   - 选择 GraphML 格式的图文件
 4. **交互控制**:
   - **相机移动**:
     - W: 前进
     - S: 后退
     - A: 左移
     - D: 右移
     - Q: 上升
     - E: 下降
   - **视角控制**:
     - 按住鼠标右键拖动来旋转视角
   - **节点交互**:
     - 鼠标悬停可高亮节点
     - 点击可选中节点
 5. **可视化设置**:
   - 可通过 UI 控制面板调整:
     - 布局类型
     - 节点大小
     - 边的宽度
     - 标签显示
     - 标签大小
     - 背景颜色
 ## 自定义设置
 - **节点缩放**: 通过 `node_scale` 参数调整节点大小
 - **边宽度**: 通过 `edge_width` 参数调整边的宽度
 - **标签显示**: 可通过 `show_labels` 开关标签显示
 - **标签大小**: 使用 `label_size` 调整标签大小
 - **标签颜色**: 通过 `label_color` 设置标签颜色
 - **视距控制**: 使用 `label_culling_distance` 控制标签显示的最大距离
 ## 性能优化
 - 使用 ModernGL 进行高效的图形渲染
 - 视距裁剪优化标签显示
 - 社区检测算法优化大规模图的可视化效果
 ## 系统要求
 - Python 3.10+
 - OpenGL 3.3+ 兼容的显卡
 - 支持的操作系统：Windows/Linux/MacOS
--- a/extra/VisualizationTool/README.md
+++ b/extra/VisualizationTool/README.md
@@ -0,0 +1,88 @@
 # 3D GraphML Viewer
 An interactive 3D graph visualization tool based on Dear ImGui and ModernGL.
 ## Features
 - **3D Interactive Visualization**: High-performance 3D graphics rendering using ModernGL
 - **Multiple Layout Algorithms**: Support for various graph layouts
  - Spring layout
  - Circular layout
  - Shell layout
  - Random layout
 - **Community Detection**: Automatic detection and visualization of graph community structures
 - **Interactive Controls**:
  - WASD + QE keys for camera movement
  - Right mouse drag for view angle control
  - Node selection and highlighting
  - Adjustable node size and edge width
  - Configurable label display
  - Quick navigation between node connections
 ## Tech Stack
 - **imgui_bundle**: User interface
 - **ModernGL**: OpenGL graphics rendering
 - **NetworkX**: Graph data structures and algorithms
 - **NumPy**: Numerical computations
 - **community**: Community detection
 ## Usage
 1. **Launch the Program**:
   ```bash
   python -m pip install -r requirements.txt
   python graph_visualizer.py
   ```
 2. **Load Font**:
   - Place the font file `font.ttf` in the `assets` directory
   - Or modify the `CUSTOM_FONT` constant to use a different font file
 3. **Load Graph File**:
   - Click the "Load GraphML" button in the interface
   - Select a graph file in GraphML format
 4. **Interactive Controls**:
   - **Camera Movement**:
     - W: Move forward
     - S: Move backward
     - A: Move left
     - D: Move right
     - Q: Move up
     - E: Move down
   - **View Control**:
     - Hold right mouse button and drag to rotate view
   - **Node Interaction**:
     - Hover mouse to highlight nodes
     - Click to select nodes
 5. **Visualization Settings**:
   - Adjustable via UI control panel:
     - Layout type
     - Node size
     - Edge width
     - Label visibility
     - Label size
     - Background color
 ## Customization Options
 - **Node Scaling**: Adjust node size via `node_scale` parameter
 - **Edge Width**: Modify edge width using `edge_width` parameter
 - **Label Display**: Toggle label visibility with `show_labels`
 - **Label Size**: Adjust label size using `label_size`
 - **Label Color**: Set label color through `label_color`
 - **View Distance**: Control maximum label display distance with `label_culling_distance`
 ## Performance Optimizations
 - Efficient graphics rendering using ModernGL
 - View distance culling for label display optimization
 - Community detection algorithms for optimized visualization of large-scale graphs
 ## System Requirements
 - Python 3.10+
 - Graphics card with OpenGL 3.3+ support
 - Supported Operating Systems: Windows/Linux/MacOS
--- a/extra/VisualizationTool/assets/place_font_here
+++ b/extra/VisualizationTool/assets/place_font_here
--- a/extra/VisualizationTool/graph_visualizer.py
+++ b/extra/VisualizationTool/graph_visualizer.py
--- a/extra/VisualizationTool/requirements.txt
+++ b/extra/VisualizationTool/requirements.txt
@@ -0,0 +1,8 @@
 imgui_bundle
 moderngl
 networkx
 numpy
 pyglm
 python-louvain
 scipy
 tk