nettracer3d 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

nettracer3d/proximity.py

@@ -10,7 +10,8 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from typing import Dict, Union, Tuple, List, Optional
 from collections import defaultdict
-
+from multiprocessing import Pool, cpu_count
+import functools
 
 # Related to morphological border searching:
 
@@ -200,7 +201,103 @@ def populate_array(centroids, clip=False):
     else:
         return array
 
-def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None):
+def _process_chunk_centroids(args):
+    """Process a chunk of neighbor indices for centroids mode"""
+    chunk_data, idx_to_node, query_indices, tree, points, max_neighbors = args
+    output = []
+    
+    for i, neighbors in chunk_data:
+        query_idx = query_indices[i]
+        query_value = idx_to_node[query_idx]
+        query_point = points[query_idx]
+        
+        # Filter out self-reference
+        filtered_neighbors = [n for n in neighbors if n != query_idx]
+        
+        # If max_neighbors is specified and we have more neighbors than allowed
+        if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
+            # Use KDTree to get distances efficiently - query for more than we need
+            # to ensure we get the exact closest ones
+            k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
+            distances, indices = tree.query(query_point, k=k)
+            
+            # Filter out self and limit to max_neighbors
+            selected_neighbors = []
+            for dist, idx in zip(distances, indices):
+                if idx != query_idx and idx in filtered_neighbors:
+                    selected_neighbors.append(idx)
+                    if len(selected_neighbors) >= max_neighbors:
+                        break
+            
+            filtered_neighbors = selected_neighbors
+        
+        # Add all selected neighbors to output
+        for neighbor_idx in filtered_neighbors:
+            neighbor_value = idx_to_node[neighbor_idx]
+            output.append([query_value, neighbor_value, 0])
+    
+    return output
+
+def _process_chunk_array(args):
+    """Process a chunk of neighbor indices for array mode"""
+    chunk_data, array, point_tuples, query_indices, tree, points, max_neighbors = args
+    output = []
+    
+    for i, neighbors in chunk_data:
+        query_idx = query_indices[i]
+        query_value = array[point_tuples[query_idx]]
+        query_point = points[query_idx]
+        
+        # Filter out self-reference
+        filtered_neighbors = [n for n in neighbors if n != query_idx]
+        
+        # If max_neighbors is specified and we have more neighbors than allowed
+        if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
+            # Use KDTree to get distances efficiently - query for more than we need
+            # to ensure we get the exact closest ones
+            k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
+            distances, indices = tree.query(query_point, k=k)
+            
+            # Filter out self and limit to max_neighbors
+            selected_neighbors = []
+            for dist, idx in zip(distances, indices):
+                if idx != query_idx and idx in filtered_neighbors:
+                    selected_neighbors.append(idx)
+                    if len(selected_neighbors) >= max_neighbors:
+                        break
+            
+            filtered_neighbors = selected_neighbors
+        
+        # Add all selected neighbors to output
+        for neighbor_idx in filtered_neighbors:
+            neighbor_value = array[point_tuples[neighbor_idx]]
+            output.append([query_value, neighbor_value, 0])
+    
+    return output
+
+def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jobs=None, chunk_size=None, max_neighbors=None):
+    """
+    Find neighbors using KDTree with optional parallelization.
+    
+    Parameters:
+    -----------
+    radius : float
+        Search radius for finding neighbors
+    centroids : dict or list, optional
+        Dictionary mapping node IDs to coordinates or list of points
+    array : numpy.ndarray, optional
+        Array to search for nonzero points
+    targets : list, optional
+        Specific targets to query for neighbors
+    n_jobs : int, optional
+        Number of parallel jobs. If None, uses cpu_count(). Set to 1 to disable parallelization.
+    chunk_size : int, optional
+        Size of chunks for parallel processing. If None, auto-calculated based on data size.
+    max_neighbors : int, optional
+        Maximum number of nearest neighbors to return per query point within the radius.
+        If None, returns all neighbors within radius (original behavior).
+    """
+    
     # Get coordinates of nonzero points
     if centroids:
         # If centroids is a dictionary mapping node IDs to coordinates
@@ -214,72 +311,136 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None):
             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
+        # Create direct index-to-node mapping instead of sparse array
+        idx_to_node = {i: node_ids[i] for i in range(len(points))}
+        
     elif array is not None:
         points = np.transpose(np.nonzero(array))
         node_ids = None  # Not used in array-based mode
+        # Pre-convert points to tuples once to avoid repeated conversions
+        point_tuples = [tuple(point) for point in points]
     else:
         return []
     
+    print("Building KDTree...")
     # Create KD-tree from all nonzero points
     tree = KDTree(points)
     
     if targets is None:
         # Original behavior: find neighbors for all points
         query_points = points
-        query_indices = range(len(points))
+        query_indices = list(range(len(points)))
     else:
+        # Convert targets to set for O(1) lookup
+        targets_set = set(targets)
+        
         # Find coordinates of target values
         target_points = []
         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)
+            for idx, point_tuple in enumerate(point_tuples):
+                if array[point_tuple] in targets_set:
+                    target_points.append(points[idx])
                     target_indices.append(idx)
         else:
             # Filter based on node IDs directly
             for idx, node_id in enumerate(node_ids):
-                if node_id in targets:
+                if node_id in targets_set:
                     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
+
         
         # Handle case where no target values were found
         if len(query_points) == 0:
             return []
     
+    print("Querying KDTree...")
+
     # Query for all points within radius of each query point
     neighbor_indices = tree.query_ball_point(query_points, radius)
     
-    # Initialize output list
-    output = []
+    print("Sorting Through Output...")
+
+    # Determine parallelization parameters
+    if n_jobs is None:
+        n_jobs = cpu_count()
     
-    # Generate pairs
-    for i, neighbors in enumerate(neighbor_indices):
-        query_idx = query_indices[i]
-        for neighbor_idx in neighbors:
-            # Skip self-pairing
-            if neighbor_idx != query_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])
+    # Skip parallelization for small datasets or when n_jobs=1
+    if n_jobs == 1 or len(neighbor_indices) < 100:
+        # Sequential processing (original logic with max_neighbors support)
+        output = []
+        for i, neighbors in enumerate(neighbor_indices):
+            query_idx = query_indices[i]
+            query_point = points[query_idx]
+            
+            # Filter out self-reference
+            filtered_neighbors = [n for n in neighbors if n != query_idx]
+            
+            # If max_neighbors is specified and we have more neighbors than allowed
+            if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
+                # Use KDTree to get distances efficiently - query for more than we need
+                # to ensure we get the exact closest ones
+                k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
+                distances, indices = tree.query(query_point, k=k)
+                
+                # Filter out self and limit to max_neighbors
+                selected_neighbors = []
+                for dist, idx in zip(distances, indices):
+                    if idx != query_idx and idx in filtered_neighbors:
+                        selected_neighbors.append(idx)
+                        if len(selected_neighbors) >= max_neighbors:
+                            break
+                
+                filtered_neighbors = selected_neighbors
+            
+            # Process the selected neighbors
+            if centroids:
+                query_value = idx_to_node[query_idx]
+                for neighbor_idx in filtered_neighbors:
+                    neighbor_value = idx_to_node[neighbor_idx]
+                    output.append([query_value, neighbor_value, 0])
+            else:
+                query_value = array[point_tuples[query_idx]]
+                for neighbor_idx in filtered_neighbors:
+                    neighbor_value = array[point_tuples[neighbor_idx]]
+                    output.append([query_value, neighbor_value, 0])
+        return output
+    
+    # Parallel processing
+    if chunk_size is None:
+        # Auto-calculate chunk size: aim for ~4x more chunks than processes
+        chunk_size = max(1, len(neighbor_indices) // (n_jobs * 4))
+    
+    # Create chunks of (index, neighbors) pairs
+    chunks = []
+    for i in range(0, len(neighbor_indices), chunk_size):
+        chunk = [(j, neighbor_indices[j]) for j in range(i, min(i + chunk_size, len(neighbor_indices)))]
+        chunks.append(chunk)
+    
+    # Process chunks in parallel
+    with Pool(processes=n_jobs) as pool:
+        if centroids:
+            # Prepare arguments for centroids mode
+            chunk_args = [(chunk, idx_to_node, query_indices, tree, points, max_neighbors) for chunk in chunks]
+            chunk_results = pool.map(_process_chunk_centroids, chunk_args)
+        else:
+            # Prepare arguments for array mode
+            chunk_args = [(chunk, array, point_tuples, query_indices, tree, points, max_neighbors) for chunk in chunks]
+            chunk_results = pool.map(_process_chunk_array, chunk_args)
+    
+    # Flatten results
+    output = []
+    for chunk_result in chunk_results:
+        output.extend(chunk_result)
+
+    print("Organizing Network...")
+
     
     return output
 
@@ -296,6 +457,69 @@ def extract_pairwise_connections(connections):
     return output
 
 
+def average_nearest_neighbor_distances(point_centroids, root_set, compare_set, xy_scale=1.0, z_scale=1.0, num = 1):
+    """
+    Calculate the average distance between each point in root_set and its nearest neighbor in compare_set.
+    
+    Args:
+        point_centroids (dict): Dictionary mapping point IDs to [Z, Y, X] coordinates
+        root_set (set): Set of point IDs to find nearest neighbors for
+        compare_set (set): Set of point IDs to search for nearest neighbors in
+        xy_scale (float): Scaling factor for X and Y coordinates
+        z_scale (float): Scaling factor for Z coordinate
+    
+    Returns:
+        float: Average distance to nearest neighbors
+    """
+    
+    # Extract and scale coordinates for compare_set
+    compare_coords = []
+    compare_ids = list(compare_set)
+    
+    for point_id in compare_ids:
+        z, y, x = point_centroids[point_id]
+        compare_coords.append([z * z_scale, y * xy_scale, x * xy_scale])
+    
+    compare_coords = np.array(compare_coords)
+    
+    # Build KDTree for efficient nearest neighbor search
+    tree = KDTree(compare_coords)
+    
+    distances = {}
+    same_sets = root_set == compare_set
+    
+    for root_id in root_set:
+        # Get scaled coordinates for root point
+        z, y, x = point_centroids[root_id]
+        root_coord = np.array([z * z_scale, y * xy_scale, x * xy_scale])
+        
+        if same_sets:
+            # When sets are the same, find 2 nearest neighbors and take the second one
+            # (first one would be the point itself)
+            distances_to_all, indices = tree.query(root_coord, k= (num + 1))
+
+            temp_dist = 0
+            for i in range(1, len(distances_to_all)):
+                temp_dist += distances_to_all[i]
+
+            distances[root_id] = temp_dist/(len(distances_to_all) - 1)
+
+        else:
+            # Different sets, find nearest neighbors
+            distances_to_all, _ = tree.query(root_coord, k=num)
+            temp_dist = 0
+            for val in distances_to_all:
+                temp_dist += val
+
+            distances[root_id] = temp_dist/(len(distances_to_all))
+
+    avg = np.mean(list(distances.values())) if list(distances.values()) else 0.0
+
+    
+    # Return average distance
+    return avg, distances
+
+
 
 #voronois:
 def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, int, int], List[int]]], 

nettracer3d-0.8.2.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: nettracer3d
+Version: 0.8.2
+Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
+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.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: Pillow
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: opencv-python-headless
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: tifffile
+Requires-Dist: qtrangeslider
+Requires-Dist: PyQt6
+Requires-Dist: scikit-learn
+Requires-Dist: nibabel
+Requires-Dist: setuptools
+Requires-Dist: umap-learn
+Provides-Extra: cuda11
+Requires-Dist: cupy-cuda11x; extra == "cuda11"
+Provides-Extra: cuda12
+Requires-Dist: cupy-cuda12x; extra == "cuda12"
+Provides-Extra: cupy
+Requires-Dist: cupy; extra == "cupy"
+Provides-Extra: cellpose
+Requires-Dist: cellpose[GUI]; extra == "cellpose"
+Provides-Extra: viz
+Requires-Dist: napari; extra == "viz"
+Provides-Extra: all
+Requires-Dist: cellpose[GUI]; extra == "all"
+Requires-Dist: napari; extra == "all"
+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 ---
+
+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
+
+Optional Packages
+~~~~~~~~~~~~~~~~~~
+I recommend including Napari (Chi-Li Chiu, Nathan Clack, the napari community, napari: a Python Multi-Dimensional Image Viewer Platform for the Research Community, Microscopy and Microanalysis, Volume 28, Issue S1, 1 August 2022, Pages 1576–1577, https://doi.org/10.1017/S1431927622006328) in the download as well, which allows NetTracer3D to use 3D displays. The standard package only comes with its native 2D slice display window. 
+If Napari is present, all 3D images and overlays from NetTracer3D can be easily displayed in 3D with a click of a button. To package with Napari, use this install command instead: 
+
+    pip install nettracer3d[viz]
+
+Additionally, for easy access to high-quality cell segmentation, as of version 0.8.2, NetTracer3D can be optionally packaged with Cellpose3. (Stringer, C., Pachitariu, M. Cellpose3: one-click image restoration for improved cellular segmentation. Nat Methods 22, 592–599 (2025). https://doi.org/10.1038/s41592-025-02595-5)
+Cellpose3 is not involved with the rest of the program in any way, although its GUI can be opened from NetTracer3D's GUI, provided both are installed in the same environment. It is a top-tier cell segmenter which can assist in the production of cell networks.
+To include Cellpose3 in the install, use this command:
+
+
+    pip install nettracer3d[cellpose]
+
+Alternatively, both Napari and Cellpose can be included in the package with this command: (Or they can be independently installed with pip from the base package env)
+
+
+    pip install nettracer3d[all]
+
+GPU
+~~~~~~~~~~~~~~~~~~
+NetTracer3D is mostly CPU-bound, but a few functions can optionally use the GPU. To install optional GPU functionalities, first set up a CUDA toolkit that runs with the GPU on your machine. This requires an NVIDIA GPU. Then, find your GPUs compatible CUDA toolkit and install it with the auto-installer from the NVIDIA website: https://developer.nvidia.com/cuda-toolkit
+
+With a CUDA toolkit installed, use:
+
+    pip install nettracer3d[CUDA11] #If your CUDA toolkit is version 11
+    pip install nettracer3d[CUDA12] #If your CUDA toolkit is version 12
+    pip install nettracer3d[cupy] #For the generic cupy library (The above two are usually the ones you want)
+
+Or if you've already installed the NetTracer3D base package and want to get just the GPU associated packages:
+
+    pip install cupy-cuda11x #If your CUDA toolkit is version 11
+    pip install cupy-cuda12x #If your CUDA toolkit is version 12
+    pip install cupy #For the generic cupy library (The above two are usually the ones you want)
+
+While not related to NetTracer3D, if you want to use Cellpose3 (for which GPU-usage is somewhat obligatory) to help segment cells for any networks, you will also want to install pytorch here: https://pytorch.org/. Use the pytorch build menu on this webpage to find a pip install command that is compatible with Python and your CUDA version.
+
+
+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.8.2 Updates -- 
+
+	* Bug Fixes.
+	* Improved some of the image viewer window features.
+	* New option to zoom in on specific windows by clicking + dragging while in zoom mode.
+	* Added more features to UMAP/community neighborhood clustering (optional DBSCAN clustering, results more robust to node distribution)
+	* Made Napari and optional rather than core dependency.
+	* Added Cellpose as an optional dependency.

nettracer3d-0.8.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/cellpose_manager.py,sha256=qZpTxSkmPb38Pru8TmjJ88xxcD_wM02EfJB5Mw9Xx4Y,6021
+nettracer3d/community_extractor.py,sha256=oa4e0bAwUALDgu_QdBiqNNn1XrmOW3drD5bjwey81BI,25313
+nettracer3d/excelotron.py,sha256=lS5vnpoOGZWp7fdqVpTPqeC-mUKrfwDrWHfx4PQ7Uzg,71384
+nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,21788
+nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
+nettracer3d/neighborhoods.py,sha256=ac_gjN7pUlXZZpMSZnUVErKbKtSlInxX2dHe22oDNJA,34532
+nettracer3d/nettracer.py,sha256=L7FGwgiuzIloFBcQmR7UNYGicJMHgHL-etIgogCrRE0,235084
+nettracer3d/nettracer_gui.py,sha256=QRZEEazgO-8jLjZu29ZDD2MLnC4rObISbZgLFiQxgbE,526421
+nettracer3d/network_analysis.py,sha256=yUEzy4hBDTuZvXwFuJWdIQcxqPW4z67APe4zcjCjDW8,43613
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=LoeTFeOcrX6kPquZvCqYnMW-jDd9oqKM27r-rTlKEtY,10274
+nettracer3d/proximity.py,sha256=mRkug_y6fbqq_pOYTkF5uOoiRhvYv2e_QFC92ZTraYE,38110
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=VatOSpc41lxhPuYLTTejCxG1CcwP5hwiQ3ZFK9OBavA,60115
+nettracer3d/segmenter_GPU.py,sha256=sFVmz_cYIVOQqnfFV3peK9hzb6IoIV5WDQHH9Lws96I,53915
+nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
+nettracer3d/smart_dilate.py,sha256=DOEOQq9ig6-AO4MpqAG0CqrGDFqw5_UBeqfSedqHk28,25933
+nettracer3d-0.8.2.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.8.2.dist-info/METADATA,sha256=QlUhREQ7hy0wHfA8nKn6Qu_W-QONoGPSQY5yp9GEBYE,7112
+nettracer3d-0.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.8.2.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.8.2.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.8.2.dist-info/RECORD,,

nettracer3d-0.8.0.dist-info/METADATA

@@ -1,83 +0,0 @@
-Metadata-Version: 2.4
-Name: nettracer3d
-Version: 0.8.0
-Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
-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.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: scikit-image
-Requires-Dist: Pillow
-Requires-Dist: matplotlib
-Requires-Dist: networkx
-Requires-Dist: opencv-python-headless
-Requires-Dist: openpyxl
-Requires-Dist: pandas
-Requires-Dist: napari
-Requires-Dist: tifffile
-Requires-Dist: qtrangeslider
-Requires-Dist: PyQt6
-Requires-Dist: scikit-learn
-Requires-Dist: nibabel
-Requires-Dist: setuptools
-Requires-Dist: umap-learn
-Provides-Extra: cuda11
-Requires-Dist: cupy-cuda11x; extra == "cuda11"
-Provides-Extra: cuda12
-Requires-Dist: cupy-cuda12x; extra == "cuda12"
-Provides-Extra: cupy
-Requires-Dist: cupy; extra == "cupy"
-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 ---
-
-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.8.0 Updates -- 
-
-	* Added ability to threshold nodes by degree.
-	* Improved image viewer window performance.
-	* Bug fixes and a few optimizations.
-	* Added ability to 'merge node identities' which just uses the nodes image as a reference for collecting 'identity' information from a group of other images - ie can use with cell nuclei (DAPI) to see what markers from the same imaging session overlap.
-	* Added ability to search for specific nodes directly in the nodes image with 'shift + f' or right click.
-	

nettracer3d-0.8.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=ZOz97Au4k7dHK8azarWQtxCPyvwzGmDHNL8kTIC9by8,22670
-nettracer3d/excelotron.py,sha256=lS5vnpoOGZWp7fdqVpTPqeC-mUKrfwDrWHfx4PQ7Uzg,71384
-nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,21788
-nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
-nettracer3d/neighborhoods.py,sha256=kkKR8m6Gjw34cDd_mytAIwLxqvuNBtQb2hU4JuBY9pI,12301
-nettracer3d/nettracer.py,sha256=494nHDmdrdfecTAShbXc0eFE2tG6WKJtEqKvJyt4sh4,227141
-nettracer3d/nettracer_gui.py,sha256=Pc_t5pDk0P4gpyC1axx37JJX6EpMvXdj0UHbqjqENrQ,501757
-nettracer3d/network_analysis.py,sha256=h-5yzUWdE0hcWYy8wcBA5LV1bRhdqiMnKbQLrRzb1Sw,41443
-nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
-nettracer3d/proximity.py,sha256=hPmTPFGUziPMVwfWRLVV9gUjqSL7nzLD6WAVLekvxbE,28545
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=VatOSpc41lxhPuYLTTejCxG1CcwP5hwiQ3ZFK9OBavA,60115
-nettracer3d/segmenter_GPU.py,sha256=sFVmz_cYIVOQqnfFV3peK9hzb6IoIV5WDQHH9Lws96I,53915
-nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
-nettracer3d/smart_dilate.py,sha256=DOEOQq9ig6-AO4MpqAG0CqrGDFqw5_UBeqfSedqHk28,25933
-nettracer3d-0.8.0.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.8.0.dist-info/METADATA,sha256=2bK3auAT6Xr7y_VDBaZE_cB4dgShYtF0qrIzcuTDflU,4605
-nettracer3d-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-0.8.0.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.8.0.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.8.0.dist-info/RECORD,,