nettracer3d 0.6.7__py3-none-any.whl → 0.6.9__py3-none-any.whl

nettracer3d/proximity.py

@@ -82,7 +82,7 @@ def _get_node_node_dict(label_array, label, dilate_xy, dilate_z, fastdil = False
 def process_label(args):
     """Modified to use pre-computed bounding boxes instead of argwhere"""
     nodes, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
-    #print(f"Processing node {label}")
+    print(f"Processing node {label}")
     
     # Get the pre-computed bounding box for this label
     slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
@@ -178,9 +178,31 @@ def populate_array(centroids):
         
     return array
 
-def find_neighbors_kdtree(array, radius, targets=None):
+def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None):
     # Get coordinates of nonzero points
-    points = np.transpose(np.nonzero(array))
+    if centroids:
+        # If centroids is a dictionary mapping node IDs to coordinates
+        if isinstance(centroids, dict):
+            # Extract the node IDs and points
+            node_ids = list(centroids.keys())
+            points_list = list(centroids.values())
+            points = np.array(points_list, dtype=np.int32)
+        else:
+            # If centroids is just a list of points
+            points = np.array(centroids, dtype=np.int32)
+            node_ids = list(range(1, len(points) + 1))  # Default sequential IDs
+        
+        # Create a temporary array only if we need it for lookups
+        if array is None:
+            max_coords = np.max(points, axis=0) + 1
+            array = np.zeros(tuple(max_coords), dtype=np.int32)
+            for i, point in enumerate(points):
+                array[tuple(point)] = node_ids[i]  # Use the actual node ID
+    elif array is not None:
+        points = np.transpose(np.nonzero(array))
+        node_ids = None  # Not used in array-based mode
+    else:
+        return []
     
     # Create KD-tree from all nonzero points
     tree = KDTree(points)
@@ -188,19 +210,29 @@ def find_neighbors_kdtree(array, radius, targets=None):
     if targets is None:
         # Original behavior: find neighbors for all points
         query_points = points
-        query_indices = range(len(points))  # Add this line
+        query_indices = range(len(points))
     else:
         # Find coordinates of target values
         target_points = []
-        target_indices = []  # Add this line
-        for idx, point in enumerate(points):
-            if array[tuple(point)] in targets:
-                target_points.append(point)
-                target_indices.append(idx)  # Add this line
+        target_indices = []
+        
+        if array is not None:
+            # Standard array-based filtering
+            for idx, point in enumerate(points):
+                point_tuple = tuple(point)
+                if array[point_tuple] in targets:
+                    target_points.append(point)
+                    target_indices.append(idx)
+        else:
+            # Filter based on node IDs directly
+            for idx, node_id in enumerate(node_ids):
+                if node_id in targets:
+                    target_points.append(points[idx])
+                    target_indices.append(idx)
         
         # Convert to numpy array for querying
         query_points = np.array(target_points)
-        query_indices = target_indices  # Add this line
+        query_indices = target_indices
         
         # Handle case where no target values were found
         if len(query_points) == 0:
@@ -214,17 +246,21 @@ def find_neighbors_kdtree(array, radius, targets=None):
     
     # Generate pairs
     for i, neighbors in enumerate(neighbor_indices):
-        query_idx = query_indices[i]  # Modified this line
+        query_idx = query_indices[i]
         for neighbor_idx in neighbors:
             # Skip self-pairing
             if neighbor_idx != query_idx:
-                query_value = array[tuple(points[query_idx])]
-                neighbor_value = array[tuple(points[neighbor_idx])]
+                # Use node IDs from the dictionary if available
+                if array is not None:
+                    query_value = array[tuple(points[query_idx])]
+                    neighbor_value = array[tuple(points[neighbor_idx])]
+                else:
+                    query_value = node_ids[query_idx]
+                    neighbor_value = node_ids[neighbor_idx]
                 output.append([query_value, neighbor_value, 0])
     
     return output
 
-
 def extract_pairwise_connections(connections):
     output = []
 

nettracer3d/segmenter.py

@@ -1011,7 +1011,7 @@ class InteractiveSegmenter:
                 futures.append(future)
             
             def compute_dog_local(img, s1, s2):
-                g1 = ndimage.gaussian_filter(img, s1)
+                g1 = ndimage.gaussian_filter(img, s1) # Consider just having this return the gaussians to
                 g2 = ndimage.gaussian_filter(img, s2)
                 return g1 - g2
 

nettracer3d/smart_dilate.py

@@ -192,7 +192,8 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = Fa
 
         return nettracer.dilate_2D(array, search_distance, scaling = xy_scaling)
 
-    # Determine which dimension needs resampling
+    # Determine which dimension needs resampling. the moral of the story is read documentation before you do something unecessary.
+    """
     if (z_scaling > xy_scaling):
         # Z dimension needs to be stretched
         zoom_factor = [z_scaling/xy_scaling, 1, 1]  # Scale factor for [z, y, x]
@@ -208,11 +209,11 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = Fa
         zoom_factor = None
         rev_factor = None
         cardinal = xy_scaling
-
+    """
 
     # Resample the mask if needed
-    if zoom_factor:
-        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
+    #if zoom_factor:
+        #array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
 
     # Invert the array (find background)
     inv = array < 1
@@ -220,22 +221,22 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = Fa
     if GPU:
         try:
             print("Attempting on GPU...")
-            inv, indices = compute_distance_transform_GPU(inv, return_dists = True)
+            inv, indices = compute_distance_transform_GPU(inv, return_dists = True, sampling = [z_scaling, xy_scaling, xy_scaling])
         except:
             print("Failed, attempting on CPU...")
             #Who would have seen this coming?:
-            inv, indices = compute_distance_transform(inv, return_dists = True)
+            inv, indices = compute_distance_transform(inv, return_dists = True, sampling = [z_scaling, xy_scaling, xy_scaling])
     else:
-        inv, indices = compute_distance_transform(inv, return_dists = True)
+        inv, indices = compute_distance_transform(inv, return_dists = True, sampling = [z_scaling, xy_scaling, xy_scaling])
 
 
-    inv = inv * cardinal
+    #inv = inv * cardinal
     
     # Threshold the distance transform to get dilated result
     inv = inv <= search_distance
 
 
-    return inv.astype(np.uint8), indices, array, rev_factor
+    return inv.astype(np.uint8), indices, array
 
 
 
@@ -275,7 +276,7 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
         binary_nodes = binarize(nodes)
         dilated_binary_nodes = dilate_3D(binary_nodes, dilate_xy, dilate_xy, dilate_z)
     else:
-        dilated_binary_nodes, nearest_label_indices, nodes, rev_factor = dilate_3D_dt(nodes, use_dt_dil_amount, GPU = GPU, xy_scaling = xy_scale, z_scaling = z_scale)
+        dilated_binary_nodes, nearest_label_indices, nodes = dilate_3D_dt(nodes, use_dt_dil_amount, GPU = GPU, xy_scaling = xy_scale, z_scaling = z_scale)
         binary_nodes = binarize(nodes)
 
     # Step 3: Isolate the ring (binary dilated mask minus original binary mask)
@@ -352,8 +353,6 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
     if (dilated_nodes_with_labels.shape[1] < original_shape[1]) and fast_dil: #If downsample was used, upsample output
         dilated_nodes_with_labels = nettracer.upsample_with_padding(dilated_nodes_with_labels, downsample_needed, original_shape)
         dilated_nodes_with_labels = dilated_nodes_with_labels * dilated_mask
-    elif (dilated_nodes_with_labels.shape[1] != original_shape[1]) and not fast_dil:
-        dilated_nodes_with_labels = ndimage.zoom(dilated_nodes_with_labels, rev_factor, order=0)
 
     if directory is not None:
         try:
@@ -472,7 +471,7 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
 
     return dilated_nodes_with_labels
 
-def compute_distance_transform_GPU(nodes, return_dists = False):
+def compute_distance_transform_GPU(nodes, return_dists = False, sampling = [1, 1, 1]):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
@@ -481,7 +480,7 @@ def compute_distance_transform_GPU(nodes, return_dists = False):
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    dists, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    dists, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True, sampling = sampling)
     
     # Convert results back to numpy arrays
     nearest_label_indices_np = cp.asnumpy(nearest_label_indices)
@@ -504,12 +503,12 @@ def compute_distance_transform_GPU(nodes, return_dists = False):
         return dists, nearest_label_indices_np
 
 
-def compute_distance_transform(nodes, return_dists = False):
+def compute_distance_transform(nodes, return_dists = False, sampling = [1, 1, 1]):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
 
-    dists, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+    dists, nearest_label_indices = distance_transform_edt(nodes, return_indices=True, sampling = sampling)
 
     if is_pseudo_3d:
         # For 2D input, we get (2, H, W) but need (3, 1, H, W)
@@ -529,7 +528,7 @@ def compute_distance_transform(nodes, return_dists = False):
 
 
 
-def compute_distance_transform_distance_GPU(nodes):
+def compute_distance_transform_distance_GPU(nodes, sampling = [1, 1, 1]):
 
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
@@ -539,7 +538,7 @@ def compute_distance_transform_distance_GPU(nodes):
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    distance = cpx.distance_transform_edt(nodes_cp)
+    distance = cpx.distance_transform_edt(nodes_cp, sampling = sampling)
     
     # Convert results back to numpy arrays
     distance = cp.asnumpy(distance)
@@ -550,14 +549,14 @@ def compute_distance_transform_distance_GPU(nodes):
     return distance    
 
 
-def compute_distance_transform_distance(nodes):
+def compute_distance_transform_distance(nodes, sampling = [1, 1, 1]):
 
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
 
     # Fallback to CPU if there's an issue with GPU computation
-    distance = distance_transform_edt(nodes)
+    distance = distance_transform_edt(nodes, sampling = sampling)
     if is_pseudo_3d:
         np.expand_dims(distance, axis = 0)
     return distance

{nettracer3d-0.6.7.dist-info → nettracer3d-0.6.9.dist-info}/METADATA

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.7
+Version: 0.6.9
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
-Author-email: Liam McLaughlin <mclaughlinliam99@gmail.com>
-Project-URL: User_Tutorial, https://www.youtube.com/watch?v=cRatn5VTWDY
+Author-email: Liam McLaughlin <liamm@wustl.edu>
+Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
+Project-URL: Video_Tutorial, https://www.youtube.com/watch?v=cRatn5VTWDY
 Project-URL: Reference_Citation_For_Use, https://doi.org/10.1101/2024.07.29.605633
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: ==3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy==1.26.4
@@ -38,20 +39,46 @@ Dynamic: license-file
 
 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 and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
+--- Documentation ---
 
-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 is coming down the line, but for now please see: https://www.youtube.com/watch?v=cRatn5VTWDY
-for a video tutorial on using the GUI.
+Please see: https://nettracer3d.readthedocs.io/en/latest/
+
+--- Installation ---
+
+To install nettracer3d, simply install Python and use this command in your command terminal:
+
+pip install nettracer3d
+
+I recommend installing the program as an Anaconda package to ensure its modules are work together on your specific system:
+(Install anaconda at the link below, set up a new python env for nettracer3d, then use the same pip command).
+
+https://www.anaconda.com/download?utm_source=anacondadocs&utm_medium=documentation&utm_campaign=download&utm_content=installwindows
+
+nettracer3d mostly utilizes the CPU for processing and visualization, although it does have a few GPU-aided options. If you would like to use the GPU for these, you will need an NVIDIA GPU and a corresponding CUDA toolkit which can be installed here:
+https://developer.nvidia.com/cuda-toolkit
+
+To install nettracer3d with associated GPU-supporting packages, please use:
+
+If your CUDA toolkit is version 11: pip install nettracer3d[CUDA11]
+If your CUDA toolkit is version 12: pip install nettracer3d[CUDA12]
+If you just want the entire cupy library: pip install nettracer3d[cupy]
+
+
+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.
+
+
+For a (slightly outdated) video tutorial on using the GUI: https://www.youtube.com/watch?v=cRatn5VTWDY
 
 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.
 
--- Version 0.6.7 updates --
+-- Version 0.6.9 updates --
 
-1. Updated all methods to use dilation to allow the user to select between perfect distance transform based dilation (which can be slower but allows for perfect searching - and is designed to account for scaling differences), or the current pseudo-3d kernel method.
+1. Adjusted all distance transform-based dilation/radius calculating methods to simply use the already supported scipy.ndimage.distance_transform_edt() sampling parameter to account for differentially scaled axis (previously the image was being resampled but now it no longer will need to do that).
 
-1.5. The dt dilator accounts for scaling by stretching (upsampling) images to equivalent scales before dilating with the distance transform. It will not attempt to downsample. This admittedly will ask for greater memory and some more processing. To give the user the option to use the dt dilator without dealing with this, I added two new options to the resize method. You can now have it upsample your image until its equivalently scaled, or, if you don't need the fidelity, downsample your image until it's equivalently scaled. When the scaling is equivalent, the dt dilator will always just use the regular distance transform without attempting to resize the array.
+2. Added new right click option to extract highlighted regions and implant their data onto a separate image or into a new empty image.
 
-2. Fixed radius finding method to also account for scaling correctly. Previous method scaled wrong. New method predictably accounts for differing scaling in xy vs z dims as well.
+3. General bug fixes and improvements.
 
-3. Bug fixes.
+4. Now specifies python 3.11. 

nettracer3d-0.6.9.dist-info/RECORD

@@ -0,0 +1,20 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/community_extractor.py,sha256=5v9SCCLX3P1RX0fjPVKH5NHMFkMolZ5BTe0bR_a67xg,24479
+nettracer3d/modularity.py,sha256=FH3GpTHorRNkdQULe-2DWgFE3i0_u__hrao7Nx_6Ge4,30249
+nettracer3d/morphology.py,sha256=y6OXLvyRmIBFpF3snC7ZirOW3Hg9jsHE11wbe0HrzQM,19692
+nettracer3d/nettracer.py,sha256=muv5Z33KOLKzzzbnNLDad_z1LYCKbuQUuKQLFQ0HAPY,211734
+nettracer3d/nettracer_gui.py,sha256=UCls6Z8O3SaXJUyxzdJlPDxIug7w290VbrojSWQDKs8,417722
+nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
+nettracer3d/proximity.py,sha256=-HoJseoD2O2Q1eLDBMMmM_UYPqM1vZg7bpG4_9Ime-o,12516
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=GnQTVisQUKhackgjFxoldMlbArHEwHGiZPwv-sgPTj0,85072
+nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
+nettracer3d/smart_dilate.py,sha256=SKm5OSu7jcnA7eUKz58_LscadV-lCvY2ZzdVzCvTmkY,25796
+nettracer3d-0.6.9.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.6.9.dist-info/METADATA,sha256=5JFlDK6cwwRKV25onj8KGX6ylD4vFXMaoZM1lzZCGaw,4755
+nettracer3d-0.6.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nettracer3d-0.6.9.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.6.9.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.6.9.dist-info/RECORD,,

nettracer3d-0.6.7.dist-info/RECORD

@@ -1,20 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=5v9SCCLX3P1RX0fjPVKH5NHMFkMolZ5BTe0bR_a67xg,24479
-nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
-nettracer3d/morphology.py,sha256=P7hH9qpDBs0JtMSd95NmrvqoyD8BVq3AjAYv-MWoS_Y,19498
-nettracer3d/nettracer.py,sha256=HDU7z9UOpc2rK1tp-gV7vum27NBNVe8CmfZEeJ7lDBc,209469
-nettracer3d/nettracer_gui.py,sha256=ba_Kx84iu6qfdYKLjhwrS7cXvQQL0_YxrxM9PdIp6kk,401549
-nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
-nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
-nettracer3d/proximity.py,sha256=mHgU24GZy5GGrR6RETB7QACfOURxgiyUze2dxMfs_3o,10917
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=NcNeLSfg3ox-CfnUajT1E2iDqDkv5H6zSJOK_L5N4YI,85020
-nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=ISZR6v52zf-MwhGx-JTfTOP8uo7pNGt-GJj7ydeuMAo,25587
-nettracer3d-0.6.7.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.6.7.dist-info/METADATA,sha256=jAjlCQhz-wFDiHbqF-nbVpEKu95n77H8CZNLP2cRnGI,4172
-nettracer3d-0.6.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nettracer3d-0.6.7.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.6.7.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.6.7.dist-info/RECORD,,