nettracer3d 0.3.5__tar.gz → 0.3.7__tar.gz

{nettracer3d-0.3.5/src/nettracer3d.egg-info → nettracer3d-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.5
+Version: 0.3.7
 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.5 → nettracer3d-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.3.5"
+version = "0.3.7"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]
@@ -15,7 +15,7 @@ dependencies = [
     "opencv-python-headless",
     "openpyxl",
     "pandas",
-    "plotly",
+    "napari",
     "python-louvain",
     "tifffile",
     "PyQt6"

{nettracer3d-0.3.5 → nettracer3d-0.3.7}/src/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)
     
@@ -3741,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-0.3.5 → nettracer3d-0.3.7}/src/nettracer3d/nettracer_gui.py

@@ -564,7 +564,7 @@ class ImageViewerWindow(QMainWindow):
                         link_nodes.triggered.connect(self.handle_link)
                         delink_nodes = highlight_menu.addAction("Split Nodes")
                         delink_nodes.triggered.connect(self.handle_split)
-                context_menu.addMenu(highlight_menu)
+                    context_menu.addMenu(highlight_menu)
 
                 # Create measure menu
                 measure_menu = QMenu("Measure", self)
@@ -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)
 
@@ -2597,6 +2599,8 @@ 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])
 
             self.update_display()
 
@@ -3923,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")
@@ -3949,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):

{nettracer3d-0.3.5 → nettracer3d-0.3.7/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.5
+Version: 0.3.7
 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.5 → nettracer3d-0.3.7}/src/nettracer3d.egg-info/requires.txt

@@ -7,7 +7,7 @@ networkx
 opencv-python-headless
 openpyxl
 pandas
-plotly
+napari
 python-louvain
 tifffile
 PyQt6