nettracer3d 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

nettracer3d/nettracer.py

@@ -10,7 +10,10 @@ import multiprocessing as mp
 import os
 import copy
 import statistics as stats
-import plotly.graph_objects as go
+try:
+    import napari
+except:
+    pass
 import networkx as nx
 from scipy.signal import find_peaks
 try:
@@ -396,7 +399,7 @@ def upsample_with_padding(data, factor=None, original_shape=None):
         raise ValueError("original_shape must be provided")
         
     # Handle 4D color arrays
-    is_color = len(data.shape) == 4 and data.shape[-1] == 3
+    is_color = len(data.shape) == 4 and (data.shape[-1] == 3 or data.shape[-1] == 4)
     if is_color:
         # Split into separate color channels
         channels = [data[..., i] for i in range(3)]
@@ -623,6 +626,65 @@ def threshold(arr, proportion, custom_rad = None):
 
     return arr
 
+def show_3d(arrays_3d=None, arrays_4d=None, down_factor=None, order=0, xy_scale=1, z_scale=1, colors=['red', 'green', 'white', 'cyan', 'yellow']):
+    """
+    Show 3d (or 2d) displays of array data using napari.
+    Params: arrays - A list of 3d or 2d numpy arrays to display
+    down_factor (int) - Optional downsampling factor to speed up display
+    """
+    import os
+    # Force PyQt6 usage to avoid binding warning
+    os.environ['QT_API'] = 'pyqt6'
+    
+    import napari
+    from qtpy.QtWidgets import QApplication
+
+    if down_factor is not None:
+        # Downsample arrays if specified
+        arrays_3d = [downsample(array, down_factor, order=order) for array in arrays_3d] if arrays_3d is not None else None
+        arrays_4d = [downsample(array, down_factor, order=order) for array in arrays_4d] if arrays_4d is not None else None
+    
+    viewer = napari.Viewer(ndisplay=3)
+    scale = [z_scale, xy_scale, xy_scale]  # [z, y, x] order for napari
+    
+    # Add 3D arrays if provided
+    if arrays_3d is not None:
+        for arr, color in zip(arrays_3d, colors):
+            viewer.add_image(
+                arr,
+                scale=scale,
+                colormap=color,
+                rendering='mip',
+                blending='additive',
+                opacity=0.5,
+                name=f'Channel_{color}'
+            )
+        
+    if arrays_4d is not None:
+        for i, arr in enumerate(arrays_4d):
+            # Check if the last dimension is 3 (RGB) or 4 (RGBA)
+            if arr.shape[-1] not in [3, 4]:
+                print(f"Warning: Array {i} doesn't appear to be RGB/RGBA. Skipping.")
+                continue
+                
+            if arr.shape[3] == 4:
+                arr = arr[:, :, :, :3]  # Remove alpha
+            
+            # Add each color channel separately
+            colors = ['red', 'green', 'blue']
+            for c in range(3):
+                viewer.add_image(
+                    arr[:,:,:,c],  # Take just one color channel
+                    scale=scale,
+                    colormap=colors[c],  # Use corresponding color
+                    rendering='mip',
+                    blending='additive',
+                    opacity=0.5,
+                    name=f'Channel_{colors[c]}_{i}'
+                )
+
+    napari.run()
+
 def z_project(array3d, method='max'):
     """
     Project a 3D numpy array along the Z axis to create a 2D array.
@@ -733,6 +795,18 @@ def fill_holes_3d(array):
 def resize(array, factor, order = 0):
     """Simply resizes an array by a factor"""
 
+    if len(array.shape) == 4:  # presumably this is a color image
+        processed_arrays = []
+        for i in range(array.shape[3]):  # iterate through the color dimension
+            color_array = array[:, :, :, i]  # get 3D array for each color channel
+            processed_color = zoom(color_array, (factor), order = order)
+
+            processed_arrays.append(processed_color)
+        
+        # Stack them back together along the 4th dimension
+        result = np.stack(processed_arrays, axis=3)
+        return result
+
     array = zoom(array, (factor), order = order)
 
     return array
@@ -748,103 +822,6 @@ def _rescale(array, original_shape, xy_scale, z_scale):
             array = zoom(array, (1, z_scale/xy_scale, z_scale/xy_scale))
     return array
 
-def visualize_3D(array, other_arrays=None, xy_scale = 1, z_scale = 1):
-    """
-    Mostly internal method for 3D visualization, although can be run directly on tif files to view them. Uses plotly to visualize
-    a 3D, binarized isosurface of data. Note this method likely requires downsampling on objects before running.
-    :param array: (Mandatory; string or ndarray) - Either a path to a .tif file to visualize in 3D binary, or a ndarray of the same.
-    :param other_arrays: (Optional - Val = None; string, ndarray, or list) - Either a path to a an additional .tif file to visualize in 3D binary or an ndarray containing the same,
-    or otherwise a path to a directory containing ONLY other .tif files to visualize, or a list of ndarrays containing the same.
-    :param xy_scale: (Optional - Val = 1; float) - The xy pixel scaling of an image to visualize.
-    :param z_scale: (Optional - Val = 1; float) - The z voxel depth of an image to visualize.
-    """
-
-    if isinstance(array, str):
-        array = tifffile.imread(array)
-
-    original_shape = array.shape[1]
-
-    array = _rescale(array, original_shape, xy_scale, z_scale)
-    array = binarize(array)
-
-    # Create a meshgrid for coordinates
-    x, y, z = np.indices(array.shape)
-
-    # Create a figure
-    fig = go.Figure()
-
-    # Plot the main array
-    _plot_3D(fig, x, y, z, array, 'red')
-
-    if other_arrays is not None and ((type(other_arrays) == str) or (type(other_arrays) == list)):
-        try: #Presume single tif
-            array = tifffile.imread(other_arrays)
-            if array.shape[1] != original_shape:
-                array = downsample(array, array.shape[1]/original_shape)
-            array = _rescale(array, original_shape, xy_scale, z_scale)
-            array = binarize(array)
-            _plot_3D(fig, x, y, z, array, 'green')
-        except: #presume directory or list
-            basic_colors = ['blue', 'yellow', 'cyan', 'magenta', 'black', 'white', 'gray', 'orange', 'brown', 'pink', 'purple', 'lime', 'teal', 'navy', 'maroon', 'olive', 'silver', 'red', 'green']
-            try: #presume directory
-                arrays = directory_info(other_arrays)
-                directory = other_arrays
-            except: #presume list
-                arrays = other_arrays
-            for i, array_path in enumerate(arrays): 
-                try: #presume tif
-                    array = tifffile.imread(f"{directory}/{array_path}")
-                    if array.shape[1] != original_shape:
-                        array = downsample(array, array.shape[1]/original_shape)
-                    array = _rescale(array, original_shape, xy_scale, z_scale)
-                    array = binarize(array)
-                except: #presume array
-                    array = array_path
-                    del array_path
-                    if array is not None:
-                        if array.shape[1] != original_shape:
-                            array = downsample(array, array.shape[1]/original_shape)
-                        array = _rescale(array, original_shape, xy_scale, z_scale)
-                        array = binarize(array)
-                color = basic_colors[i % len(basic_colors)]  # Ensure color index wraps around if more arrays than colors
-                if array is not None:
-                    _plot_3D(fig, x, y, z, array, color)
-    else:
-        try:
-            other_arrays = _rescale(other_arrays, original_shape, xy_scale, z_scale)
-            other_arrays = binarize(other_arrays)
-            _plot_3D(fig, x, y, z, other_arrays, 'green')
-        except:
-            pass
-
-    # Set the layout for better visualization
-    fig.update_layout(scene=dict(
-        xaxis_title='Z Axis',
-        yaxis_title='Y Axis',
-        zaxis_title='X Axis'
-    ))
-
-    fig.show()
-
-def _plot_3D(fig, x, y, z, array, color):
-    """Internal method used for 3D visualization"""
-    # Define the isosurface level
-    level = 0.5  
-
-    # Add the isosurface to the figure
-    fig.add_trace(go.Isosurface(
-        x=x.flatten(),
-        y=y.flatten(),
-        z=z.flatten(),
-        value=array.flatten(),
-        isomin=level,
-        isomax=level,
-        opacity=0.6,  # Adjust opacity
-        surface_count=1,  # Show only the isosurface
-        colorscale=[[0, color], [1, color]],  # Set uniform color
-        showscale=False  # Hide color scale bar
-    ))
-
 
 def remove_trunk(edges):
     """
@@ -1380,6 +1357,17 @@ def downsample(data, factor, directory=None, order=0):
         data = tifffile.imread(data)
     else:
         data2 = None
+
+    if len(data.shape) == 4:  # presumably this is a color image
+        processed_arrays = []
+        for i in range(data.shape[3]):  # iterate through the color dimension
+            color_array = data[:, :, :, i]  # get 3D array for each color channel
+            processed_color = downsample(color_array, factor, directory = None, order = order) #right now this is only for internal use - color array downsampling that is
+            processed_arrays.append(processed_color)
+        
+        # Stack them back together along the 4th dimension
+        result = np.stack(processed_arrays, axis=3)
+        return result
     
     # Check if Z dimension is too small relative to downsample factor
     if data.ndim == 3 and data.shape[0] < factor * 4:
@@ -1389,6 +1377,7 @@ def downsample(data, factor, directory=None, order=0):
     else:
         zoom_factors = 1/factor
 
+
     # Apply downsampling
     data = zoom(data, zoom_factors, order=order)
     
@@ -1524,7 +1513,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None):
     """
     Can be used to label branches a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -1546,7 +1535,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         array = downsample(array, down_factor)
         arrayshape = array.shape
     else:
-        arrayshape = bonus_array.shape
+        arrayshape = arrayshape
 
 
     if nodes is None:
@@ -1564,6 +1553,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         array = upsample_with_padding(array, down_factor, arrayshape)
 
 
+
     if nodes is None:
 
         array = smart_dilate.smart_label(array, other_array, GPU = GPU)
@@ -1594,7 +1584,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     return array
 
-def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False):
+def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False, order = 0):
     """
     Can be used to label vertices (where multiple branches connect) a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
     Note that this can be used in tandem with an edge segmentation to create an image containing 'pseudo-nodes', meaning we can make a network out of just a single edge file.
@@ -1616,7 +1606,9 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     if down_factor > 0:
         array_shape = array.shape
-        array = downsample(array, down_factor)
+        array = downsample(array, down_factor, order)
+        if order == 3:
+            array = binarize(array)
 
     array = array > 0
 
@@ -3738,81 +3730,6 @@ class Network_3D:
 
 
 
-    #Methods relating to visualizing elements of the network in 3D
-
-    def show_3D(self, other_arrays = None, down_factor = 1):
-        """
-        Allows the Network_3D object to be visualized in 3D using plotly. By default, this will show the nodes and edges properties. All arrays involved will be made binary. 
-        Note that nettracer_3D is not primarily a 3D visualization tool, so the funcionality of this method is limited, and additionally it should really only be run on downsampled data.
-        :param other_arrays: (Optional - Val = None; string). A filepath to additional .tif files (or a directory containing only .tif files) to show alongside the Network_3D object, for example a node_indicies or network_lattice overlay. 
-        :param down_factor: (Optional - Val = 1; int). A downsampling factor to speed up showing the 3D display and improve processing. Note that ALL arrays being shown will be subject
-        to this downsample factor. If you have files to be shown alongside the Network_3D object that were ALREADY downsampled, instead downsample the Network_3D object FIRST and pass nothing to this value.
-        If arrays are sized to different shapes while show_3D() is being called, there may be unusual results.
-        """
-        if down_factor > 1:
-            xy_scale = down_factor * self._xy_scale
-            z_scale = down_factor * self._z_scale
-            try:
-                nodes = downsample(self._nodes, down_factor, order = 3)
-                nodes = binarize(nodes)
-            except:
-                pass
-            try:
-                edges = downsample(self._edges, down_factor, order = 3)
-                edges = binarize(edges)
-            except:
-                edges = None
-            try:
-                if not isinstance(other_arrays, np.ndarray):
-                    other_arrays = tifffile.imread(other_arrays)
-                if other_arrays.shape == self._nodes.shape:
-                    other_arrays = downsample(other_arrays, down_factor, order = 3)
-                    other_arrays = binarize(other_arrays)
-                other_arrays = [edges, other_arrays]
-            except:
-                try:
-                    arrays = directory_info(other_arrays)
-                    directory = other_arrays
-                    other_arrays = []
-                    for array in arrays:
-                        array = tifffile.imread(f'{directory}/{array}')
-                        if array.shape == self._nodes.shape:
-                            array = downsample(array, down_factor, order = 3)
-                            array = binarize(array)
-                        other_arrays.append(array)
-                    other_arrays.insert(0, edges)
-                except:
-                    other_arrays = edges
-            visualize_3D(nodes, other_arrays, xy_scale = xy_scale, z_scale = z_scale)
-        else:
-            try: 
-                nodes = binarize(self._nodes)
-            except:
-                pass
-            try:
-                edges = binarize(self._edges)
-            except:
-                edges = None
-            try:
-                if not isinstance(other_arrays, np.ndarray):
-                    other_arrays = tifffile.imread(other_arrays)
-                other_arrays = binarize(other_arrays)
-                other_arrays = [edges, other_arrays]
-            except:
-                try:
-                    arrays = directory_info(other_arrays)
-                    directory = other_arrays
-                    other_arrays = []
-                    for array in arrays:
-                        array = tifffile.imread(f'{directory}/{array}')
-                        array = binarize(array)
-                        other_arrays.append(array)
-                    other_arrays.insert(0, self._edges)
-                except:
-                    other_arrays = edges
-
-            visualize_3D(nodes, other_arrays, xy_scale = self._xy_scale, z_scale = self._z_scale)
-
     def get_degrees(self, down_factor = 1, directory = None, called = False, no_img = 0):
         """
         Method to obtain information on the degrees of nodes in the network, also generating overlays that relate this information to the 3D structure.

nettracer3d/nettracer_gui.py

@@ -1880,7 +1880,7 @@ class ImageViewerWindow(QMainWindow):
         searchoverlay_action.triggered.connect(self.show_search_dialog)
         shuffle_action = overlay_menu.addAction("Shuffle")
         shuffle_action.triggered.connect(self.show_shuffle_dialog)
-        show3d_action = image_menu.addAction("Show 3D (beta)")
+        show3d_action = image_menu.addAction("Show 3D (Napari)")
         show3d_action.triggered.connect(self.show3d_dialog)
 
 
@@ -2339,7 +2339,9 @@ class ImageViewerWindow(QMainWindow):
                 f"Select Directory for Network3D Object",
                 "",
                 QFileDialog.Option.ShowDirsOnly
-            )
+                )
+            self.reset(nodes = True, network = True, xy_scale = 1, z_scale = 1, edges = True, search_region = True, network_overlay = True, id_overlay = True)
+
 
             my_network.assemble(directory)
 
@@ -2514,17 +2516,10 @@ class ImageViewerWindow(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
-    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True, preserve_zoom = None):
+    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True):
         """Load a channel and enable active channel selection if needed."""
 
         try:
-            # Store current zoom limits if they exist and weren't provided
-            if preserve_zoom is None and hasattr(self, 'ax'):
-                current_xlim = None
-                current_ylim = None
-            else:
-                current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-
             if not data:  # For solo loading
                 import tifffile
                 filename, _ = QFileDialog.getOpenFileName(
@@ -2604,14 +2599,10 @@ class ImageViewerWindow(QMainWindow):
 
             if assign_shape: #keep original shape tracked to undo resampling.
                 self.original_shape = self.channel_data[channel_index].shape
+                if len(self.original_shape) == 4:
+                    self.original_shape = (self.original_shape[0], self.original_shape[1], self.original_shape[2])
 
-            # Restore zoom limits if they existed
-            if current_xlim is not None and current_ylim is not None:
-                self.ax.set_xlim(current_xlim)
-                self.ax.set_ylim(current_ylim)
-                self.update_display(preserve_zoom = (current_xlim, current_ylim))
-            else:
-                self.update_display()
+            self.update_display()
 
 
                 
@@ -2835,137 +2826,160 @@ class ImageViewerWindow(QMainWindow):
         self.channel_brightness[channel_index]['max'] = max_val / 255
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
     
-    def update_display(self, preserve_zoom=None):
-            """Update the display with currently visible channels and highlight overlay."""
-            self.figure.clear()
-            
-            # Create subplot with tight layout and white figure background
-            self.figure.patch.set_facecolor('white')
-            self.ax = self.figure.add_subplot(111)
-            
-            # Store current zoom limits if they exist and weren't provided
-            if preserve_zoom is None and hasattr(self, 'ax'):
-                current_xlim = self.ax.get_xlim() if self.ax.get_xlim() != (0, 1) else None
-                current_ylim = self.ax.get_ylim() if self.ax.get_ylim() != (0, 1) else None
+    def update_display(self, preserve_zoom=None, dims = None):
+        """Update the display with currently visible channels and highlight overlay."""
+
+        self.figure.clear()
+
+        # Get active channels and their dimensions
+        active_channels = [i for i in range(4) if self.channel_data[i] is not None]
+        if dims is None:
+            if active_channels:
+                dims = [(self.channel_data[i].shape[1:3] if len(self.channel_data[i].shape) >= 3 else 
+                        self.channel_data[i].shape) for i in active_channels]
+                min_height = min(d[0] for d in dims)
+                min_width = min(d[1] for d in dims)
             else:
-                current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-            
-            # Define base colors for each channel with increased intensity
-            base_colors = self.base_colors
-            # Set only the axes (image area) background to black
-            self.ax.set_facecolor('black')
-            
-            # Display each visible channel
-            for channel in range(4):
-                if (self.channel_visible[channel] and 
-                    self.channel_data[channel] is not None):
-                    
-                    # Check if we're dealing with RGB data
-                    is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
-                    
-                    if len(self.channel_data[channel].shape) == 3 and not is_rgb:
-                        current_image = self.channel_data[channel][self.current_slice, :, :]
-                    elif is_rgb:
-                        current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
-                    else:
-                        current_image = self.channel_data[channel]
+                min_height = 1
+                min_width = 1
+        else:
+            min_height = dims[0]
+            min_width = dims[1]
+
+        # Set axes limits before displaying any images
+        self.ax.set_xlim(-0.5, min_width - 0.5)
+        self.ax.set_ylim(min_height - 0.5, -0.5)
+        
+        # Create subplot with tight layout and white figure background
+        self.figure.patch.set_facecolor('white')
+        self.ax = self.figure.add_subplot(111)
+        
+        # Store current zoom limits if they exist and weren't provided
+        if preserve_zoom is None and hasattr(self, 'ax'):
+            current_xlim = self.ax.get_xlim() if self.ax.get_xlim() != (0, 1) else None
+            current_ylim = self.ax.get_ylim() if self.ax.get_ylim() != (0, 1) else None
+        else:
+            current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
+        
+        # Define base colors for each channel with increased intensity
+        base_colors = self.base_colors
+        # Set only the axes (image area) background to black
+        self.ax.set_facecolor('black')
+        
+        # Display each visible channel
+        for channel in range(4):
+            if (self.channel_visible[channel] and 
+                self.channel_data[channel] is not None):
+                
+                # Check if we're dealing with RGB data
+                is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
+                
+                if len(self.channel_data[channel].shape) == 3 and not is_rgb:
+                    current_image = self.channel_data[channel][self.current_slice, :, :]
+                elif is_rgb:
+                    current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
+                else:
+                    current_image = self.channel_data[channel]
 
-                    if is_rgb and self.channel_data[channel].shape[-1] == 3:
-                        # For RGB images, just display directly without colormap
-                        self.ax.imshow(current_image,
-                                     alpha=0.7)
-                    elif is_rgb and self.channel_data[channel].shape[-1] == 4:
-                        self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
+                if is_rgb and self.channel_data[channel].shape[-1] == 3:
+                    # For RGB images, just display directly without colormap
+                    self.ax.imshow(current_image,
+                                 alpha=0.7)
+                elif is_rgb and self.channel_data[channel].shape[-1] == 4:
+                    self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
 
+                else:
+                    # Regular channel processing with colormap
+                    # Calculate brightness/contrast limits from entire volume
+                    img_min = self.min_max[channel][0]
+                    img_max = self.min_max[channel][1]
+                    
+                    # Calculate vmin and vmax, ensuring we don't get a zero range
+                    if img_min == img_max:
+                        vmin = img_min
+                        vmax = img_min + 1
                     else:
-                        # Regular channel processing with colormap
-                        # Calculate brightness/contrast limits from entire volume
-                        img_min = self.min_max[channel][0]
-                        img_max = self.min_max[channel][1]
-                        
-                        # Calculate vmin and vmax, ensuring we don't get a zero range
-                        if img_min == img_max:
-                            vmin = img_min
-                            vmax = img_min + 1
-                        else:
-                            vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
-                            vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
-                        
-                        # Normalize the image safely
-                        if vmin == vmax:
-                            normalized_image = np.zeros_like(current_image)
-                        else:
-                            normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
-                        
-                        # Create custom colormap with higher intensity
-                        color = base_colors[channel]
-                        custom_cmap = LinearSegmentedColormap.from_list(
-                            f'custom_{channel}',
-                            [(0,0,0,0), (*color,1)]
-                        )
-                        
-                        # Display the image with slightly higher alpha
-                        self.ax.imshow(normalized_image,
-                                     alpha=0.7,
-                                     cmap=custom_cmap,
-                                     vmin=0,
-                                     vmax=1)
-
-            # Rest of the code remains the same...
-            # Add highlight overlay if it exists
-            if self.highlight_overlay is not None:
-                highlight_slice = self.highlight_overlay[self.current_slice]
-                highlight_cmap = LinearSegmentedColormap.from_list(
-                    'highlight',
-                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-                )
-                self.ax.imshow(highlight_slice,
-                             cmap=highlight_cmap,
-                             alpha=0.5)
-
-            # Restore zoom limits if they existed
-            if current_xlim is not None and current_ylim is not None:
-                self.ax.set_xlim(current_xlim)
-                self.ax.set_ylim(current_ylim)
-            
-            # Style the axes
-            self.ax.set_xlabel('X')
-            self.ax.set_ylabel('Y')
-            self.ax.set_title(f'Slice {self.current_slice}')
-
-            # Make axis labels and ticks black for visibility against white background
-            self.ax.xaxis.label.set_color('black')
-            self.ax.yaxis.label.set_color('black')
-            self.ax.title.set_color('black')
-            self.ax.tick_params(colors='black')
-            for spine in self.ax.spines.values():
-                spine.set_color('black')
-
-            # Adjust the layout to ensure the plot fits well in the figure
-            self.figure.tight_layout()
-
-            # Redraw measurement points and their labels
-            for point in self.measurement_points:
-                x1, y1, z1 = point['point1']
-                x2, y2, z2 = point['point2']
-                pair_idx = point['pair_index']
-                
-                # Draw points and labels if they're on current slice
-                if z1 == self.current_slice:
-                    self.ax.plot(x1, y1, 'yo', markersize=8)
-                    self.ax.text(x1, y1+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
-                if z2 == self.current_slice:
-                    self.ax.plot(x2, y2, 'yo', markersize=8)
-                    self.ax.text(x2, y2+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
+                        vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
+                        vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
                     
-                # Draw line if both points are on current slice
-                if z1 == z2 == self.current_slice:
-                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+                    # Normalize the image safely
+                    if vmin == vmax:
+                        normalized_image = np.zeros_like(current_image)
+                    else:
+                        normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                    
+                    # Create custom colormap with higher intensity
+                    color = base_colors[channel]
+                    custom_cmap = LinearSegmentedColormap.from_list(
+                        f'custom_{channel}',
+                        [(0,0,0,0), (*color,1)]
+                    )
+                    
+                    # Display the image with slightly higher alpha
+                    self.ax.imshow(normalized_image,
+                                 alpha=0.7,
+                                 cmap=custom_cmap,
+                                 vmin=0,
+                                 vmax=1,
+                                 extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+
+        # Add highlight overlay if it exists
+        if self.highlight_overlay is not None:
+            highlight_slice = self.highlight_overlay[self.current_slice]
+            highlight_cmap = LinearSegmentedColormap.from_list(
+                'highlight',
+                [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
+            )
+            self.ax.imshow(highlight_slice,
+                         cmap=highlight_cmap,
+                         alpha=0.5)
+
+        # Restore zoom limits if they existed
+        if current_xlim is not None and current_ylim is not None:
+            self.ax.set_xlim(current_xlim)
+            self.ax.set_ylim(current_ylim)
+        
+        # Style the axes
+        self.ax.set_xlabel('X')
+        self.ax.set_ylabel('Y')
+        self.ax.set_title(f'Slice {self.current_slice}')
+
+        # Make axis labels and ticks black for visibility against white background
+        self.ax.xaxis.label.set_color('black')
+        self.ax.yaxis.label.set_color('black')
+        self.ax.title.set_color('black')
+        self.ax.tick_params(colors='black')
+        for spine in self.ax.spines.values():
+            spine.set_color('black')
+
+        # Adjust the layout to ensure the plot fits well in the figure
+        self.figure.tight_layout()
+
+        # Redraw measurement points and their labels
+        for point in self.measurement_points:
+            x1, y1, z1 = point['point1']
+            x2, y2, z2 = point['point2']
+            pair_idx = point['pair_index']
+            
+            # Draw points and labels if they're on current slice
+            if z1 == self.current_slice:
+                self.ax.plot(x1, y1, 'yo', markersize=8)
+                self.ax.text(x1, y1+5, str(pair_idx), 
+                            color='white', ha='center', va='bottom')
+            if z2 == self.current_slice:
+                self.ax.plot(x2, y2, 'yo', markersize=8)
+                self.ax.text(x2, y2+5, str(pair_idx), 
+                            color='white', ha='center', va='bottom')
+                
+            # Draw line if both points are on current slice
+            if z1 == z2 == self.current_slice:
+                self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+    
+        if active_channels:
+            self.ax.set_xlim(-0.5, min_width - 0.5)
+            self.ax.set_ylim(min_height - 0.5, -0.5)
         
-            self.canvas.draw()
-
+        self.canvas.draw()
     def show_netshow_dialog(self):
         dialog = NetShowDialog(self)
         dialog.exec()
@@ -3913,19 +3927,19 @@ class ColorDialog(QDialog):
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Display Parameters")
+        self.setWindowTitle("Display Parameters (Napari)")
         self.setModal(True)
         
         layout = QFormLayout(self)
 
-        self.downsample = QLineEdit("1")
-        layout.addRow("Downsample Factor (Expect Slowness on Large Images):", self.downsample)
+        self.downsample = QLineEdit("")
+        layout.addRow("Downsample Factor (Optional to speed up display):", self.downsample)
 
         # Network Overlay checkbox (default True)
-        self.overlay = QPushButton("Overlay 1")
-        self.overlay.setCheckable(True)
-        self.overlay.setChecked(True)
-        layout.addRow("Include Overlay 1?", self.overlay)
+        self.cubic = QPushButton("cubic")
+        self.cubic.setCheckable(True)
+        self.cubic.setChecked(False)
+        layout.addRow("Use cubic downsample (Slower but preserves shape better potentially)?", self.cubic)
         
         # Add Run button
         run_button = QPushButton("Show 3D")
@@ -3939,22 +3953,49 @@ class Show3dDialog(QDialog):
             
             # Get amount
             try:
-                downsample = float(self.downsample.text()) if self.downsample.text() else 1
+                downsample = float(self.downsample.text()) if self.downsample.text() else None
             except ValueError:
-                downsample = 1
+                downsample = None
 
-            overlay = self.overlay.isChecked()
-            if overlay:
-        
-                # Example analysis plot
-                my_network.show_3D(my_network.network_overlay, downsample)
+            cubic = self.cubic.isChecked()
+
+            if cubic:
+                order = 3
             else:
-                my_network.show_3D(down_factor = downsample)
+                order = 0
+
+            arrays_3d = []
+            arrays_4d = []
+
+            color_template = ['red', 'green', 'white', 'cyan', 'yellow']  # color list
+            colors = []
+
+
+            for i, channel in enumerate(self.parent().channel_data):
+                if channel is not None:
+
+                    if len(channel.shape) == 3:
+                        visible = self.parent().channel_buttons[i].isChecked()
+                        if visible:
+                            arrays_3d.append(channel)
+                            colors.append(color_template[i])
+                    elif len(channel.shape) == 4:
+                        visible = self.parent().channel_buttons[i].isChecked()
+                        if visible:
+                            arrays_4d.append(channel)
+
+            if self.parent().highlight_overlay is not None:
+                arrays_3d.append(self.parent().highlight_overlay)
+                colors.append(color_template[4])
+        
+            n3d.show_3d(arrays_3d, arrays_4d, down_factor = downsample, order = order, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale, colors = colors)
             
             self.accept()
 
         except Exception as e:
             print(f"Error: {e}")
+            import traceback
+            print(traceback.format_exc())
 
 
 class NetOverlayDialog(QDialog):
@@ -4969,6 +5010,7 @@ class ResizeDialog(QDialog):
                         resized_data = n3d.resize(self.parent().channel_data[channel], resize, order)
                         self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
 
+
                 
                 # Process highlight overlay if it exists
                 if self.parent().highlight_overlay is not None:
@@ -4990,8 +5032,8 @@ class ResizeDialog(QDialog):
                 # Process highlight overlay if it exists
                 if self.parent().highlight_overlay is not None:
                     self.parent().highlight_overlay = n3d.upsample_with_padding(self.parent().highlight_overlay, original_shape = self.parent().original_shape)
-
-                my_network.search_region = n3d.upsample_with_padding(my_network.search_region, original_shape = self.parent().original_shape)
+                if my_network.search_region is not None:
+                    my_network.search_region = n3d.upsample_with_padding(my_network.search_region, original_shape = self.parent().original_shape)
 
             
             # Update slider range based on new z-dimension
@@ -5417,7 +5459,7 @@ class DilateDialog(QDialog):
             )
 
             # Update both the display data and the network object
-            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom=(current_xlim, current_ylim))
+            self.parent().load_channel(self.parent().active_channel, result, True)
 
             self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
             self.accept()
@@ -5503,7 +5545,7 @@ class ErodeDialog(QDialog):
             )
 
 
-            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom=(current_xlim, current_ylim))
+            self.parent().load_channel(self.parent().active_channel, result, True)
 
 
             self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -5908,8 +5950,13 @@ class GenNodesDialog(QDialog):
         if down_factor is None:
             self.down_factor = QLineEdit("0")
             layout.addRow("Downsample Factor (Speeds up calculation at the cost of fidelity):", self.down_factor)
+            self.cubic = QPushButton("Cubic Downsample")
+            self.cubic.setCheckable(True)
+            self.cubic.setChecked(False)
+            layout.addRow("(if downsampling): Use cubic dilation? (Slower but can preserve structure better)", self.cubic)
         else:
-            self.down_factor = down_factor
+            self.down_factor = down_factor[0]
+            self.cubic = down_factor[1]
 
         self.directory = QLineEdit()
         self.directory.setPlaceholderText("Leave empty to save in active dir")
@@ -5922,7 +5969,7 @@ class GenNodesDialog(QDialog):
             self.retain.setChecked(True)
             layout.addRow("Retain Original Edges? (Will be moved to overlay 2):", self.retain)
         else:
-            self.retain = True
+            self.retain = False
 
         # Add Run button
         run_button = QPushButton("Run Node Generation")
@@ -5956,17 +6003,24 @@ class GenNodesDialog(QDialog):
             # Get down_factor
             if type(self.down_factor) is int:
                 down_factor = self.down_factor
+                cubic = self.cubic
             else:
                 try:
                     down_factor = int(self.down_factor.text()) if self.down_factor.text() else 0
                 except ValueError:
                     down_factor = 0
+                cubic = self.cubic.isChecked()
                 
             try:
                 retain = self.retain.isChecked()
             except:
                 retain = True
 
+            if cubic:
+                order = 3
+            else:
+                order = 0
+
             
             result, skele = n3d.label_vertices(
                 my_network.edges,
@@ -5974,12 +6028,14 @@ class GenNodesDialog(QDialog):
                 branch_removal=branch_removal,
                 comp_dil=comp_dil,
                 down_factor=down_factor,
+                order = order,
                 return_skele = True
 
             )
 
             if down_factor > 0 and not self.called:
-                my_network.edges = n3d.downsample(my_network.edges, down_factor)
+
+                my_network.edges = n3d.downsample(my_network.edges, down_factor, order = order)
                 my_network.xy_scale = my_network.xy_scale * down_factor
                 my_network.z_scale = my_network.z_scale * down_factor
                 print("xy_scales and z_scales have been adjusted per downsample. Check image -> properties to manually reset them to 1 if desired.")
@@ -5995,13 +6051,14 @@ class GenNodesDialog(QDialog):
             except:
                 pass
 
+            self.parent().load_channel(1, channel_data = skele, data = True)
+
+            self.parent().load_channel(0, channel_data = result, data = True)
 
             if retain:
                 self.parent().load_channel(3, channel_data = my_network.edges, data = True)
 
-            self.parent().load_channel(1, channel_data = skele, data = True)
 
-            self.parent().load_channel(0, channel_data = result, data = True)
 
             self.parent().update_display()
             self.accept()
@@ -6040,6 +6097,12 @@ class BranchDialog(QDialog):
         self.down_factor = QLineEdit("0")
         layout.addRow("Internal downsample (will have to recompute nodes)?:", self.down_factor)
 
+        # cubic checkbox (default False)
+        self.cubic = QPushButton("Cubic Downsample")
+        self.cubic.setCheckable(True)
+        self.cubic.setChecked(False)
+        layout.addRow("(if downsampling): Use cubic dilation? (Slower but can preserve structure better)", self.cubic)
+
         # Add Run button
         run_button = QPushButton("Run Branch Label")
         run_button.clicked.connect(self.branch_label)
@@ -6056,25 +6119,29 @@ class BranchDialog(QDialog):
 
             nodes = self.nodes.isChecked()
             GPU = self.GPU.isChecked()
+            cubic = self.cubic.isChecked()
+
 
             original_shape = my_network.edges.shape
+            original_array = copy.deepcopy(my_network.edges)
 
             if down_factor > 0:
-                self.parent().show_gennodes_dialog(down_factor = down_factor, called = True)
+                self.parent().show_gennodes_dialog(down_factor = [down_factor, cubic], called = True)
             elif nodes:
                 self.parent().show_gennodes_dialog(called = True)
                 down_factor = None
 
             if my_network.edges is not None and my_network.nodes is not None and my_network.id_overlay is not None:
 
-                output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = my_network.id_overlay, GPU = GPU, down_factor = down_factor)
+                output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape)
 
                 if down_factor is not None:
 
-                    self.parent().reset(nodes = True, id_overlay = True)
+                    self.parent().reset(nodes = True, id_overlay = True, edges = True)
 
                 else:
                     self.parent().reset(id_overlay = True)
+                self.parent().update_display(dims = (output.shape[1], output.shape[2]))
 
                 self.parent().load_channel(1, channel_data = output, data = True)
 

{nettracer3d-0.3.4.dist-info → nettracer3d-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.4
+Version: 0.3.6
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
@@ -20,7 +20,7 @@ Requires-Dist: networkx
 Requires-Dist: opencv-python-headless
 Requires-Dist: openpyxl
 Requires-Dist: pandas
-Requires-Dist: plotly
+Requires-Dist: napari
 Requires-Dist: python-louvain
 Requires-Dist: tifffile
 Requires-Dist: PyQt6

{nettracer3d-0.3.4.dist-info → nettracer3d-0.3.6.dist-info}/RECORD

@@ -3,16 +3,16 @@ nettracer3d/community_extractor.py,sha256=8bRDJOfZhOFLtpkJVaDQrQ4O8wUywyr-EfVvW5
 nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,8298
 nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
 nettracer3d/morphology.py,sha256=wv7v06YUcn5lMyefcc_znQlXF5iDxvUdoc0fXOKlGTw,12982
-nettracer3d/nettracer.py,sha256=ViIDJz8k-wcxVgcknH_YpG86QyfH8F86T1wKb5d4Cns,206526
-nettracer3d/nettracer_gui.py,sha256=3T5jLilk0DCXx1qMFW_s0Yq_o0hU_9WH0LkTnl6K-sg,286748
+nettracer3d/nettracer.py,sha256=CfAdS3SnigL4TkfqwHRIg0WeBtwJ1nGysNq5pfSSwVU,201682
+nettracer3d/nettracer_gui.py,sha256=e72Z9Yw0wxZ1ZIvrPv20oCtI49W3o0-YL7pNTLsM5Qc,289120
 nettracer3d/network_analysis.py,sha256=MJBBjslA1k_R8ymid77U-qGSgzxFVfzGVQhE0IdhnbE,48046
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
 nettracer3d/node_draw.py,sha256=BMiD_FrlOHeGD4AQZ_Emd152PfxFuMgGf2x4S0TOTnw,9752
 nettracer3d/proximity.py,sha256=KYs4QUbt1U79RLzTvt8BmrxeGVaeKOQ2brtzTjjA78c,11011
 nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
 nettracer3d/smart_dilate.py,sha256=howfO6Lw5PxNjkaOBSCjkmf7fyau_-_8iTct2mAuTAQ,22083
-nettracer3d-0.3.4.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.3.4.dist-info/METADATA,sha256=_WReeJl26IM6fTvZNZgtiFsFH59Fo1YA3DV_msrBMrc,2894
-nettracer3d-0.3.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nettracer3d-0.3.4.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.3.4.dist-info/RECORD,,
+nettracer3d-0.3.6.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.3.6.dist-info/METADATA,sha256=8NWQk4tgtrZhISu9b210_FY4Q_GtcLN0Dhb1AdZukmg,2894
+nettracer3d-0.3.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nettracer3d-0.3.6.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.3.6.dist-info/RECORD,,