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

nettracer3d/proximity.py

@@ -64,13 +64,13 @@ def reslice_3d_array(args):
 
 
 
-def _get_node_node_dict(label_array, label, dilate_xy, dilate_z):
+def _get_node_node_dict(label_array, label, dilate_xy, dilate_z, fastdil = False, xy_scale = 1, z_scale = 1, search = 0):
     """Internal method used for the secondary algorithm to find which nodes interact 
     with which other nodes based on proximity."""
     
     # Create a boolean mask where elements with the specified label are True
     binary_array = label_array == label
-    binary_array = nettracer.dilate_3D_recursive(binary_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
+    binary_array = nettracer.dilate(binary_array, search, xy_scale, z_scale, fast_dil = fastdil, dilate_xy = dilate_xy, dilate_z = dilate_z) #Dilate the label to see where the dilated label overlaps
     label_array = label_array * binary_array  # Filter the labels by the node in question
     label_array = label_array.flatten()  # Convert 3d array to 1d array
     label_array = nettracer.remove_zeros(label_array)  # Remove zeros
@@ -82,7 +82,7 @@ def _get_node_node_dict(label_array, label, dilate_xy, dilate_z):
 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
@@ -97,10 +97,11 @@ def process_label(args):
     return label, sub_nodes
 
 
-def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets=None):
-    """Modified to pre-compute all bounding boxes using find_objects"""
+def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets=None, fastdil = False, xy_scale = 1, z_scale = 1, search = 0):
+    """pre-compute all bounding boxes using find_objects"""
     node_dict = {}
     array_shape = nodes.shape
+
     
     # Get all bounding boxes at once
     bounding_boxes = ndimage.find_objects(nodes)
@@ -118,17 +119,17 @@ def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets=None):
 
         # Process results in parallel
         for label, sub_nodes in results:
-            executor.submit(create_dict_entry, node_dict, label, sub_nodes, dilate_xy, dilate_z)
+            executor.submit(create_dict_entry, node_dict, label, sub_nodes, dilate_xy, dilate_z, fastdil = fastdil, xy_scale = xy_scale, z_scale = z_scale, search = search)
 
     return node_dict
 
-def create_dict_entry(node_dict, label, sub_nodes, dilate_xy, dilate_z):
+def create_dict_entry(node_dict, label, sub_nodes, dilate_xy, dilate_z, fastdil = False, xy_scale = 1, z_scale = 1, search = 0):
     """Internal method used for the secondary algorithm to pass around args in parallel."""
 
     if label is None:
         pass
     else:
-        node_dict[label] = _get_node_node_dict(sub_nodes, label, dilate_xy, dilate_z)
+        node_dict[label] = _get_node_node_dict(sub_nodes, label, dilate_xy, dilate_z, fastdil = fastdil, xy_scale = xy_scale, z_scale = z_scale, search = search)
 
 def find_shared_value_pairs(input_dict):
     """Internal method used for the secondary algorithm to look through discrete 

nettracer3d/segmenter.py

@@ -1,18 +1,5 @@
 from sklearn.ensemble import RandomForestClassifier
 import numpy as np
-try:
-    import torch
-except:
-    pass
-try:
-    import cupy as cp
-    import cupyx.scipy.ndimage as cpx
-except:
-    pass
-try:
-    from cuml.ensemble import RandomForestClassifier as cuRandomForestClassifier
-except:
-    pass
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 import threading
@@ -218,13 +205,20 @@ class InteractiveSegmenter:
         
         # Gaussian and DoG using scipy
         #print("Obtaining gaussians")
-        for sigma in [0.5, 1.0, 2.0, 4.0]:
+        for sigma in self.alphas:
             smooth = ndimage.gaussian_filter(image_3d, sigma)
             features.append(smooth)
+
+        # Difference of Gaussians
+        for (s1, s2) in self.dogs:
+            g1 = ndimage.gaussian_filter(image_3d, s1)
+            g2 = ndimage.gaussian_filter(image_3d, s2)
+            dog = g1 - g2
+            features.append(dog)
         
         #print("Computing local statistics")
         # Local statistics using scipy's convolve
-        window_size = 5
+        window_size = self.windows
         kernel = np.ones((window_size, window_size, window_size)) / (window_size**3)
         
         # Local mean
@@ -299,7 +293,7 @@ class InteractiveSegmenter:
             for (s1, s2) in self.dogs:
                 
                 future = executor.submit(compute_dog_local, image_3d, s1, s2)
-                futures.append('dog', s1, future)
+                futures.append(('dog', s1, future))
             
             # Local statistics computation
             def compute_local_mean():
@@ -960,13 +954,13 @@ class InteractiveSegmenter:
         
         # Gaussian smoothing at different scales
         #print("Obtaining gaussians")
-        for sigma in [0.5, 1.0, 2.0, 4.0]:
+        for sigma in self.alphas:
             smooth = ndimage.gaussian_filter(image_3d, sigma)
             features.append(smooth)
         
         #print("Obtaining dif of gaussians")
         # Difference of Gaussians
-        for (s1, s2) in [(1, 2), (2, 4)]:
+        for (s1, s2) in self.dogs:
             g1 = ndimage.gaussian_filter(image_3d, s1)
             g2 = ndimage.gaussian_filter(image_3d, s2)
             dog = g1 - g2

nettracer3d/smart_dilate.py

@@ -2,6 +2,7 @@ import tifffile
 import numpy as np
 from scipy.ndimage import binary_dilation, distance_transform_edt
 from scipy.ndimage import gaussian_filter
+from scipy import ndimage
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import cv2
 import os
@@ -145,45 +146,99 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
     return final_result
 
 
-def dilate_3D_old(tiff_array, dilated_x, dilated_y, dilated_z):
-    """Dilate an array in 3D. Consider replacing with scipy dilation method.
-    Arguments are an array,  and the desired pixel dilation amounts in X, Y, Z."""
+def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
+    """
+    Dilate a 3D array using scipy.ndimage.binary_dilation with a 3x3x3 cubic kernel.
+    
+    Arguments:
+    tiff_array -- Input 3D binary array
+    dilated_x -- Fixed at 3 for X dimension
+    dilated_y -- Fixed at 3 for Y dimension
+    dilated_z -- Fixed at 3 for Z dimension
+    
+    Returns:
+    Dilated 3D array
+    """
+    import numpy as np
+    from scipy import ndimage
+    
+    # Handle special case for 2D arrays
+    if tiff_array.shape[0] == 1:
+        # Call 2D dilation function if needed
+        return dilate_2D(tiff_array, 1)  # For a 3x3 kernel, radius is 1
+    
+    # Create a simple 3x3x3 cubic kernel (all ones)
+    kernel = np.ones((3, 3, 3), dtype=bool)
+    
+    # Perform binary dilation
+    dilated_array = ndimage.binary_dilation(tiff_array.astype(bool), structure=kernel)
+    
+    return dilated_array.astype(np.uint8)
 
-    # 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)
+def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = False):
+    """
+    Dilate a 3D array using distance transform method. Dt dilation produces perfect results but only works in euclidean geometry and lags in big arrays.
+    
+    Parameters:
+    array -- Input 3D binary array
+    search_distance -- Distance within which to dilate
+    xy_scaling -- Scaling factor for x and y dimensions (default: 1.0)
+    z_scaling -- Scaling factor for z dimension (default: 1.0)
+    
+    Returns:
+    Dilated 3D array
+    """
+    if array.shape[0] == 1:
+
+        return nettracer.dilate_2D(array, search_distance, scaling = xy_scaling)
+
+    # Determine which dimension needs resampling
+    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]
+        rev_factor = [xy_scaling/z_scaling, 1, 1] 
+        cardinal = xy_scaling
+    elif (xy_scaling > z_scaling):
+        # XY dimensions need to be stretched
+        zoom_factor = [1, xy_scaling/z_scaling, xy_scaling/z_scaling]  # Scale factor for [z, y, x]
+        rev_factor = [1, z_scaling/xy_scaling, z_scaling/xy_scaling]  # Scale factor for [z, y, x]
+        cardinal = z_scaling
+    else:
+        # Already uniform scaling, no need to resample
+        zoom_factor = None
+        rev_factor = None
+        cardinal = xy_scaling
 
-    # Perform 2D dilation in the XY plane
-    for z in range(tiff_array.shape[0]):
-        kernel_x = int(dilated_x)
-        kernel_y = int(dilated_y)
-        kernel = np.ones((kernel_y, kernel_x), dtype=np.uint8)
 
+    # Resample the mask if needed
+    if zoom_factor:
+        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
 
-        # Convert the slice to the appropriate data type
-        tiff_slice = tiff_array[z].astype(np.uint8)
-
-        dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
-        dilated_xy[z] = dilated_slice
+    # Invert the array (find background)
+    inv = array < 1
+    
+    if GPU:
+        try:
+            print("Attempting on GPU...")
+            inv, indices = compute_distance_transform_GPU(inv, return_dists = True)
+        except:
+            print("Failed, attempting on CPU...")
+            #Who would have seen this coming?:
+            inv, indices = compute_distance_transform(inv, return_dists = True)
+    else:
+        inv, indices = compute_distance_transform(inv, return_dists = True)
 
-    # Perform 2D dilation in the XZ plane
-    for y in range(tiff_array.shape[1]):
-        kernel_x = int(dilated_x)
-        kernel_z = int(dilated_z)
-        kernel = np.ones((kernel_z, kernel_x), dtype=np.uint8)
 
+    inv = inv * cardinal
+    
+    # Threshold the distance transform to get dilated result
+    inv = inv <= search_distance
 
-        # Convert the slice to the appropriate data type
-        tiff_slice = tiff_array[:, y, :].astype(np.uint8)
 
-        dilated_slice = cv2.dilate(tiff_slice, kernel, iterations=1)
-        dilated_xz[:, y, :] = dilated_slice
+    return inv.astype(np.uint8), indices, array, rev_factor
 
-    # Overlay the results (you can use logical OR operation or another method)
-    final_result = dilated_xy | dilated_xz
 
 
-    return final_result
 
 def binarize(image):
     """Convert an array from numerical values to boolean mask"""
@@ -209,71 +264,73 @@ def process_chunk(start_idx, end_idx, nodes, ring_mask, nearest_label_indices):
     
     return dilated_nodes_with_labels_chunk
 
-def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_dil = False, predownsample = None):
+def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_dil = True, predownsample = None, use_dt_dil_amount = None, xy_scale = 1, z_scale = 1):
 
     original_shape = nodes.shape
 
-    # Step 1: Binarize the labeled array
-    binary_nodes = binarize(nodes)
 
-    # Step 2: Dilate the binarized array
-    if not fast_dil:
+    #Dilate the binarized array
+    if fast_dil:
+        # Step : Binarize the labeled array
+        binary_nodes = binarize(nodes)
         dilated_binary_nodes = dilate_3D(binary_nodes, dilate_xy, dilate_xy, dilate_z)
     else:
-        dilated_binary_nodes = dilate_3D_old(binary_nodes, dilate_xy, dilate_xy, dilate_z)
-
+        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)
+        binary_nodes = binarize(nodes)
 
     # Step 3: Isolate the ring (binary dilated mask minus original binary mask)
     ring_mask = dilated_binary_nodes & invert_array(binary_nodes)
 
+    del binary_nodes
+
     print("Preforming distance transform for smart search... this step may take some time if computed on CPU...")
 
-    try:
+    if fast_dil:
 
-        if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:
-            print("GPU detected. Using CuPy for distance transform.")
+        try:
 
-            try:
+            if GPU == True and cp.cuda.runtime.getDeviceCount() > 0:
+                print("GPU detected. Using CuPy for distance transform.")
 
-                if predownsample is None:
+                try:
 
-                    # Step 4: Find the nearest label for each voxel in the ring
-                    nearest_label_indices = compute_distance_transform_GPU(invert_array(nodes))
+                    if predownsample is None:
 
-                else:
-                    gotoexcept = 1/0
+                        # Step 4: Find the nearest label for each voxel in the ring
+                        nearest_label_indices = compute_distance_transform_GPU(invert_array(nodes))
 
-            except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
-                if predownsample is None:
-                    down_factor = catch_memory(e) #Obtain downsample amount based on memory missing
-                else:
-                    down_factor = (predownsample)**3
+                    else:
+                        gotoexcept = 1/0
 
-                while True:
-                    downsample_needed = down_factor**(1./3.)
-                    small_nodes = nettracer.downsample(nodes, downsample_needed) #Apply downsample
-                    try:
-                        nearest_label_indices = compute_distance_transform_GPU(invert_array(small_nodes)) #Retry dt on downsample
-                        print(f"Using {down_factor} downsample ({downsample_needed} in each dim - Largest possible with this GPU unless user specified downsample)")
-                        break
-                    except cp.cuda.memory.OutOfMemoryError:
-                        down_factor += 1
-                binary_nodes = binarize(small_nodes) #Recompute variables for downsample
-                dilated_mask = dilated_binary_nodes #Need this for later to stamp out the correct output
-                if not fast_dil:
+                except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
+                    if predownsample is None:
+                        down_factor = catch_memory(e) #Obtain downsample amount based on memory missing
+                    else:
+                        down_factor = (predownsample)**3
+
+                    while True:
+                        downsample_needed = down_factor**(1./3.)
+                        small_nodes = nettracer.downsample(nodes, downsample_needed) #Apply downsample
+                        try:
+                            nearest_label_indices = compute_distance_transform_GPU(invert_array(small_nodes)) #Retry dt on downsample
+                            print(f"Using {down_factor} downsample ({downsample_needed} in each dim - Largest possible with this GPU unless user specified downsample)")
+                            break
+                        except cp.cuda.memory.OutOfMemoryError:
+                            down_factor += 1
+                    binary_nodes = binarize(small_nodes) #Recompute variables for downsample
+                    dilated_mask = dilated_binary_nodes #Need this for later to stamp out the correct output
                     dilated_binary_nodes = dilate_3D(binary_nodes, 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_z/downsample_needed)) #Mod dilation to recompute variables for downsample while also over dilatiing
-                else:
-                    dilated_binary_nodes = dilate_3D_old(binary_nodes, 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_xy/downsample_needed), 2 + round_to_odd(dilate_z/downsample_needed)) 
-                ring_mask = dilated_binary_nodes & invert_array(binary_nodes)
-                nodes = small_nodes
-                del small_nodes
-        else:
-            goto_except = 1/0
-    except Exception as e:
-        print("GPU dt failed or did not detect GPU (cupy must be installed with a CUDA toolkit setup...). Computing CPU distance transform instead.")
-        if GPU:
-            print(f"Error message: {str(e)}")
-        nearest_label_indices = compute_distance_transform(invert_array(nodes))
+
+                    ring_mask = dilated_binary_nodes & invert_array(binary_nodes)
+                    nodes = small_nodes
+                    del small_nodes
+            else:
+                goto_except = 1/0
+        except Exception as e:
+            print("GPU dt failed or did not detect GPU (cupy must be installed with a CUDA toolkit setup...). Computing CPU distance transform instead.")
+            if GPU:
+                print(f"Error message: {str(e)}")
+            nearest_label_indices = compute_distance_transform(invert_array(nodes))
 
 
     # Step 5: Process in parallel chunks using ThreadPoolExecutor
@@ -284,12 +341,19 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
         args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else nodes.shape[0], nodes, ring_mask, nearest_label_indices) for i in range(num_cores)]
         results = list(executor.map(lambda args: process_chunk(*args), args_list))
 
+    del ring_mask
+    del nodes
+    del nearest_label_indices
+
     # Combine results from chunks
     dilated_nodes_with_labels = np.concatenate(results, axis=0)
 
-    if nodes.shape[1] < original_shape[1]: #If downsample was used, upsample output
+
+    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:
@@ -364,7 +428,7 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
                 binary_core = binarize(small_array)
                 label_array = small_array
                 binary_array = nettracer.downsample(binary_array, downsample_needed)
-                binary_array = nettracer.dilate_3D(binary_array, 3, 3, 3)
+                binary_array = nettracer.dilate_3D_old(binary_array)
                 ring_mask = binary_array & invert_array(binary_core)
 
         else:
@@ -408,7 +472,7 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
 
     return dilated_nodes_with_labels
 
-def compute_distance_transform_GPU(nodes):
+def compute_distance_transform_GPU(nodes, return_dists = False):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
@@ -417,7 +481,7 @@ def compute_distance_transform_GPU(nodes):
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    _, 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)
     
     # Convert results back to numpy arrays
     nearest_label_indices_np = cp.asnumpy(nearest_label_indices)
@@ -430,18 +494,22 @@ def compute_distance_transform_GPU(nodes):
         # indices_4d[0] stays 0 for all Z coordinates
         nearest_label_indices_np = indices_4d
 
-    
+    if not return_dists:
 
+        return nearest_label_indices_np
+
+    else:
+        dists = cp.asnumpy(dists)
 
-    return nearest_label_indices_np
+        return dists, nearest_label_indices_np
 
 
-def compute_distance_transform(nodes):
+def compute_distance_transform(nodes, return_dists = False):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
 
-    distance, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+    dists, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
 
     if is_pseudo_3d:
         # For 2D input, we get (2, H, W) but need (3, 1, H, W)
@@ -451,7 +519,13 @@ def compute_distance_transform(nodes):
         # indices_4d[0] stays 0 for all Z coordinates
         nearest_label_indices = indices_4d
 
-    return nearest_label_indices
+    if not return_dists:
+
+        return nearest_label_indices
+
+    else:
+
+        return dists, nearest_label_indices
 
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.6
+Version: 0.6.7
 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
@@ -46,8 +46,12 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.6.6 updates --
+-- Version 0.6.7 updates --
 
-1. Updated flexibility of the fill holes method for user with varying use cases.
+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.
 
-2. Greatly improved memory efficiency of segmenter. Now works comfortably with 3.5 GB array on my machine for example (my machine has 64 GB RAM and this occupied around 20% of it I would say). Removed the non-memory efficient option (now always prioritizes mem - the former wasn't even that much faster anyway), removed GPU option (would need an entire cupy-centric build, does not make sense to be sharing a script with the CPU version). 
+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. 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. Bug fixes.

nettracer3d-0.6.7.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=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,,

nettracer3d-0.6.6.dist-info/RECORD

@@ -1,20 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=Zq8ZM595CTzeR6zLEZ4I6KvhkNfCPUReWvAKxTlaVfk,33495
-nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
-nettracer3d/morphology.py,sha256=yncUj04Noj_mcdJze4qMfYw-21AbebwiIcu1bDWGgCM,17778
-nettracer3d/nettracer.py,sha256=iq2EybaXzC9pdkNMmLQ_EqfFqHWMK-jxYqpb8Su61xQ,210230
-nettracer3d/nettracer_gui.py,sha256=o2DiNbEDrf5CK_CdIZNjArmx-eKbwHk25rzBwVeRE5A,394393
-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=FnIiI_AzfXd22HwCIFIyQRZxKYJ8YscIDdPnIv-wsO4,10560
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=MC4-Bkz1JKcbkISwJaoCwhNmys9E2iXp1gmCn049JjU,85023
-nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=vnBj2soDGVBioKaNQi-bcyAtg0nuWcNGmlrzUNFFYQE,23191
-nettracer3d-0.6.6.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.6.6.dist-info/METADATA,sha256=gro7B_GK6lL1oL-nd64pO69ynXwbZKBvShNBTKJVYu0,3559
-nettracer3d-0.6.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nettracer3d-0.6.6.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.6.6.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.6.6.dist-info/RECORD,,