nettracer3d 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

nettracer3d/nettracer.py

@@ -804,7 +804,7 @@ def threshold(arr, proportion, custom_rad = None):
 
         threshold_index = int(len(sorted_values) * proportion)
         threshold_value = sorted_values[threshold_index]
-        print(f"Thresholding as if smallest_radius as assigned {threshold_value}")
+        print(f"Thresholding as if smallest_radius was assigned {threshold_value}")
 
 
     mask = arr > threshold_value

nettracer3d/nettracer_gui.py

@@ -36,6 +36,7 @@ from threading import Lock
 from scipy import ndimage
 import os
 from . import painting
+from . import stats as net_stats
 
 
 
@@ -425,8 +426,6 @@ class ImageViewerWindow(QMainWindow):
         self.canvas.mpl_connect('button_release_event', self.on_mouse_release)
         self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
 
-        #self.canvas.mpl_connect('button_press_event', self.on_mouse_click)
-
         # Initialize measurement tracking
         self.measurement_points = []  # List to store point pairs
         self.angle_measurements = []  # NEW: List to store angle trios
@@ -879,6 +878,24 @@ class ImageViewerWindow(QMainWindow):
         elif self.scroll_direction > 0 and new_value <= self.slice_slider.maximum():
             self.slice_slider.setValue(new_value)
 
+    def evaluate_mini(self, mode = 'nodes'):
+        if mode == 'nodes':
+            if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
+                self.mini_overlay = True
+                self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+            else:
+                self.create_highlight_overlay(node_indices=self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+        elif mode == 'edges':
+
+            if self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2] > self.mini_thresh:
+                self.mini_overlay = True
+                self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+            else:
+                self.create_highlight_overlay(
+                    node_indices=self.clicked_values['nodes'], 
+                    edge_indices=self.clicked_values['edges']
+                )
+
     def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None, bounds = False):
         """
         Create a binary overlay highlighting specific nodes and/or edges using parallel processing.
@@ -1705,28 +1722,12 @@ class ImageViewerWindow(QMainWindow):
                 if edges:
                     edge_indices = filtered_df.iloc[:, 2].unique().tolist()
                     self.clicked_values['edges'] = edge_indices
-
-                    if self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2] > self.mini_thresh:
-                        self.mini_overlay = True
-                        self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                    else:
-                        self.create_highlight_overlay(
-                            node_indices=self.clicked_values['nodes'], 
-                            edge_indices=self.clicked_values['edges']
-                        )
+                    self.evaluate_mini(mode = 'edges')
                 else:
-                    if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
-                        self.mini_overlay = True
-                        self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                    else:
-                        self.create_highlight_overlay(
-                            node_indices=self.clicked_values['nodes'],
-                            edge_indices = self.clicked_values['edges']
-                    )
-            
+                    self.evaluate_mini()
                 
         except Exception as e:
-            print(f"Error processing neighbors: {e}")
+            print(f"Error showing neighbors: {e}")
 
     
     def handle_show_component(self, edges = False, nodes = True):
@@ -1797,23 +1798,10 @@ class ImageViewerWindow(QMainWindow):
             if edges:
                 edge_indices = filtered_df.iloc[:, 2].unique().tolist()
                 self.clicked_values['edges'] = edge_indices
-                if self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2] > self.mini_thresh:
-                    self.mini_overlay = True
-                    self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                else:
-                    self.create_highlight_overlay(
-                        node_indices=self.clicked_values['nodes'],
-                        edge_indices=edge_indices
-                    )
+                self.evaluate_mini(mode = 'edges')
             else:
-                if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
-                    self.mini_overlay = True
-                    self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                else:
-                    self.create_highlight_overlay(
-                        node_indices = self.clicked_values['nodes'],
-                        edge_indices = self.clicked_values['edges']
-                )
+                self.evaluate_mini()
+
 
         except Exception as e:
 
@@ -2640,9 +2628,9 @@ class ImageViewerWindow(QMainWindow):
                     self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
                     self.needs_mini = False
                 else:
-                    self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+                    self.evaluate_mini()
             else:
-                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+                self.evaluate_mini()
 
         
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -4569,6 +4557,8 @@ class ImageViewerWindow(QMainWindow):
         allstats_action.triggered.connect(self.stats)
         histos_action = stats_menu.addAction("Network Statistic Histograms")
         histos_action.triggered.connect(self.histos)
+        sig_action = stats_menu.addAction("Significance Testing")
+        sig_action.triggered.connect(self.sig_test)
         radial_action = stats_menu.addAction("Radial Distribution Analysis")
         radial_action.triggered.connect(self.show_radial_dialog)
         neighbor_id_action = stats_menu.addAction("Identity Distribution of Neighbors")
@@ -4913,6 +4903,16 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"Error creating histogram selector: {e}")
 
+    def sig_test(self):
+        # Get the existing QApplication instance
+        app = QApplication.instance()
+        
+        # Create the statistical GUI window without starting a new event loop
+        stats_window = net_stats.main(app)
+        
+        # Keep a reference so it doesn't get garbage collected
+        self.stats_window = stats_window
+
     def volumes(self):
 
 
@@ -5060,6 +5060,10 @@ class ImageViewerWindow(QMainWindow):
             dialog = MergeNodeIdDialog(self)
             dialog.exec()
 
+    def show_multichan_dialog(self, data):
+        dialog = MultiChanDialog(self, data)
+        dialog.show()
+
     def show_gray_water_dialog(self):
         """Show the gray watershed parameter dialog."""
         dialog = GrayWaterDialog(self)
@@ -5162,7 +5166,7 @@ class ImageViewerWindow(QMainWindow):
 
             my_network.edges = (my_network.nodes == 0) * my_network.edges
 
-            my_network.calculate_all(my_network.nodes, my_network.edges, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale, search = None, diledge = None, inners = False, hash_inners = False, remove_trunk = 0, ignore_search_region = True, other_nodes = None, label_nodes = True, directory = None, GPU = False, fast_dil = False, skeletonize = False, GPU_downsample = None)
+            my_network.calculate_all(my_network.nodes, my_network.edges, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale, search = None, diledge = None, inners = False, remove_trunk = 0, ignore_search_region = True, other_nodes = None, label_nodes = True, directory = None, GPU = False, fast_dil = False, skeletonize = False, GPU_downsample = None)
 
             self.load_channel(1, my_network.edges, data = True)
             self.load_channel(0, my_network.nodes, data = True)
@@ -5916,6 +5920,16 @@ class ImageViewerWindow(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
+    def confirm_multichan_dialog(self):
+        """Shows a dialog asking user to confirm if image is multichan"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Image Format Alert")
+        msg.setInformativeText("Is this a Multi-Channel (4D) image?")
+        msg.setWindowTitle("Confirm Image Format")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
+
     def confirm_resize_dialog(self):
         """Shows a dialog asking user to resize image"""
         msg = QMessageBox()
@@ -5999,7 +6013,7 @@ class ImageViewerWindow(QMainWindow):
             try:
                 if len(self.channel_data[channel_index].shape) == 3:  # potentially 2D RGB
                     if self.channel_data[channel_index].shape[-1] in (3, 4):  # last dim is 3 or 4
-                        if not data and self.shape is None:
+                        if not data:
                             if self.confirm_rgb_dialog():
                                 # User confirmed it's 2D RGB, expand to 4D
                                 self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
@@ -6009,12 +6023,18 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
-            if not color:
-                try:
-                    if len(self.channel_data[channel_index].shape) == 4 and (channel_index == 0 or channel_index == 1):
+            if len(self.channel_data[channel_index].shape) == 4:
+                if not self.channel_data[channel_index].shape[-1] in (3, 4):
+                    if self.confirm_multichan_dialog(): # User is trying to load 4D channel stack:
+                        my_data = copy.deepcopy(self.channel_data[channel_index])
+                        self.channel_data[channel_index] = None 
+                        self.show_multichan_dialog(data = my_data)
+                        return
+                elif not color and (channel_index == 0 or channel_index == 1):
+                    try:
                         self.channel_data[channel_index] = self.reduce_rgb_dimension(self.channel_data[channel_index], 'weight')
-                except:
-                    pass
+                    except:
+                        pass
 
             reset_resize = False
 
@@ -8431,6 +8451,89 @@ class MergeNodeIdDialog(QDialog):
             print(traceback.format_exc())
             #print(f"Error: {e}")
 
+class MultiChanDialog(QDialog):
+
+    def __init__(self, parent=None, data = None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Channel Loading")
+        self.setModal(False)
+        
+        layout = QFormLayout(self)
+
+        self.data = data
+
+        self.nodes = QComboBox()
+        self.edges = QComboBox()
+        self.overlay1 = QComboBox()
+        self.overlay2 = QComboBox()
+        options = ["None"]
+        for i in range(self.data.shape[0]):
+            options.append(str(i))
+        self.nodes.addItems(options)
+        self.edges.addItems(options)
+        self.overlay1.addItems(options)
+        self.overlay2.addItems(options)
+        self.nodes.setCurrentIndex(0)
+        self.edges.setCurrentIndex(0)
+        self.overlay1.setCurrentIndex(0)
+        self.overlay2.setCurrentIndex(0)
+        layout.addRow("Load this channel into nodes?", self.nodes)
+        layout.addRow("Load this channel into edges?", self.edges)
+        layout.addRow("Load this channel into overlay1?", self.overlay1)
+        layout.addRow("Load this channel into overlay2?", self.overlay2)
+
+        run_button = QPushButton("Load Channels")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+        run_button2 = QPushButton("Save Channels to Directory")
+        run_button2.clicked.connect(self.run2)
+        layout.addWidget(run_button2)
+
+
+    def run(self):
+
+        try:
+            node_chan = int(self.nodes.currentText())
+            self.parent().load_channel(0, self.data[node_chan, :, :, :], data = True)
+        except:
+            pass
+        try:
+            edge_chan = int(self.edges.currentText())
+            self.parent().load_channel(1, self.data[edge_chan, :, :, :], data = True)
+        except:
+            pass
+        try:
+            overlay1_chan = int(self.overlay1.currentText())
+            self.parent().load_channel(2, self.data[overlay1_chan, :, :, :], data = True)
+        except:
+            pass
+        try:
+            overlay2_chan = int(self.overlay2.currentText())
+            self.parent().load_channel(3, self.data[overlay2_chan, :, :, :], data = True)
+        except:
+            pass
+
+    def run2(self):
+
+        try:
+            # First let user select parent directory
+            parent_dir = QFileDialog.getExistingDirectory(
+                self,
+                "Select Location to Save Channels",
+                "",
+                QFileDialog.Option.ShowDirsOnly
+            )
+
+            for i in range(self.data.shape[0]):
+                try:
+                    tifffile.imwrite(f'{parent_dir}/C{i}.tif', self.data[i, :, :, :])
+                except:
+                    continue
+        except:
+            pass
+
 
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
@@ -10513,6 +10616,9 @@ class MotherDialog(QDialog):
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error finding mothers: {e}")
 
 
@@ -12257,7 +12363,7 @@ class ThresholdWindow(QMainWindow):
         button_layout.addWidget(run_button)
         
         # Add Cancel button for external dialog use
-        cancel_button = QPushButton("Cancel/Skip")
+        cancel_button = QPushButton("Cancel/Skip (Retains Selection)")
         cancel_button.clicked.connect(self.cancel_processing)
         button_layout.addWidget(cancel_button)
         

nettracer3d/segmenter.py

@@ -1181,12 +1181,22 @@ class InteractiveSegmenter:
                                                (x[0][2] - curr_x) ** 2))
                     return nearest[0]
             else:
-                # 3D chunks: use existing center-based distance calculation
-                nearest = min(unprocessed_chunks, 
+                # 3D chunks: find chunks on nearest Z-plane, then closest in X/Y
+                # First find the nearest Z-plane among available chunks
+                nearest_z = min(unprocessed_chunks, 
+                               key=lambda x: abs(x[1]['center'][0] - curr_z))[1]['center'][0]
+                
+                # Get all chunks on that nearest Z-plane
+                nearest_z_chunks = [chunk for chunk in unprocessed_chunks 
+                                   if chunk[1]['center'][0] == nearest_z]
+                
+                # From those chunks, find closest in X/Y
+                nearest = min(nearest_z_chunks, 
                              key=lambda x: sum((a - b) ** 2 for a, b in 
-                                             zip(x[1]['center'], (curr_z, curr_y, curr_x))))
+                                             zip(x[1]['center'][1:], (curr_y, curr_x))))
+                
                 return nearest[0]
-            
+                        
             return None
         
         while True:
@@ -1284,12 +1294,14 @@ class InteractiveSegmenter:
         
         return foreground_features, background_features
 
-    def compute_3d_chunks(self, chunk_size=None):
+    def compute_3d_chunks(self, chunk_size=None, thickness=49):
         """
-        Compute 3D chunks with consistent logic across all operations.
+        Compute 3D chunks as rectangular prisms with consistent logic across all operations.
+        Creates chunks that are thin in Z and square-like in X/Y dimensions.
         
         Args:
-            chunk_size: Optional chunk size, otherwise uses dynamic calculation
+            chunk_size: Optional chunk size for volume calculation, otherwise uses dynamic calculation
+            thickness: Z-dimension thickness of chunks (default: 9)
             
         Returns:
             list: List of chunk coordinates [z_start, z_end, y_start, y_end, x_start, x_end]
@@ -1313,27 +1325,57 @@ class InteractiveSegmenter:
         except:
             depth, height, width, rgb = self.image_3d.shape
         
-        # Calculate chunk grid dimensions
-        z_chunks = (depth + chunk_size - 1) // chunk_size
-        y_chunks = (height + chunk_size - 1) // chunk_size
-        x_chunks = (width + chunk_size - 1) // chunk_size
+        # Calculate target volume per chunk (same as original cube)
+        target_volume = chunk_size ** 3
+        
+        # Calculate XY side length based on thickness and target volume
+        # Volume = thickness * xy_side * xy_side
+        # So xy_side = sqrt(volume / thickness)
+        xy_side = int(np.sqrt(target_volume / thickness))
+        xy_side = max(1, xy_side)  # Ensure minimum size of 1
         
-        # Generate all chunk start positions
-        chunk_starts = np.array(np.meshgrid(
-            np.arange(z_chunks) * chunk_size,
-            np.arange(y_chunks) * chunk_size,
-            np.arange(x_chunks) * chunk_size,
-            indexing='ij'
-        )).reshape(3, -1).T
+        # Calculate actual chunk dimensions for grid calculation
+        z_chunk_size = thickness
+        xy_chunk_size = xy_side
         
-        # Create chunk coordinate list
+        # Calculate number of chunks in each dimension
+        z_chunks = (depth + z_chunk_size - 1) // z_chunk_size
+        y_chunks = (height + xy_chunk_size - 1) // xy_chunk_size
+        x_chunks = (width + xy_chunk_size - 1) // xy_chunk_size
+        
+        # Calculate actual chunk sizes to distribute remainder evenly
+        # This ensures all chunks are roughly the same size
+        z_sizes = np.full(z_chunks, depth // z_chunks)
+        z_remainder = depth % z_chunks
+        z_sizes[:z_remainder] += 1
+        
+        y_sizes = np.full(y_chunks, height // y_chunks)
+        y_remainder = height % y_chunks
+        y_sizes[:y_remainder] += 1
+        
+        x_sizes = np.full(x_chunks, width // x_chunks)
+        x_remainder = width % x_chunks
+        x_sizes[:x_remainder] += 1
+        
+        # Calculate cumulative positions
+        z_positions = np.concatenate([[0], np.cumsum(z_sizes)])
+        y_positions = np.concatenate([[0], np.cumsum(y_sizes)])
+        x_positions = np.concatenate([[0], np.cumsum(x_sizes)])
+        
+        # Generate all chunk coordinates
         chunks = []
-        for z_start, y_start, x_start in chunk_starts:
-            z_end = min(z_start + chunk_size, depth)
-            y_end = min(y_start + chunk_size, height)
-            x_end = min(x_start + chunk_size, width)
-            coords = [z_start, z_end, y_start, y_end, x_start, x_end]
-            chunks.append(coords)
+        for z_idx in range(z_chunks):
+            for y_idx in range(y_chunks):
+                for x_idx in range(x_chunks):
+                    z_start = z_positions[z_idx]
+                    z_end = z_positions[z_idx + 1]
+                    y_start = y_positions[y_idx]
+                    y_end = y_positions[y_idx + 1]
+                    x_start = x_positions[x_idx]
+                    x_end = x_positions[x_idx + 1]
+                    
+                    coords = [z_start, z_end, y_start, y_end, x_start, x_end]
+                    chunks.append(coords)
         
         return chunks
 

nettracer3d/segmenter_GPU.py

@@ -1055,19 +1055,18 @@ class InteractiveSegmenter:
         self.realtimechunks = chunk_dict
         print("Ready!")
 
-    def compute_3d_chunks(self, chunk_size=None):
+    def compute_3d_chunks(self, chunk_size=None, thickness=49):
         """
-        Compute 3D chunks with consistent logic across all operations (GPU version).
+        Compute 3D chunks as rectangular prisms with consistent logic across all operations.
+        Creates chunks that are thin in Z and square-like in X/Y dimensions.
         
         Args:
-            chunk_size: Optional chunk size, otherwise uses dynamic calculation
+            chunk_size: Optional chunk size for volume calculation, otherwise uses dynamic calculation
+            thickness: Z-dimension thickness of chunks (default: 9)
             
         Returns:
             list: List of chunk coordinates [z_start, z_end, y_start, y_end, x_start, x_end]
         """
-        import cupy as cp
-        import multiprocessing
-        
         # Use consistent chunk size calculation
         if chunk_size is None:
             if hasattr(self, 'master_chunk') and self.master_chunk is not None:
@@ -1075,10 +1074,10 @@ class InteractiveSegmenter:
             else:
                 # Dynamic calculation (same as segmentation)
                 total_cores = multiprocessing.cpu_count()
-                total_volume = cp.prod(cp.array(self.image_3d.shape))
+                total_volume = np.prod(self.image_3d.shape)
                 target_volume_per_chunk = total_volume / (total_cores * 4)
                 
-                chunk_size = int(cp.cbrt(target_volume_per_chunk))
+                chunk_size = int(np.cbrt(target_volume_per_chunk))
                 chunk_size = max(16, min(chunk_size, min(self.image_3d.shape) // 2))
                 chunk_size = ((chunk_size + 7) // 16) * 16
         
@@ -1087,28 +1086,57 @@ class InteractiveSegmenter:
         except:
             depth, height, width, rgb = self.image_3d.shape
         
-        # Calculate chunk grid dimensions
-        z_chunks = (depth + chunk_size - 1) // chunk_size
-        y_chunks = (height + chunk_size - 1) // chunk_size
-        x_chunks = (width + chunk_size - 1) // chunk_size
+        # Calculate target volume per chunk (same as original cube)
+        target_volume = chunk_size ** 3
+        
+        # Calculate XY side length based on thickness and target volume
+        # Volume = thickness * xy_side * xy_side
+        # So xy_side = sqrt(volume / thickness)
+        xy_side = int(np.sqrt(target_volume / thickness))
+        xy_side = max(1, xy_side)  # Ensure minimum size of 1
+        
+        # Calculate actual chunk dimensions for grid calculation
+        z_chunk_size = thickness
+        xy_chunk_size = xy_side
+        
+        # Calculate number of chunks in each dimension
+        z_chunks = (depth + z_chunk_size - 1) // z_chunk_size
+        y_chunks = (height + xy_chunk_size - 1) // xy_chunk_size
+        x_chunks = (width + xy_chunk_size - 1) // xy_chunk_size
+        
+        # Calculate actual chunk sizes to distribute remainder evenly
+        # This ensures all chunks are roughly the same size
+        z_sizes = np.full(z_chunks, depth // z_chunks)
+        z_remainder = depth % z_chunks
+        z_sizes[:z_remainder] += 1
         
-        # Generate all chunk start positions using CuPy
-        chunk_starts = cp.array(cp.meshgrid(
-            cp.arange(z_chunks) * chunk_size,
-            cp.arange(y_chunks) * chunk_size,
-            cp.arange(x_chunks) * chunk_size,
-            indexing='ij'
-        )).reshape(3, -1).T
+        y_sizes = np.full(y_chunks, height // y_chunks)
+        y_remainder = height % y_chunks
+        y_sizes[:y_remainder] += 1
         
+        x_sizes = np.full(x_chunks, width // x_chunks)
+        x_remainder = width % x_chunks
+        x_sizes[:x_remainder] += 1
         
-        # Create chunk coordinate list
+        # Calculate cumulative positions
+        z_positions = np.concatenate([[0], np.cumsum(z_sizes)])
+        y_positions = np.concatenate([[0], np.cumsum(y_sizes)])
+        x_positions = np.concatenate([[0], np.cumsum(x_sizes)])
+        
+        # Generate all chunk coordinates
         chunks = []
-        for z_start, y_start, x_start in chunk_starts:
-            z_end = min(z_start + chunk_size, depth)
-            y_end = min(y_start + chunk_size, height)
-            x_end = min(x_start + chunk_size, width)
-            coords = [int(z_start), int(z_end), int(y_start), int(y_end), int(x_start), int(x_end)]
-            chunks.append(coords)
+        for z_idx in range(z_chunks):
+            for y_idx in range(y_chunks):
+                for x_idx in range(x_chunks):
+                    z_start = z_positions[z_idx]
+                    z_end = z_positions[z_idx + 1]
+                    y_start = y_positions[y_idx]
+                    y_end = y_positions[y_idx + 1]
+                    x_start = x_positions[x_idx]
+                    x_end = x_positions[x_idx + 1]
+                    
+                    coords = [z_start, z_end, y_start, y_end, x_start, x_end]
+                    chunks.append(coords)
         
         return chunks
 
@@ -1196,10 +1224,20 @@ class InteractiveSegmenter:
                                                (x[0][2] - curr_x) ** 2))
                     return nearest[0]
             else:
-                # 3D chunks: use existing center-based distance calculation
-                nearest = min(unprocessed_chunks, 
+                # 3D chunks: find chunks on nearest Z-plane, then closest in X/Y
+                # First find the nearest Z-plane among available chunks
+                nearest_z = min(unprocessed_chunks, 
+                               key=lambda x: abs(x[1]['center'][0] - curr_z))[1]['center'][0]
+                
+                # Get all chunks on that nearest Z-plane
+                nearest_z_chunks = [chunk for chunk in unprocessed_chunks 
+                                   if chunk[1]['center'][0] == nearest_z]
+                
+                # From those chunks, find closest in X/Y
+                nearest = min(nearest_z_chunks, 
                              key=lambda x: sum((a - b) ** 2 for a, b in 
-                                             zip(x[1]['center'], (curr_z, curr_y, curr_x))))
+                                             zip(x[1]['center'][1:], (curr_y, curr_x))))
+                
                 return nearest[0]
             
             return None