nettracer3d 0.3.1__tar.gz → 0.3.3__tar.gz

{nettracer3d-0.3.1/src/nettracer3d.egg-info → nettracer3d-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -34,8 +34,11 @@ Requires-Dist: cupy; extra == "cupy"
 NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
 
 #Start
+
 from nettracer3d import nettracer_gui
+
 nettracer_gui.run_gui()
+
 #End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link

{nettracer3d-0.3.1 → nettracer3d-0.3.3}/README.md

@@ -1,8 +1,11 @@
 NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
 
 #Start
+
 from nettracer3d import nettracer_gui
+
 nettracer_gui.run_gui()
+
 #End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link

{nettracer3d-0.3.1 → nettracer3d-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.3.1"
+version = "0.3.3"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]

{nettracer3d-0.3.1 → nettracer3d-0.3.3}/src/nettracer3d/community_extractor.py

@@ -781,16 +781,16 @@ def generate_distinct_colors(n_colors: int) -> List[Tuple[int, int, int]]:
         colors.append(rgb)
     return colors
 
-def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.ndarray) -> np.ndarray:
+def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.ndarray) -> Tuple[np.ndarray, Dict[int, str]]:
     """
-    Assign distinct colors to communities and create an RGB image.
+    Assign distinct colors to communities and create an RGBA image.
     
     Args:
         community_dict: Dictionary mapping node IDs to community numbers
         labeled_array: 3D numpy array with labels corresponding to node IDs
     
     Returns:
-        RGB-coded numpy array (H, W, D, 3)
+        Tuple of (RGBA-coded numpy array (H, W, D, 4), dictionary mapping nodes to color names)
     """
     # Get unique communities and their sizes
     communities = set(community_dict.values())
@@ -802,26 +802,30 @@ def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.nd
     # Generate distinct colors
     colors = generate_distinct_colors(len(communities))
     
+    # Convert RGB colors to RGBA by adding alpha channel
+    colors_rgba = [(r, g, b, 255) for r, g, b in colors]  # Full opacity for colored regions
+    
     # Create mapping from community to color
-    community_to_color = {comm: colors[i] for i, comm in enumerate(sorted_communities)}
+    community_to_color = {comm: colors_rgba[i] for i, comm in enumerate(sorted_communities)}
     
     # Create mapping from node ID to color
     node_to_color = {node: community_to_color[comm] for node, comm in community_dict.items()}
     
-    # Create RGB array
-    rgb_array = np.zeros((*labeled_array.shape, 3), dtype=np.uint8)
+    # Create RGBA array (initialize with transparent background)
+    rgba_array = np.zeros((*labeled_array.shape, 4), dtype=np.uint8)
     
     # Assign colors to each voxel based on its label
     for label in np.unique(labeled_array):
         if label in node_to_color:  # Skip background (usually label 0)
             mask = labeled_array == label
-            for i in range(3):  # RGB channels
-                rgb_array[mask, i] = node_to_color[label][i]
-
-    node_to_color_names = convert_node_colors_to_names(community_to_color)
+            for i in range(4):  # RGBA channels
+                rgba_array[mask, i] = node_to_color[label][i]
 
+    # Convert the RGB portion of community_to_color back to RGB for color naming
+    community_to_color_rgb = {k: tuple(v[:3]) for k, v in community_to_color.items()}
+    node_to_color_names = convert_node_colors_to_names(community_to_color_rgb)
     
-    return rgb_array, node_to_color_names
+    return rgba_array, node_to_color_names
 
 def assign_community_grays(community_dict: Dict[int, Union[int, str, Any]], labeled_array: np.ndarray) -> np.ndarray:
     """

{nettracer3d-0.3.1 → nettracer3d-0.3.3}/src/nettracer3d/nettracer.py

@@ -950,9 +950,17 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
         dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
         return y, dilated_slice
 
+    """
+    def process_slice_third(x):
+        tiff_slice = tiff_array[:, :, x].astype(np.uint8)
+        dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
+        return x, dilated_slice
+    """
+
     # Create empty arrays to store the dilated results for the XY and XZ planes
     dilated_xy = np.zeros_like(tiff_array, dtype=np.uint8)
     dilated_xz = np.zeros_like(tiff_array, dtype=np.uint8)
+    #dilated_yz = np.zeros_like(tiff_array, dtype=np.uint8)
 
     kernel_x = int(dilated_x)
     kernel = create_circular_kernel(kernel_x)
@@ -969,7 +977,10 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
     kernel_x = int(dilated_x)
     kernel_z = int(dilated_z)
 
-    kernel = create_ellipsoidal_kernel(kernel_x, kernel_z)
+    if kernel_x == kernel_z:
+        kernel = create_circular_kernel(kernel_z)
+    else:
+        kernel = create_ellipsoidal_kernel(kernel_x, kernel_z)
 
     with ThreadPoolExecutor(max_workers=num_cores) as executor:
         futures = {executor.submit(process_slice_other, y): y for y in range(tiff_array.shape[1])}
@@ -978,12 +989,23 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
             y, dilated_slice = future.result()
             dilated_xz[:, y, :] = dilated_slice
 
+    """
+    with ThreadPoolExecutor(max_workers=num_cores) as executor:
+        futures = {executor.submit(process_slice_other, x): x for x in range(tiff_array.shape[2])}
+        
+        for future in as_completed(futures):
+            x, dilated_slice = future.result()
+            dilated_yz[:, :, x] = dilated_slice
+    """
+
 
     # Overlay the results
-    final_result = dilated_xy | dilated_xz
+    final_result = (dilated_xy | dilated_xz)
 
     return final_result
 
+
+
 def dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=None):
     """Recursive 3D dilation method that handles odd-numbered dilations properly.
     
@@ -1000,7 +1022,7 @@ def dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=N
     # For small dilations relative to array size, don't use recursion
     max_dilation = max(dilated_x, dilated_y, dilated_z)
     if max_dilation < (0.2 * min_dim):
-        return dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=1)
+        return dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z)
     
     # Initialize step_size for first call
     if step_size is None:
@@ -1379,7 +1401,7 @@ def downsample(data, factor, directory=None, order=0):
         tifffile.imwrite(filename, data)
     
     return data
-    
+
 def binarize(arrayimage, directory = None):
     """
     Can be used to binarize an image. Binary output will be saved to the active directory if none is specified.

{nettracer3d-0.3.1 → nettracer3d-0.3.3}/src/nettracer3d/nettracer_gui.py

@@ -476,7 +476,7 @@ class ImageViewerWindow(QMainWindow):
             return np.vstack(chunk_results)
         
         # Process nodes and edges in parallel using multiprocessing
-        with ThreadPoolExecutor(max_workers=2) as executor:
+        with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
             future_nodes = executor.submit(process_channel, self.channel_data[0], node_indices, full_shape)
             future_edges = executor.submit(process_channel, self.channel_data[1], edge_indices, full_shape)
             future_overlay1 = executor.submit(process_channel, self.channel_data[2], overlay1_indices, full_shape)
@@ -2514,10 +2514,17 @@ 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):
+    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True, preserve_zoom = None):
         """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 = 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)
+
             if not data:  # For solo loading
                 import tifffile
                 filename, _ = QFileDialog.getOpenFileName(
@@ -2543,7 +2550,6 @@ class ImageViewerWindow(QMainWindow):
                 self.channel_data[channel_index] = self.reduce_rgb_dimension(self.channel_data[channel_index])
 
 
-
             if channel_index == 0:
                 my_network.nodes = self.channel_data[channel_index]
             elif channel_index == 1:
@@ -2563,19 +2569,25 @@ class ImageViewerWindow(QMainWindow):
                 self.active_channel_combo.setEnabled(True)
             
             # Update slider range if this is the first channel loaded
-            if len(self.channel_data[channel_index].shape) == 3:
+            if len(self.channel_data[channel_index].shape) == 3 or len(self.channel_data[channel_index].shape) == 4:
                 if not self.slice_slider.isEnabled():
                     self.slice_slider.setEnabled(True)
                     self.slice_slider.setMinimum(0)
                     self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                    self.slice_slider.setValue(0)
-                    self.current_slice = 0
+                    if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
+                        self.current_slice = self.slice_slider.value()
+                    else:
+                        self.slice_slider.setValue(0)
+                        self.current_slice = 0
                 else:
                     self.slice_slider.setEnabled(True)
                     self.slice_slider.setMinimum(0)
                     self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                    self.slice_slider.setValue(0)
-                    self.current_slice = 0
+                    if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
+                        self.current_slice = self.slice_slider.value()
+                    else:
+                        self.current_slice = 0
+                        self.slice_slider.setValue(0)
             else:
                 self.slice_slider.setEnabled(False)
 
@@ -2592,8 +2604,15 @@ class ImageViewerWindow(QMainWindow):
 
             if assign_shape: #keep original shape tracked to undo resampling.
                 self.original_shape = self.channel_data[channel_index].shape
-            
-            self.update_display()
+
+            # 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()
+
 
                 
         except Exception as e:
@@ -2842,7 +2861,7 @@ class ImageViewerWindow(QMainWindow):
                     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
+                    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, :, :]
@@ -2851,10 +2870,13 @@ class ImageViewerWindow(QMainWindow):
                     else:
                         current_image = self.channel_data[channel]
 
-                    if is_rgb:
+                    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
@@ -4148,8 +4170,11 @@ class ShuffleDialog(QDialog):
 
 
             if accepted_target == 4:
+                try:
+                    self.parent().highlight_overlay = n3d.binarize(active_data)
+                except:
+                    self.parent().highlight_overlay = None
 
-                self.parent().highlight_overlay = n3d.binarize(active_data)
             else:
                 self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
 
@@ -4949,7 +4974,7 @@ class ResizeDialog(QDialog):
                 if self.parent().highlight_overlay is not None:
                     self.parent().highlight_overlay = n3d.resize(self.parent().highlight_overlay, resize, order)
                 if my_network.search_region is not None:
-                    my_network.search_region = n3d.resize(search_region, resize, order)
+                    my_network.search_region = n3d.resize(my_network.search_region, resize, order)
 
 
             else:
@@ -4966,7 +4991,7 @@ class ResizeDialog(QDialog):
                 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(search_region, original_shape = self.parent().original_shape)
+                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
@@ -5340,6 +5365,14 @@ class DilateDialog(QDialog):
     def run_dilate(self):
         try:
 
+            try: #for retaining zoom params
+                current_xlim = self.parent().ax.get_xlim()
+                current_ylim = self.parent().ax.get_ylim()
+            except:
+                current_xlim = None
+                current_ylim = None
+
+
             accepted_mode = self.mode_selector.currentIndex()
             
             # Get amount
@@ -5384,9 +5417,9 @@ class DilateDialog(QDialog):
             )
 
             # Update both the display data and the network object
-            self.parent().load_channel(self.parent().active_channel, result, True)
+            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom=(current_xlim, current_ylim))
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
             self.accept()
             
         except Exception as e:
@@ -5432,6 +5465,13 @@ class ErodeDialog(QDialog):
 
     def run_erode(self):
         try:
+
+            try: #for retaining zoom params
+                current_xlim = self.parent().ax.get_xlim()
+                current_ylim = self.parent().ax.get_ylim()
+            except:
+                current_xlim = None
+                current_ylim = None
             
             # Get amount
             try:
@@ -5462,14 +5502,11 @@ class ErodeDialog(QDialog):
                 z_scale = z_scale,
             )
 
-            # Update both the display data and the network object
-            self.parent().channel_data[self.parent().active_channel] = result
 
+            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom=(current_xlim, current_ylim))
 
-            # Update the corresponding property in my_network
-            setattr(my_network, network_properties[self.parent().active_channel], result)
 
-            self.parent().update_display()
+            self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
             self.accept()
             
         except Exception as e:

{nettracer3d-0.3.1 → nettracer3d-0.3.3/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -34,8 +34,11 @@ Requires-Dist: cupy; extra == "cupy"
 NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
 
 #Start
+
 from nettracer3d import nettracer_gui
+
 nettracer_gui.run_gui()
+
 #End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link