nettracer3d 0.2.9__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.9
+Version: 0.3.1
 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
@@ -31,10 +31,15 @@ Requires-Dist: cupy-cuda12x; extra == "cuda12"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
 
-NetTracer3D is a python package developed for 3D analysis of microscopic images in the .tif file format, such as lightsheet images, although it can also be used for 2D analysis if the user converts the 2D .tif file into a 3D stack first by appending the image together twice. NetTracer3D does not function on images directly, but rather on binary/labelled segmentations of image signal, and general requires one segmentation to serve as objects in a network (nodes) and one segmentation to serve as a connective media (edges), although it is possible to make networks from only edges.
+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:
 
-Please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
-for a user manual that provides documentation and detailed information.
+#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
+for a user manual that provides older documentation.
 
 NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
 

nettracer3d-0.3.1/README.md

@@ -0,0 +1,13 @@
+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
+for a user manual that provides older documentation.
+
+NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
+
+NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.

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

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

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

@@ -118,9 +118,43 @@ def get_border_nodes(partition, G):
 
     return border_nodes, intercom_connections, set(connected_coms)
 
-def downsample(data, factor):
-    # Downsample the input data by a specified factor
-    return zoom(data, 1/factor, order=0)
+def downsample(data, factor, directory=None, order=0):
+    """
+    Can be used to downsample an image by some arbitrary factor. Downsampled output will be saved to the active directory if none is specified.
+    
+    :param data: (Mandatory, string or ndarray) - If string, a path to a tif file to downsample. Note that the ndarray alternative is for internal use mainly and will not save its output.
+    :param factor: (Mandatory, int) - A factor by which to downsample the image.
+    :param directory: (Optional - Val = None, string) - A filepath to save outputs.
+    :param order: (Optional - Val = 0, int) - The order of interpolation for scipy.ndimage.zoom
+    :returns: a downsampled ndarray.
+    """
+    # Load the data if it's a file path
+    if isinstance(data, str):
+        data2 = data
+        data = tifffile.imread(data)
+    else:
+        data2 = None
+    
+    # Check if Z dimension is too small relative to downsample factor
+    if data.ndim == 3 and data.shape[0] < factor * 4:
+        print(f"Warning: Z dimension ({data.shape[0]}) is less than 4x the downsample factor ({factor}). "
+              f"Skipping Z-axis downsampling to preserve resolution.")
+        zoom_factors = (1, 1/factor, 1/factor)
+    else:
+        zoom_factors = 1/factor
+
+    # Apply downsampling
+    data = zoom(data, zoom_factors, order=order)
+    
+    # Save if input was a file path
+    if isinstance(data2, str):
+        if directory is None:
+            filename = "downsampled.tif"
+        else:
+            filename = f"{directory}/downsampled.tif"
+        tifffile.imwrite(filename, data)
+    
+    return data
 
 def labels_to_boolean(label_array, labels_list):
     # Use np.isin to create a boolean array with a single operation

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

@@ -696,29 +696,35 @@ def fill_holes_3d(array):
 
     array = binarize(array)
     inv_array = invert_array(array)
+
     
     # Create arrays for all three planes
     array_xy = np.zeros_like(inv_array, dtype=np.uint8)
     array_xz = np.zeros_like(inv_array, dtype=np.uint8)
     array_yz = np.zeros_like(inv_array, dtype=np.uint8)
-    
+
+
     # Process XY plane
     for z in range(inv_array.shape[0]):
         array_xy[z] = process_slice(inv_array[z])
+
+    if array.shape[0] > 3: #only use these dimensions for sufficiently large zstacks
         
-    # Process XZ plane    
-    for y in range(inv_array.shape[1]):
-        slice_xz = inv_array[:, y, :]
-        array_xz[:, y, :] = process_slice(slice_xz)
+        # Process XZ plane    
+        for y in range(inv_array.shape[1]):
+            slice_xz = inv_array[:, y, :]
+            array_xz[:, y, :] = process_slice(slice_xz)
+            
+        # Process YZ plane
+        for x in range(inv_array.shape[2]):
+            slice_yz = inv_array[:, :, x]
+            array_yz[:, :, x] = process_slice(slice_yz)
         
-    # Process YZ plane
-    for x in range(inv_array.shape[2]):
-        slice_yz = inv_array[:, :, x]
-        array_yz[:, :, x] = process_slice(slice_yz)
-    
-    # Combine results from all three planes
-    filled = (array_xy | array_xz | array_yz) * 255
-    return array + filled
+        # Combine results from all three planes
+        filled = (array_xy | array_xz | array_yz) * 255
+        return array + filled
+    else:
+        return array_xy * 255
 
 
 
@@ -1336,35 +1342,44 @@ def directory_info(directory = None):
 
 #CLASSLESS FUNCTIONS THAT MAY BE USEFUL TO USERS TO RUN DIRECTLY THAT SUPPORT ANALYSIS IN SOME WAY. NOTE THESE METHODS SOMETIMES ARE USED INTERNALLY AS WELL:
 
-def downsample(data, factor, directory = None, order = 0):
+def downsample(data, factor, directory=None, order=0):
     """
     Can be used to downsample an image by some arbitrary factor. Downsampled output will be saved to the active directory if none is specified.
+    
     :param data: (Mandatory, string or ndarray) - If string, a path to a tif file to downsample. Note that the ndarray alternative is for internal use mainly and will not save its output.
     :param factor: (Mandatory, int) - A factor by which to downsample the image.
     :param directory: (Optional - Val = None, string) - A filepath to save outputs.
+    :param order: (Optional - Val = 0, int) - The order of interpolation for scipy.ndimage.zoom
     :returns: a downsampled ndarray.
     """
-
-
-    # Downsample the input data by a specified factor
-
-    if type(data) == str:
+    # Load the data if it's a file path
+    if isinstance(data, str):
         data2 = data
         data = tifffile.imread(data)
     else:
         data2 = None
+    
+    # Check if Z dimension is too small relative to downsample factor
+    if data.ndim == 3 and data.shape[0] < factor * 4:
+        print(f"Warning: Z dimension ({data.shape[0]}) is less than 4x the downsample factor ({factor}). "
+              f"Skipping Z-axis downsampling to preserve resolution.")
+        zoom_factors = (1, 1/factor, 1/factor)
+    else:
+        zoom_factors = 1/factor
 
-    data = zoom(data, 1/factor, order=order)
-
-    if type(data2) == str:
+    # Apply downsampling
+    data = zoom(data, zoom_factors, order=order)
+    
+    # Save if input was a file path
+    if isinstance(data2, str):
         if directory is None:
-            filename = f"downampled.tif"
+            filename = "downsampled.tif"
         else:
             filename = f"{directory}/downsampled.tif"
         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.
@@ -3331,7 +3346,12 @@ class Network_3D:
 
         print("Converting all edge objects to nodes...")
 
-        df, identity_dict, max_node = network_analysis.edge_to_node(self._network_lists, self._node_identities)
+        if self._nodes is not None:
+            max_node = np.max(self._nodes)
+        else:
+            max_node = None
+
+        df, identity_dict, max_node = network_analysis.edge_to_node(self._network_lists, self._node_identities, maxnode = max_node)
 
         self._network_lists = network_analysis.read_excel_to_lists(df)
         self._network, net_weights = network_analysis.weighted_network(df)

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

@@ -4948,6 +4948,10 @@ class ResizeDialog(QDialog):
                 # Process highlight overlay if it exists
                 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)
+
+
             else:
                 # Process each channel
                 if array_shape == self.parent().original_shape:
@@ -4962,6 +4966,8 @@ 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)
+
             
             # Update slider range based on new z-dimension
             for channel in self.parent().channel_data:
@@ -6289,7 +6295,10 @@ class ModifyDialog(QDialog):
                 my_network.edge_to_node()
                 self.parent().load_channel(0, my_network.nodes, True)
                 self.parent().load_channel(1, my_network.edges, True)
-
+                try:
+                    self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                except:
+                    pass
             try:
                 if hasattr(my_network, 'network_lists'):
                     model = PandasModel(my_network.network_lists)

{nettracer3d-0.2.9 → nettracer3d-0.3.1}/src/nettracer3d/network_analysis.py

@@ -21,9 +21,43 @@ try:
 except:
     pass
 
-def downsample(data, factor):
-    # Downsample the input data by a specified factor
-    return zoom(data, 1/factor, order=0)
+def downsample(data, factor, directory=None, order=0):
+    """
+    Can be used to downsample an image by some arbitrary factor. Downsampled output will be saved to the active directory if none is specified.
+    
+    :param data: (Mandatory, string or ndarray) - If string, a path to a tif file to downsample. Note that the ndarray alternative is for internal use mainly and will not save its output.
+    :param factor: (Mandatory, int) - A factor by which to downsample the image.
+    :param directory: (Optional - Val = None, string) - A filepath to save outputs.
+    :param order: (Optional - Val = 0, int) - The order of interpolation for scipy.ndimage.zoom
+    :returns: a downsampled ndarray.
+    """
+    # Load the data if it's a file path
+    if isinstance(data, str):
+        data2 = data
+        data = tifffile.imread(data)
+    else:
+        data2 = None
+    
+    # Check if Z dimension is too small relative to downsample factor
+    if data.ndim == 3 and data.shape[0] < factor * 4:
+        print(f"Warning: Z dimension ({data.shape[0]}) is less than 4x the downsample factor ({factor}). "
+              f"Skipping Z-axis downsampling to preserve resolution.")
+        zoom_factors = (1, 1/factor, 1/factor)
+    else:
+        zoom_factors = 1/factor
+
+    # Apply downsampling
+    data = zoom(data, zoom_factors, order=order)
+    
+    # Save if input was a file path
+    if isinstance(data2, str):
+        if directory is None:
+            filename = "downsampled.tif"
+        else:
+            filename = f"{directory}/downsampled.tif"
+        tifffile.imwrite(filename, data)
+    
+    return data
 
 def compute_centroid(binary_stack, label):
     """
@@ -157,7 +191,6 @@ def read_excel_to_lists(file_path, sheet_name=0):
             master_list[2].extend([int(x) for x in data_lists[i+2]])
         except IndexError:
             master_list[2].extend([0])  # Note: Changed to list with single int 0
-    print(master_list)
             
     return master_list
 
@@ -1169,7 +1202,7 @@ def isolate_internode_connections(networkfile, nodeIDs, ID1, ID2):
     # Optional: Return the updated lists if needed
     return master_list, output_dict
 
-def edge_to_node(network, node_identities = None):
+def edge_to_node(network, node_identities = None, maxnode = None):
     """Converts edge IDs into nodes, so that the node-edge relationships can be more easily visualized"""
 
     if node_identities is not None and type(node_identities) == str:
@@ -1195,7 +1228,8 @@ def edge_to_node(network, node_identities = None):
     nodesB = master_list[1]
     edgesC = master_list[2]
     allnodes = set(nodesA + nodesB)
-    maxnode = max(allnodes)
+    if maxnode is None:
+        maxnode = max(allnodes)
     print(f"Transposing all edge vals by {maxnode} to prevent ID overlap with preexisting nodes")
 
 

{nettracer3d-0.2.9 → nettracer3d-0.3.1}/src/nettracer3d/network_draw.py

@@ -95,9 +95,43 @@ def draw_line_inplace(start, end, array):
     # Set the line coordinates to 255 in the existing array
     array[x_coords, y_coords, z_coords] = 255
 
-def downsample(data, factor):
-    # Downsample the input data by a specified factor
-    return zoom(data, 1/factor, order=0)
+def downsample(data, factor, directory=None, order=0):
+    """
+    Can be used to downsample an image by some arbitrary factor. Downsampled output will be saved to the active directory if none is specified.
+    
+    :param data: (Mandatory, string or ndarray) - If string, a path to a tif file to downsample. Note that the ndarray alternative is for internal use mainly and will not save its output.
+    :param factor: (Mandatory, int) - A factor by which to downsample the image.
+    :param directory: (Optional - Val = None, string) - A filepath to save outputs.
+    :param order: (Optional - Val = 0, int) - The order of interpolation for scipy.ndimage.zoom
+    :returns: a downsampled ndarray.
+    """
+    # Load the data if it's a file path
+    if isinstance(data, str):
+        data2 = data
+        data = tifffile.imread(data)
+    else:
+        data2 = None
+    
+    # Check if Z dimension is too small relative to downsample factor
+    if data.ndim == 3 and data.shape[0] < factor * 4:
+        print(f"Warning: Z dimension ({data.shape[0]}) is less than 4x the downsample factor ({factor}). "
+              f"Skipping Z-axis downsampling to preserve resolution.")
+        zoom_factors = (1, 1/factor, 1/factor)
+    else:
+        zoom_factors = 1/factor
+
+    # Apply downsampling
+    data = zoom(data, zoom_factors, order=order)
+    
+    # Save if input was a file path
+    if isinstance(data2, str):
+        if directory is None:
+            filename = "downsampled.tif"
+        else:
+            filename = f"{directory}/downsampled.tif"
+        tifffile.imwrite(filename, data)
+    
+    return data
 
 def draw_network_lattice(nodes, network, label_nodes = None):
 

{nettracer3d-0.2.9 → nettracer3d-0.3.1}/src/nettracer3d/node_draw.py

@@ -5,9 +5,43 @@ from PIL import Image, ImageDraw, ImageFont
 from scipy.ndimage import zoom
 
 
-def downsample(data, factor):
-    # Downsample the input data by a specified factor
-    return zoom(data, 1/factor, order=0)
+def downsample(data, factor, directory=None, order=0):
+    """
+    Can be used to downsample an image by some arbitrary factor. Downsampled output will be saved to the active directory if none is specified.
+    
+    :param data: (Mandatory, string or ndarray) - If string, a path to a tif file to downsample. Note that the ndarray alternative is for internal use mainly and will not save its output.
+    :param factor: (Mandatory, int) - A factor by which to downsample the image.
+    :param directory: (Optional - Val = None, string) - A filepath to save outputs.
+    :param order: (Optional - Val = 0, int) - The order of interpolation for scipy.ndimage.zoom
+    :returns: a downsampled ndarray.
+    """
+    # Load the data if it's a file path
+    if isinstance(data, str):
+        data2 = data
+        data = tifffile.imread(data)
+    else:
+        data2 = None
+    
+    # Check if Z dimension is too small relative to downsample factor
+    if data.ndim == 3 and data.shape[0] < factor * 4:
+        print(f"Warning: Z dimension ({data.shape[0]}) is less than 4x the downsample factor ({factor}). "
+              f"Skipping Z-axis downsampling to preserve resolution.")
+        zoom_factors = (1, 1/factor, 1/factor)
+    else:
+        zoom_factors = 1/factor
+
+    # Apply downsampling
+    data = zoom(data, zoom_factors, order=order)
+    
+    # Save if input was a file path
+    if isinstance(data2, str):
+        if directory is None:
+            filename = "downsampled.tif"
+        else:
+            filename = f"{directory}/downsampled.tif"
+        tifffile.imwrite(filename, data)
+    
+    return data
 
 def upsample_with_padding(data, factor, original_shape):
     # Upsample the input binary array while adding padding to match the original shape

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.9
+Version: 0.3.1
 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
@@ -31,10 +31,15 @@ Requires-Dist: cupy-cuda12x; extra == "cuda12"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
 
-NetTracer3D is a python package developed for 3D analysis of microscopic images in the .tif file format, such as lightsheet images, although it can also be used for 2D analysis if the user converts the 2D .tif file into a 3D stack first by appending the image together twice. NetTracer3D does not function on images directly, but rather on binary/labelled segmentations of image signal, and general requires one segmentation to serve as objects in a network (nodes) and one segmentation to serve as a connective media (edges), although it is possible to make networks from only edges.
+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:
 
-Please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
-for a user manual that provides documentation and detailed information.
+#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
+for a user manual that provides older documentation.
 
 NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
 

nettracer3d-0.2.9/README.md

@@ -1,8 +0,0 @@
-NetTracer3D is a python package developed for 3D analysis of microscopic images in the .tif file format, such as lightsheet images, although it can also be used for 2D analysis if the user converts the 2D .tif file into a 3D stack first by appending the image together twice. NetTracer3D does not function on images directly, but rather on binary/labelled segmentations of image signal, and general requires one segmentation to serve as objects in a network (nodes) and one segmentation to serve as a connective media (edges), although it is possible to make networks from only edges.
-
-Please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
-for a user manual that provides documentation and detailed information.
-
-NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
-
-NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.