nettracer3d 1.3.1__py3-none-any.whl → 1.3.6__py3-none-any.whl

nettracer3d/network_graph_widget.py

@@ -8,6 +8,8 @@ from PyQt6.QtGui import QColor, QPen, QBrush
 import pyqtgraph as pg
 from pyqtgraph import ScatterPlotItem, PlotCurveItem, GraphicsLayoutWidget, ROI
 import colorsys
+import random
+import copy
 
 
 class GraphLoadThread(QThread):
@@ -15,7 +17,8 @@ class GraphLoadThread(QThread):
     finished = pyqtSignal(object)  # Emits the computed layout data
     
     def __init__(self, graph, geometric, component, centroids, communities, 
-                 community_dict, identities, identity_dict, weight, z_size):
+                 community_dict, identities, identity_dict, weight, z_size,
+                 shell, node_size, edge_size):
         super().__init__()
         self.graph = graph
         self.geometric = geometric
@@ -27,6 +30,9 @@ class GraphLoadThread(QThread):
         self.identity_dict = identity_dict
         self.weight = weight
         self.z_size = z_size
+        self.shell = shell
+        self.node_size = node_size
+        self.edge_size = edge_size
     
     def run(self):
         """Compute layout and colors in background thread"""
@@ -34,11 +40,7 @@ class GraphLoadThread(QThread):
         
         # Compute node positions
         if not self.geometric and not self.component:
-            n = len(self.graph.nodes())
-            if n < 500:
-                result['pos'] = nx.spring_layout(self.graph, seed=42, iterations=50)
-            else:
-                result['pos'] = self._compute_fast_spring_layout()
+            result['pos'] = self._compute_fast_spring_layout()
         elif self.geometric:
             result['pos'] = self._compute_geometric_layout()
         elif self.component:
@@ -72,14 +74,209 @@ class GraphLoadThread(QThread):
             return {}
         
         # For small graphs, use networkx (overhead is negligible)
-        if n < 200:
+        if n < 500 and not self.shell:
             return nx.spring_layout(self.graph, seed=42, iterations=50)
-        
+
         # Use fast vectorized implementation for larger graphs
         try:
-            return self._spring_layout_numpy(nodes, n)
+            if not self.shell:
+                return self._spring_layout_numpy(nodes, n)
+            else:
+                return self._shell_layout_numpy_super(nodes, n)
         except Exception as e:
-            return nx.spring_layout(self.graph, seed=42, iterations=15)
+            pass
+
+    def _shell_layout_numpy_super(self, nodes, n):
+        """
+        Shell layout with physically separated connected components
+        """        
+        np.random.seed(42)
+        
+        # Find connected components
+        components = list(nx.connected_components(self.graph))
+        
+        if len(components) == 1:
+            # Single component - compute shell layout directly with numpy
+            comp_nodes = nodes
+            
+            if n == 1:
+                return {nodes[0]: np.array([0.0, 0.0])}
+            
+            # Create node to index mapping
+            node_to_idx = {node: i for i, node in enumerate(nodes)}
+            
+            # Compute degree centrality using numpy
+            degrees = np.zeros(n)
+            for u, v in self.graph.edges():
+                if u in node_to_idx and v in node_to_idx:
+                    degrees[node_to_idx[u]] += 1
+                    degrees[node_to_idx[v]] += 1
+            
+            # Find most central node (highest degree)
+            central_idx = np.argmax(degrees)
+            central_node = nodes[central_idx]
+            
+            # Build adjacency list for BFS
+            adj_list = {node: [] for node in nodes}
+            for u, v in self.graph.edges():
+                if u in node_to_idx and v in node_to_idx:
+                    adj_list[u].append(v)
+                    adj_list[v].append(u)
+            
+            # Compute shells using BFS from central node
+            visited = set()
+            shells = []
+            current_shell = [central_node]
+            visited.add(central_node)
+            
+            while current_shell:
+                shells.append(current_shell[:])
+                next_shell = []
+                for node in current_shell:
+                    for neighbor in adj_list[node]:
+                        if neighbor not in visited:
+                            visited.add(neighbor)
+                            next_shell.append(neighbor)
+                current_shell = next_shell
+            
+            # Position nodes in concentric circles
+            pos = {}
+            radius = 1.0
+            
+            for shell_idx, shell in enumerate(shells):
+                if shell_idx == 0:
+                    # Center node at origin
+                    pos[shell[0]] = np.array([0.0, 0.0])
+                else:
+                    # Arrange nodes in circle at radius * shell_idx
+                    num_nodes = len(shell)
+                    angles = np.linspace(0, 2 * np.pi, num_nodes, endpoint=False)
+                    for i, node in enumerate(shell):
+                        x = radius * shell_idx * np.cos(angles[i])
+                        y = radius * shell_idx * np.sin(angles[i])
+                        pos[node] = np.array([x, y])
+            
+            # Center the layout
+            positions = np.array(list(pos.values()))
+            positions -= positions.mean(axis=0)
+            
+            return {node: positions[list(pos.keys()).index(node)] for node in nodes}
+        
+        # Multiple components - layout each component independently
+        component_layouts = []
+        component_bounds = []
+        
+        for component in components:
+            comp_nodes = list(component)
+            comp_n = len(comp_nodes)
+            
+            # Layout this component
+            comp_pos = self._layout_component_shell(comp_nodes, comp_n)
+            
+            # Calculate bounding box
+            positions = np.array(list(comp_pos.values()))
+            min_coords = positions.min(axis=0)
+            max_coords = positions.max(axis=0)
+            size = max_coords - min_coords
+            
+            component_layouts.append((comp_nodes, comp_pos))
+            component_bounds.append(size)
+        
+        # Arrange components in a grid with spacing
+        num_components = len(components)
+        grid_cols = int(np.ceil(np.sqrt(num_components)))
+        
+        # Calculate spacing based on largest component
+        max_width = max(bounds[0] for bounds in component_bounds)
+        max_height = max(bounds[1] for bounds in component_bounds)
+        spacing_x = max_width * 1.5  # 50% padding between components
+        spacing_y = max_height * 1.5
+        
+        # Place components in grid
+        final_positions = {}
+        for idx, (comp_nodes, comp_pos) in enumerate(component_layouts):
+            grid_x = idx % grid_cols
+            grid_y = idx // grid_cols
+            
+            # Calculate offset for this component
+            offset = np.array([grid_x * spacing_x, grid_y * spacing_y])
+            
+            # Apply offset to all nodes in component
+            for node in comp_nodes:
+                final_positions[node] = comp_pos[node] + offset
+        
+        # Center the entire layout
+        all_pos = np.array([final_positions[node] for node in nodes])
+        all_pos -= all_pos.mean(axis=0)
+        
+        return {node: all_pos[i] for i, node in enumerate(nodes)}
+
+    def _layout_component_shell(self, nodes, n):
+        """
+        Shell layout for a single component using numpy for centrality
+        """
+        if n == 1:
+            return {nodes[0]: np.array([0.0, 0.0])}
+        
+        # Create node to index mapping
+        node_to_idx = {node: i for i, node in enumerate(nodes)}
+        
+        # Compute degree centrality using numpy
+        degrees = np.zeros(n)
+        for u, v in self.graph.edges():
+            if u in node_to_idx and v in node_to_idx:
+                degrees[node_to_idx[u]] += 1
+                degrees[node_to_idx[v]] += 1
+        
+        # Find most central node (highest degree)
+        central_idx = np.argmax(degrees)
+        central_node = nodes[central_idx]
+        
+        # Build adjacency list for BFS
+        adj_list = {node: [] for node in nodes}
+        for u, v in self.graph.edges():
+            if u in node_to_idx and v in node_to_idx:
+                adj_list[u].append(v)
+                adj_list[v].append(u)
+        
+        # Compute shells using BFS from central node
+        visited = set()
+        shells = []
+        current_shell = [central_node]
+        visited.add(central_node)
+        
+        while current_shell:
+            shells.append(current_shell[:])
+            next_shell = []
+            for node in current_shell:
+                for neighbor in adj_list[node]:
+                    if neighbor not in visited:
+                        visited.add(neighbor)
+                        next_shell.append(neighbor)
+            current_shell = next_shell
+        
+        # Position nodes in concentric circles
+        pos = {}
+        radius = 1.0
+        
+        for shell_idx, shell in enumerate(shells):
+            if shell_idx == 0:
+                # Center node at origin
+                pos[shell[0]] = np.array([0.0, 0.0])
+            else:
+                # Arrange nodes in circle at radius * shell_idx
+                num_nodes = len(shell)
+                angles = np.linspace(0, 2 * np.pi, num_nodes, endpoint=False)
+                for i, node in enumerate(shell):
+                    x = radius * shell_idx * np.cos(angles[i])
+                    y = radius * shell_idx * np.sin(angles[i])
+                    pos[node] = np.array([x, y])
+        
+        # Center the layout
+        positions = np.array(list(pos.values()))
+        positions -= positions.mean(axis=0)
+        
+        return {node: positions[list(pos.keys()).index(node)] for node in nodes}
     
     def _spring_layout_numpy_super(self, nodes, n, iterations=50):
         """
@@ -331,7 +528,7 @@ class GraphLoadThread(QThread):
             return [{
                 'x': np.array(x_coords),
                 'y': np.array(y_coords),
-                'thickness': 1.0
+                'thickness': self.edge_size
             }]
         
         # Weight-based rendering - batch by thickness
@@ -345,8 +542,8 @@ class GraphLoadThread(QThread):
         
         # Define thickness bins (e.g., 10 discrete thickness levels)
         num_bins = 10
-        thickness_min = 0.5
-        thickness_max = 3.0  # Maximum thickness cap
+        thickness_min = self.edge_size/2
+        thickness_max = 3.0 * self.edge_size  # Maximum thickness cap
         
         # Batch edges by thickness bin
         edge_batches = {}  # {thickness: [(x_coords, y_coords), ...]}
@@ -356,7 +553,7 @@ class GraphLoadThread(QThread):
             if weight_range > 0:
                 normalized = (weight - min_weight) / weight_range
             else:
-                normalized = 0.5
+                normalized = self.edge_size/2
             
             # Calculate thickness with cap
             thickness = thickness_min + normalized * (thickness_max - thickness_min)
@@ -421,7 +618,7 @@ class GraphLoadThread(QThread):
     
     def _compute_all_node_sizes_vectorized(self, nodes):
         if not self.geometric or not self.centroids or not self.z_size:
-            return [10] * len(nodes)
+            return [self.node_size] * len(nodes)
 
         # GLOBAL z range (matches original behavior)
         all_z = np.array([
@@ -495,9 +692,7 @@ class GraphLoadThread(QThread):
         
         unique_communities = sorted(set(my_dict.values()))
         community_sizes = Counter(my_dict.values())
-        sorted_communities = sorted(unique_communities, 
-                                   key=lambda x: community_sizes[x], 
-                                   reverse=True)
+        sorted_communities = random.Random(42).sample(unique_communities, len(unique_communities))
         colors_rgb = self._generate_distinct_colors_rgb(len(unique_communities))
         color_map = {comm: colors_rgb[i] for i, comm in enumerate(sorted_communities)}
         if 0 in unique_communities:
@@ -539,7 +734,8 @@ class NetworkGraphWidget(QWidget):
     
     def __init__(self, parent=None, weight=False, geometric=False, component = False, 
                  centroids=None, communities=False, community_dict=None,
-                 identities=False, identity_dict=None, labels=False, z_size = False):
+                 identities=False, identity_dict=None, labels=False, z_size = False, 
+                 shell = False, node_size = 10, black_edges = False, edge_size = 1, popout = False):
         super().__init__(parent)
         
         self.parent_window = parent
@@ -553,6 +749,11 @@ class NetworkGraphWidget(QWidget):
         self.identity_dict = identity_dict or {}
         self.labels = labels
         self.z_size = z_size
+        self.shell = shell
+        self.node_size = node_size
+        self.black_edges = black_edges
+        self.edge_size = edge_size
+        self.popout = popout
         
         # Graph data
         self.graph = None
@@ -564,6 +765,7 @@ class NetworkGraphWidget(QWidget):
         self.label_items = {}
         self.label_data = []  # Store label data for on-demand rendering
         self.selected_nodes = set()
+        self.node_click = False
         self.rendered = False
         
         # CACHING for fast updates
@@ -629,7 +831,6 @@ class NetworkGraphWidget(QWidget):
         self.plot.addItem(self.loading_text)
         
         # Enable mouse tracking for area selection
-        self.plot.scene().sigMouseClicked.connect(self._on_plot_clicked)
         self.plot.scene().sigMouseMoved.connect(self._on_mouse_moved)
         
         # Disable default mouse interaction - will enable only in pan mode
@@ -644,6 +845,7 @@ class NetworkGraphWidget(QWidget):
         
         # Connect click events
         self.scatter.sigClicked.connect(self._on_node_clicked)
+        self.plot.scene().sigMouseClicked.connect(self._on_plot_clicked)
         
         # Connect view change for level-of-detail updates
         self.plot.sigRangeChanged.connect(self._on_view_changed)
@@ -702,10 +904,7 @@ class NetworkGraphWidget(QWidget):
             
             unique_identities = sorted(set(self.identity_dict.values()))
             community_sizes = Counter(self.identity_dict.values())
-            sorted_communities = sorted(unique_identities, 
-                                       key=lambda x: community_sizes[x], 
-                                       reverse=True)
-
+            sorted_communities = random.Random(42).sample(unique_identities, len(unique_identities))
             colors_rgb = _generate_distinct_colors_rgb(len(unique_identities))
             color_map = {comm: colors_rgb[i] for i, comm in enumerate(sorted_communities)}
             if 0 in unique_identities:
@@ -715,10 +914,7 @@ class NetworkGraphWidget(QWidget):
             
             unique_identities = sorted(set(self.community_dict.values()))
             community_sizes = Counter(self.community_dict.values())
-            sorted_communities = sorted(unique_identities, 
-                                       key=lambda x: community_sizes[x], 
-                                       reverse=True)
-
+            sorted_communities = random.Random(42).sample(unique_identities, len(unique_identities))
             colors_rgb = _generate_distinct_colors_rgb(len(unique_identities))
             color_map = {comm: colors_rgb[i] for i, comm in enumerate(sorted_communities)}
             if 0 in unique_identities:
@@ -852,6 +1048,7 @@ class NetworkGraphWidget(QWidget):
         self.clear_btn.setToolTip("Clear Graph")
         self.clear_btn.setMaximumSize(32, 32)
         self.clear_btn.clicked.connect(self._clear_graph)
+
         
         # Add buttons to layout
         panel_layout.addWidget(self.select_btn)
@@ -861,6 +1058,14 @@ class NetworkGraphWidget(QWidget):
         panel_layout.addWidget(self.refresh_btn)
         panel_layout.addWidget(self.settings_btn)
         panel_layout.addWidget(self.clear_btn)
+
+        if self.popout:
+            self.popout_btn = QPushButton("⤴")
+            self.popout_btn.setToolTip("Full Screen")
+            self.popout_btn.setMaximumSize(32, 32)
+            self.popout_btn.clicked.connect(self._popout_graph)
+            panel_layout.addWidget(self.popout_btn)
+
         panel_layout.addStretch()
         
         panel.setLayout(panel_layout)
@@ -906,6 +1111,7 @@ class NetworkGraphWidget(QWidget):
 
         # Clear existing visualization
         self._clear_graph()
+        self.get_properties()
 
         if hasattr(self, 'loading_text') and self.loading_text is not None:
             self.plot.removeItem(self.loading_text)
@@ -939,7 +1145,8 @@ class NetworkGraphWidget(QWidget):
         self.load_thread = GraphLoadThread(
             self.graph, self.geometric, self.component, self.centroids,
             self.communities, self.community_dict,
-            self.identities, self.identity_dict, self.weight, self.z_size
+            self.identities, self.identity_dict, self.weight, self.z_size,
+            self.shell, self.node_size, self.edge_size
         )
         self.load_thread.finished.connect(self._on_graph_loaded)
         self.load_thread.start()
@@ -992,6 +1199,7 @@ class NetworkGraphWidget(QWidget):
             self.select_nodes(self.parent_window.clicked_values['nodes'])
 
 
+
     def _render_prepared_data(self, result):
         """Render pre-computed data (minimal main thread work)"""
         # Clear old items
@@ -1002,6 +1210,11 @@ class NetworkGraphWidget(QWidget):
         for label_item in self.label_items.values():
             self.plot.removeItem(label_item)
         self.label_items.clear()
+
+        if self.black_edges:
+            edge_color = (0, 0, 0)
+        else:
+            edge_color = (150, 150, 150, 100)
         
         # Render edges - batched by weight for efficiency
         edge_batches = result['edge_pens']
@@ -1010,7 +1223,7 @@ class NetworkGraphWidget(QWidget):
                 edge_line = PlotCurveItem(
                     x=batch['x'],
                     y=batch['y'],
-                    pen=pg.mkPen(color=(150, 150, 150, 100), width=batch['thickness']),
+                    pen=pg.mkPen(color=edge_color, width=batch['thickness']),
                     connect='finite'  # Break lines at NaN
                 )
                 self.plot.addItem(edge_line)
@@ -1176,62 +1389,6 @@ class NetworkGraphWidget(QWidget):
         if self.label_data:
             self._update_labels_for_zoom()
     
-    def _render_edges(self, edges):
-        """Render edges with optional weight-based thickness (OPTIMIZED: single combined line)"""
-        # Remove old edges
-        for item in self.edge_items:
-            self.plot.removeItem(item)
-        self.edge_items.clear()
-        
-        if not edges:
-            return
-        
-        # Get weight range for normalization if using weights
-        if self.weight:
-            weights = [w for _, _, w in edges]
-            if len(weights) > 0:
-                min_weight = min(weights)
-                max_weight = max(weights)
-                weight_range = max_weight - min_weight if max_weight > min_weight else 1
-            else:
-                weight_range = 1
-                min_weight = 0
-        
-        # Combine all edges into single line with NaN separators
-        x_combined = []
-        y_combined = []
-        thicknesses = []
-        
-        for x, y, weight in edges:
-            if self.weight and 'weight_range' in locals() and weight_range > 0:
-                # Normalize weight to thickness range (0.5 - 3.0)
-                normalized = (weight - min_weight) / weight_range
-                thickness = 0.5 + normalized * 2.5
-            else:
-                thickness = 1.0
-            
-            thicknesses.append(thickness)
-            
-            # Add edge coordinates with NaN separator
-            x_combined.extend([x[0], x[1], np.nan])
-            y_combined.extend([y[0], y[1], np.nan])
-        
-        # Use average thickness
-        avg_thickness = np.mean(thicknesses) if thicknesses else 1.0
-        
-        # Create single line with all edges
-        edge_line = PlotCurveItem(
-            x=np.array(x_combined),
-            y=np.array(y_combined),
-            pen=pg.mkPen(color=(150, 150, 150, 100), width=avg_thickness),
-            connect='finite'
-        )
-        self.plot.addItem(edge_line)
-        self.edge_items.append(edge_line)
-        
-        # Ensure nodes are on top
-        self.scatter.setZValue(10)
-    
     def _hex_to_rgb(self, hex_color):
         """Convert hex color to RGB tuple"""
         hex_color = hex_color.lstrip('#')
@@ -1239,7 +1396,8 @@ class NetworkGraphWidget(QWidget):
     
     def _on_plot_clicked(self, ev):
         """Handle clicks on the plot background"""
-        if not self.selection_mode:
+        if not self.selection_mode or self.node_click or not self.popout:
+            self.node_click = False
             return
         
         # Only handle left button clicks
@@ -1249,12 +1407,6 @@ class NetworkGraphWidget(QWidget):
         # Get the position in scene coordinates
         scene_pos = ev.scenePos()
         
-        # Check if click was on a node (scatter will handle it)
-        items = self.plot.scene().items(scene_pos)
-        for item in items:
-            if item == self.scatter:
-                # Click was on scatter plot, let node handler deal with it
-                return
         
         # Click was on background
         modifiers = ev.modifiers()
@@ -1264,8 +1416,8 @@ class NetworkGraphWidget(QWidget):
             # Deselect all nodes
             self.selected_nodes.clear()
             self._render_nodes()
+            self.push_selection()
             self.node_selected.emit([])
-        
         # Ctrl+Click on background does nothing (as requested)
     
     def _on_mouse_moved(self, pos):
@@ -1284,6 +1436,7 @@ class NetworkGraphWidget(QWidget):
     def _start_area_selection(self, scene_pos):
         """Start area selection with rectangle"""
         self.is_area_selecting = True
+        self.node_click = False
         
         # Convert to view coordinates
         view_pos = self.plot.vb.mapSceneToView(scene_pos)
@@ -1456,6 +1609,7 @@ class NetworkGraphWidget(QWidget):
                     if delta_x > 10 or delta_y > 10:  # Moved significantly
                         self.click_timer.stop()
                         if not self.is_area_selecting:
+                            #if not self.was_in_selection_before_wheel or self.zoom_mode:
                             self._start_area_selection(self.last_mouse_pos)
 
         
@@ -1514,7 +1668,7 @@ class NetworkGraphWidget(QWidget):
         """End temporary panning mode"""
         self.temp_pan_active = False
         # Disable mouse if we're in selection mode
-        if self.selection_mode:
+        if self.selection_mode or self.zoom_mode:
             self.plot.setMouseEnabled(x=False, y=False)
     
     def _handle_wheel_in_selection(self, event):
@@ -1530,12 +1684,12 @@ class NetworkGraphWidget(QWidget):
             self.wheel_timer.setSingleShot(True)
             self.wheel_timer.timeout.connect(self._end_wheel_zoom)
         
-        # Restart timer (500ms after last wheel event)
-        self.wheel_timer.start(500)
+        # Restart timer
+        self.wheel_timer.start(1)
     
     def _end_wheel_zoom(self):
         """End wheel zoom and return to selection mode"""
-        if self.was_in_selection_before_wheel and self.selection_mode:
+        if self.was_in_selection_before_wheel and (self.selection_mode or self.zoom_mode):
             self.plot.setMouseEnabled(x=False, y=False)
             self.was_in_selection_before_wheel = False
     
@@ -1586,7 +1740,10 @@ class NetworkGraphWidget(QWidget):
         x_max, y_max = pos_array.max(axis=0)
         
         # Add padding
-        padding = 0.1
+        if self.shell or self.component:
+            padding = 0.75
+        else:
+            padding = 0.1
         x_range = x_max - x_min
         y_range = y_max - y_min
         
@@ -1679,6 +1836,32 @@ class NetworkGraphWidget(QWidget):
 
         self.loading_text.setPos(0, 0)  # Center of view
         self.plot.addItem(self.loading_text)
+
+    def _popout_graph(self):
+
+        temp_graph_widget = NetworkGraphWidget(
+            parent=self.parent_window,
+            weight=self.weight,
+            geometric=self.geometric,
+            component = self.component,
+            centroids=self.centroids,
+            communities=self.communities,
+            community_dict=self.community_dict,
+            labels=self.labels,
+            identities = self.identities,
+            identity_dict = self.identity_dict,
+            z_size = self.z_size,
+            shell = self.shell,
+            node_size = self.node_size,
+            black_edges = self.black_edges,
+            edge_size = self.edge_size
+        )
+
+        temp_graph_widget.set_graph(self.graph)
+        temp_graph_widget.show_in_window(title="Network Graph", width=1000, height=800)
+        temp_graph_widget.load_graph()
+        self.parent_window.temp_graph_widgets.append(temp_graph_widget)
+
     
     def select_nodes(self, nodes, add_to_selection=False):
         """
@@ -1734,10 +1917,12 @@ class NetworkGraphWidget(QWidget):
             # Clear previous selection and select only this node
             self.selected_nodes.clear()
             self.selected_nodes.add(clicked_node)
+
         self.push_selection()
         
         # Update visual representation
         self._render_nodes()
+        self.node_click = True
         
         # Emit signal with all selected nodes
         self.node_selected.emit(list(self.selected_nodes))
@@ -1777,6 +1962,8 @@ class NetworkGraphWidget(QWidget):
                 print(f"Found node {val} at [Z,Y,X] -> {centroid}")
                 self.push_selection()
         except:
+            import traceback
+            traceback.print_exc()
             pass
 
 
@@ -1847,6 +2034,11 @@ class NetworkGraphWidget(QWidget):
                 )
 
 
+    def get_properties(self):
+
+        self.parent_window.update_graph_fields()
+
+
     def create_context_menu(self, event):
         # Get the index at the clicked position
         # Create context menu
@@ -1898,7 +2090,7 @@ class NetworkGraphWidget(QWidget):
     
     def update_params(self, weight=None, geometric=None, component = None, centroids=None,
                      communities=None, community_dict=None,
-                     identities=None, identity_dict=None, labels=None, z_size = None):
+                     identities=None, identity_dict=None, labels=None, z_size = None, shell = None, node_size = 10):
         """Update visualization parameters"""
         if weight is not None:
             self.weight = weight
@@ -1920,6 +2112,10 @@ class NetworkGraphWidget(QWidget):
             self.labels = labels
         if z_size is not None:
             self.z_size = z_size
+        if shell is not None:
+            self.shell = shell
+        if node_size is not None:
+            self.node_size = node_size
     
     def _on_view_changed(self):
         """Handle view range changes for level-of-detail adjustments"""
@@ -1978,6 +2174,11 @@ class NetworkGraphWidget(QWidget):
             edge_alpha = min(150, int(100 + self.current_zoom_factor * 10))
         else:
             edge_alpha = 100
+
+        if self.black_edges:
+            edge_color = (0, 0, 0)
+        else:
+            edge_color = (150, 150, 150, edge_alpha)
         
         # Update edge rendering (batched edge items)
         if self.edge_items:
@@ -1985,7 +2186,7 @@ class NetworkGraphWidget(QWidget):
                 current_pen = edge_item.opts['pen']
                 if current_pen is not None:
                     width = current_pen.widthF()
-                    new_pen = pg.mkPen(color=(150, 150, 150, edge_alpha), width=width)
+                    new_pen = pg.mkPen(color=edge_color, width=width)
                     edge_item.setPen(new_pen)
         
         # Update labels based on zoom level

nettracer3d/segmenter.py

@@ -1380,7 +1380,7 @@ class InteractiveSegmenter:
         return chunks
 
     def train_batch(self, foreground_array, speed=True, use_gpu=False, use_two=False, mem_lock=False, saving=False):
-        """Updated train_batch with chunked 2D processing"""
+        """Train model for batch of arrays"""
 
         if not saving:
             print("Training model...")