nettracer3d 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

nettracer3d/network_analysis.py

@@ -136,7 +136,6 @@ def open_network(excel_file_path):
         G.add_edge(nodes_a[i], nodes_b[i])
 
     return G
-
 def read_excel_to_lists(file_path, sheet_name=0):
     """Convert a pd dataframe to lists. Handles both .xlsx and .csv files"""
     def load_json_to_list(filename):
@@ -157,6 +156,61 @@ def read_excel_to_lists(file_path, sheet_name=0):
                 converted_data[k] = v
         
         return converted_data
+        
+    if type(file_path) == str:
+        # Check file extension
+        if file_path.lower().endswith('.xlsx'):
+            # Read the Excel file with headers (since your new save method includes them)
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+        elif file_path.lower().endswith('.csv'):
+            # Read the CSV file with headers and specify dtype to avoid the warning
+            df = pd.read_csv(file_path, dtype=str, low_memory=False)
+        elif file_path.lower().endswith('.json'):
+            df = load_json_to_list(file_path)
+            return df
+        else:
+            raise ValueError("File must be either .xlsx, .csv, or .json format")
+    else:
+        df = file_path
+        
+    # Initialize an empty list to store the lists of values
+    data_lists = []
+    # Iterate over each column in the DataFrame
+    for column_name, column_data in df.items():
+        # Convert the column values to a list and append to the data_lists
+        data_lists.append(column_data.tolist())
+        
+    master_list = [[], [], []]
+    for i in range(0, len(data_lists), 3):
+        master_list[0].extend([int(x) for x in data_lists[i]])
+        master_list[1].extend([int(x) for x in data_lists[i+1]])
+        try:
+            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
+            
+    return master_list
+
+def read_excel_to_lists_old(file_path, sheet_name=0):
+    """Convert a pd dataframe to lists. Handles both .xlsx and .csv files"""
+    def load_json_to_list(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = [[],[],[]]
+        for i in data[0]:
+            try:
+                converted_data[0].append(int(data[0][i]))
+                converted_data[1].append(int(data[1][i]))
+                try:
+                    converted_data[2].append(int(data[2][i]))
+                except IndexError:
+                    converted_data[2].append(0)
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
 
     if type(file_path) == str:
         # Check file extension
@@ -545,42 +599,51 @@ def _find_centroids_old(nodes, node_list = None, down_factor = None):
 
     return centroid_dict
 
+
 def _find_centroids(nodes, node_list=None, down_factor=None):
     """Internal use version to get centroids without saving"""
-    def get_label_indices(binary_stack, label, y_offset):
-        """
-        Finds indices of labelled object in array and adjusts for the Y-offset.
-        """
-        indices = np.argwhere(binary_stack == label)
-        # Adjust the Y coordinate by the y_offset
-        indices[:, 1] += y_offset
-        return indices
+    
     
     def compute_indices_in_chunk(chunk, y_offset):
         """
-        Get indices for all labels in a given chunk of the 3D array.
-        Adjust Y-coordinate based on the y_offset for each chunk.
+        Alternative approach using np.where for even better performance on sparse arrays.
         """
         indices_dict_chunk = {}
-        label_list = np.unique(chunk)
-        try:
-            if label_list[0] == 0:
-                label_list = np.delete(label_list, 0)
-        except:
-            pass
         
-        for label in label_list:
-            indices = get_label_indices(chunk, label, y_offset)
-            indices_dict_chunk[label] = indices
+        # Get all coordinates where chunk is non-zero
+        z_coords, y_coords, x_coords = np.where(chunk != 0)
+        
+        if len(z_coords) == 0:
+            return indices_dict_chunk
+        
+        # Adjust Y coordinates
+        y_coords_adjusted = y_coords + y_offset
+        
+        # Get labels at these coordinates
+        labels = chunk[z_coords, y_coords, x_coords]
+        
+        # Group by unique labels
+        unique_labels = np.unique(labels)
+        
+        for label in unique_labels:
+            if label == 0:  # Skip background
+                continue
+            mask = (labels == label)
+            # Stack coordinates into the expected format [z, y, x]
+            indices_dict_chunk[label] = np.column_stack((
+                z_coords[mask], 
+                y_coords_adjusted[mask], 
+                x_coords[mask]
+            ))
+        
         return indices_dict_chunk
     
     def chunk_3d_array(array, num_chunks):
-        """
-        Split the 3D array into smaller chunks along the y-axis.
-        """
+        """Split the 3D array into smaller chunks along the y-axis."""
         y_slices = np.array_split(array, num_chunks, axis=1)
         return y_slices
     
+    # Handle input processing
     if isinstance(nodes, str):  # Open into numpy array if filepath
         nodes = tifffile.imread(nodes)
         if len(np.unique(nodes)) == 2:  # Label if binary
@@ -595,14 +658,14 @@ def _find_centroids(nodes, node_list=None, down_factor=None):
     indices_dict = {}
     num_cpus = mp.cpu_count()
     
-    # Chunk the 3D array along the y-axis into smaller subarrays
+    # Chunk the 3D array along the y-axis
     node_chunks = chunk_3d_array(nodes, num_cpus)
     
     # Calculate Y offset for each chunk
     chunk_sizes = [chunk.shape[1] for chunk in node_chunks]
     y_offsets = np.cumsum([0] + chunk_sizes[:-1])
     
-    # Parallel computation of indices across chunks
+    # Parallel computation using the optimized single-pass approach
     with ThreadPoolExecutor(max_workers=num_cpus) as executor:
         futures = {executor.submit(compute_indices_in_chunk, chunk, y_offset): chunk_id
                   for chunk_id, (chunk, y_offset) in enumerate(zip(node_chunks, y_offsets))}
@@ -622,10 +685,8 @@ def _find_centroids(nodes, node_list=None, down_factor=None):
         centroid = np.round(np.mean(indices, axis=0)).astype(int)
         centroid_dict[label] = centroid
     
-    try:
-        del centroid_dict[0]
-    except:
-        pass
+    # Remove background label if it exists
+    centroid_dict.pop(0, None)
     
     return centroid_dict
 

nettracer3d/node_draw.py

@@ -200,8 +200,12 @@ def degree_draw(degree_dict, centroid_dict, nodes):
 
     return draw_array
 
-def degree_infect(degree_dict, nodes):
-    return_nodes = np.zeros_like(nodes)  # Start with all zeros
+def degree_infect(degree_dict, nodes, make_floats = False):
+
+    if not make_floats:
+        return_nodes = np.zeros_like(nodes)  # Start with all zeros
+    else:
+        return_nodes = np.zeros(nodes.shape, dtype=np.float32)
     
     if not degree_dict:  # Handle empty dict
         return return_nodes

nettracer3d/proximity.py

@@ -144,7 +144,7 @@ def find_shared_value_pairs(input_dict):
 
 #Related to kdtree centroid searching:
 
-def populate_array(centroids, clip=False):
+def populate_array(centroids, clip=False, shape = None):
     """
     Create a 3D array from centroid coordinates.
     
@@ -164,12 +164,16 @@ def populate_array(centroids, clip=False):
     coords = np.array(list(centroids.values()))
     # Round coordinates to nearest integer
     coords = np.round(coords).astype(int)
-    min_coords = coords.min(axis=0)
-    max_coords = coords.max(axis=0)
+    if shape is None:
+        min_coords = coords.min(axis=0)
+        max_coords = coords.max(axis=0)
+    else:
+        min_coords = [0, 0, 0]
+        max_coords = shape
     
     # Check for negative coordinates only if not clipping
-    if not clip and np.any(min_coords < 0):
-        raise ValueError("Negative coordinates found in centroids")
+    #if not clip and np.any(min_coords < 0):
+        #raise ValueError("Negative coordinates found in centroids")
     
     # Apply clipping if requested
     clipped_centroids = {}
@@ -183,10 +187,15 @@ def populate_array(centroids, clip=False):
         for i, obj_id in enumerate(centroids.keys()):
             clipped_centroids[obj_id] = coords[i].tolist()
     
-    # Create array
-    array = np.zeros((max_coords[0] + 1, 
-                     max_coords[1] + 1, 
-                     max_coords[2] + 1), dtype=int)
+    if shape is None:
+        # Create array
+        array = np.zeros((max_coords[0] + 1, 
+                         max_coords[1] + 1, 
+                         max_coords[2] + 1), dtype=int)
+    else:
+        array = np.zeros((max_coords[0], 
+                         max_coords[1], 
+                         max_coords[2]), dtype=int)
     
     # Populate array with (possibly clipped) rounded coordinates
     for i, (obj_id, coord) in enumerate(centroids.items()):
@@ -194,7 +203,10 @@ def populate_array(centroids, clip=False):
             z, y, x = coords[i]  # Use pre-computed clipped coordinates
         else:
             z, y, x = np.round([coord[0], coord[1], coord[2]]).astype(int)
-        array[z, y, x] = obj_id
+        try:
+            array[z, y, x] = obj_id
+        except:
+            pass
         
     if clip:
         return array, clipped_centroids
@@ -328,7 +340,7 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
     
     if targets is None:
         # Original behavior: find neighbors for all points
-        query_points = points
+        query_points = np.array(points)
         query_indices = list(range(len(points)))
     else:
         # Convert targets to set for O(1) lookup
@@ -354,7 +366,6 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
         # 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:
@@ -373,6 +384,7 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
     
     # Skip parallelization for small datasets or when n_jobs=1
     if n_jobs == 1 or len(neighbor_indices) < 100:
+    #if True:
         # Sequential processing (original logic with max_neighbors support)
         output = []
         for i, neighbors in enumerate(neighbor_indices):
@@ -599,10 +611,10 @@ def convert_centroids_to_array(centroids_list, xy_scale = 1, z_scale = 1):
     points_array[:, 1:] = points_array[:, 1:] * xy_scale #account for scaling
 
     points_array[:, 0] = points_array[:, 0] * z_scale #account for scaling
-        
+
     return points_array
 
-def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_proportion=0.5):
+def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_proportion=0.5, max_r = None):
     """
     Generate an array of r values based on point distribution and step size.
     
@@ -634,18 +646,27 @@ def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_propo
         min_coords = np.array([0,0,0])
         dimensions = max_coords - min_coords
 
-    max_dimension = np.max(dimensions)
+    if 1 in dimensions:
+        dimensions = np.delete(dimensions, 0) #Presuming 2D data 
+
+    min_dimension = np.min(dimensions) #Biased for smaller dimension now for safety
     
     # Calculate maximum r value (typically half the shortest side for 2D,
     # or scaled by max_proportion for general use)
-    max_r = max_dimension * max_proportion
+    if max_r is None:
+        max_r = min_dimension * max_proportion
+        if max_proportion < 1:
+            print(f"Omitting search radii beyond {max_r}")
+    else:
+        print(f"Omitting search radii beyond {max_r} (to keep analysis within the mask)")
+
     
     # Generate r values from 0 to max_r with step_size increments
     num_steps = int(max_r / step_size)
     r_values = np.linspace(step_size, max_r, num_steps)
 
     if r_values[0] == 0:
-        np.delete(r_values, 0)
+        r_values = np.delete(r_values, 0)
     
     return r_values
 
@@ -662,7 +683,7 @@ def convert_augmented_array_to_points(augmented_array):
     # Extract just the coordinate columns (all except first column)
     return augmented_array[:, 1:]
 
-def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None, edge_correction=True, dim = 2, is_subset = False):
+def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None, dim = 2, is_subset = False, volume = None, n_subset = None):
     """
     Optimized computation of Ripley's K function using KD-Tree with simplified but effective edge correction.
     
@@ -677,7 +698,8 @@ def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None,
     K_values: numpy array of K values corresponding to r_values
     """
     n_ref = len(reference_points)
-    n_subset = len(subset_points)
+    if n_subset is None:
+        n_subset = len(subset_points)
 
     # Determine bounds if not provided
     if bounds is None:
@@ -688,10 +710,12 @@ def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None,
     # Calculate volume of study area
     min_bounds, max_bounds = bounds
     sides = max_bounds - min_bounds
-    if dim == 2:
-        volume = sides[0] * sides[1]
-    else:
-        volume = np.prod(sides)
+
+    if volume is None:
+        if dim == 2:
+            volume = sides[0] * sides[1]
+        else:
+            volume = np.prod(sides)
     
     # Point intensity (points per unit volume)
     intensity = n_ref / volume
@@ -705,94 +729,19 @@ def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None,
     # For each r value, compute cumulative counts
     for i, r in enumerate(r_values):
         total_count = 0
-        
+
         # Query the tree for all points within radius r of each subset point
         for j, point in enumerate(subset_points):
             # Find all reference points within radius r
             indices = tree.query_ball_point(point, r)
             count = len(indices)
-            
-            # Apply edge correction if needed
-            if edge_correction:
-                # Calculate edge correction weight
-                weight = 1.0
-                
-                if dim == 2:
-                    # For 2D - check all four boundaries
-                    x, y = point
-                    
-                    # Distances to all boundaries
-                    x_min_dist = x - min_bounds[0]
-                    x_max_dist = max_bounds[0] - x
-                    y_min_dist = y - min_bounds[1]
-                    y_max_dist = max_bounds[1] - y
-                    
-                    proportion_in = 1.0
-                    # Apply correction for each boundary if needed
-                    if x_min_dist < r:
-                        proportion_in -= 0.5 * (1 - x_min_dist/r)
-                    if x_max_dist < r:
-                        proportion_in -= 0.5 * (1 - x_max_dist/r)
-                    if y_min_dist < r:
-                        proportion_in -= 0.5 * (1 - y_min_dist/r)
-                    if y_max_dist < r:
-                        proportion_in -= 0.5 * (1 - y_max_dist/r)
-                    
-                    # Corner correction
-                    if ((x_min_dist < r and y_min_dist < r) or 
-                        (x_min_dist < r and y_max_dist < r) or
-                        (x_max_dist < r and y_min_dist < r) or
-                        (x_max_dist < r and y_max_dist < r)):
-                        proportion_in += 0.1  # Add a small boost for corners
-                    
-                elif dim == 3:
-                    # For 3D - check all six boundaries
-                    x, y, z = point
-                    
-                    # Distances to all boundaries
-                    x_min_dist = x - min_bounds[0]
-                    x_max_dist = max_bounds[0] - x
-                    y_min_dist = y - min_bounds[1]
-                    y_max_dist = max_bounds[1] - y
-                    z_min_dist = z - min_bounds[2]
-                    z_max_dist = max_bounds[2] - z
-                    
-                    proportion_in = 1.0
-                    # Apply correction for each boundary if needed
-                    if x_min_dist < r:
-                        proportion_in -= 0.25 * (1 - x_min_dist/r)
-                    if x_max_dist < r:
-                        proportion_in -= 0.25 * (1 - x_max_dist/r)
-                    if y_min_dist < r:
-                        proportion_in -= 0.25 * (1 - y_min_dist/r)
-                    if y_max_dist < r:
-                        proportion_in -= 0.25 * (1 - y_max_dist/r)
-                    if z_min_dist < r:
-                        proportion_in -= 0.25 * (1 - z_min_dist/r)
-                    if z_max_dist < r:
-                        proportion_in -= 0.25 * (1 - z_max_dist/r)
                     
-                    # Corner correction for 3D (if point is near a corner)
-                    num_close_edges = (
-                        (x_min_dist < r) + (x_max_dist < r) +
-                        (y_min_dist < r) + (y_max_dist < r) +
-                        (z_min_dist < r) + (z_max_dist < r)
-                    )
-                    if num_close_edges >= 2:
-                        proportion_in += 0.05 * num_close_edges  # Stronger boost for more edges
-                
-                # Ensure proportion_in stays within reasonable bounds
-                proportion_in = max(0.1, min(1.0, proportion_in))
-                weight = 1.0 / proportion_in
-                
-                count *= weight
-            
             total_count += count
-        
+
         # Subtract self-counts if points appear in both sets
         if is_subset or np.array_equal(reference_points, subset_points):
             total_count -= n_ref  # Subtract all self-counts
-        
+
         # Normalize
         K_values[i] = total_count / (n_subset * intensity)
     

nettracer3d/smart_dilate.py

@@ -223,6 +223,7 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = Fa
             inv, indices = compute_distance_transform_GPU(inv, return_dists = True, sampling = [z_scaling, xy_scaling, xy_scaling])
         except:
             print("Failed, attempting on CPU...")
+            cleanup()
             #Who would have seen this coming?:
             inv, indices = compute_distance_transform(inv, return_dists = True, sampling = [z_scaling, xy_scaling, xy_scaling])
     else:
@@ -251,15 +252,37 @@ def process_chunk(start_idx, end_idx, nodes, ring_mask, nearest_label_indices):
     nodes_chunk = nodes[:, start_idx:end_idx, :]
     ring_mask_chunk = ring_mask[:, start_idx:end_idx, :]
     dilated_nodes_with_labels_chunk = np.copy(nodes_chunk)
+    
+    # Get all ring indices at once
     ring_indices = np.argwhere(ring_mask_chunk)
-
-    for index in ring_indices:
-        z, y, x = index
-        nearest_z, nearest_y, nearest_x = nearest_label_indices[:, z, y + start_idx, x]
-        try: #There was an index error here once on the highest val of the second axis. I could not understand why because it usually doesnt hence the try block.
-            dilated_nodes_with_labels_chunk[z, y, x] = nodes[nearest_z, nearest_y, nearest_x]
-        except:
-            pass
+    
+    if len(ring_indices) > 0:
+        # Extract coordinates
+        z_coords = ring_indices[:, 0]
+        y_coords = ring_indices[:, 1] 
+        x_coords = ring_indices[:, 2]
+        
+        # Get nearest label coordinates (adjust y for chunk offset)
+        nearest_coords = nearest_label_indices[:, z_coords, y_coords + start_idx, x_coords]
+        nearest_z = nearest_coords[0, :]
+        nearest_y = nearest_coords[1, :]
+        nearest_x = nearest_coords[2, :]
+        
+        # Vectorized assignment
+        try:
+            dilated_nodes_with_labels_chunk[z_coords, y_coords, x_coords] = \
+                nodes[nearest_z, nearest_y, nearest_x]
+        except IndexError:
+            # Fallback for any problematic indices
+            valid_mask = (nearest_z < nodes.shape[0]) & \
+                        (nearest_y < nodes.shape[1]) & \
+                        (nearest_x < nodes.shape[2]) & \
+                        (nearest_z >= 0) & (nearest_y >= 0) & (nearest_x >= 0)
+            
+            valid_indices = valid_mask.nonzero()[0]
+            if len(valid_indices) > 0:
+                dilated_nodes_with_labels_chunk[z_coords[valid_indices], y_coords[valid_indices], x_coords[valid_indices]] = \
+                    nodes[nearest_z[valid_indices], nearest_y[valid_indices], nearest_x[valid_indices]]
     
     return dilated_nodes_with_labels_chunk
 
@@ -506,6 +529,7 @@ def compute_distance_transform_GPU(nodes, return_dists = False, sampling = [1, 1
 
 
 def compute_distance_transform(nodes, return_dists = False, sampling = [1, 1, 1]):
+    print("(Now doing distance transform...)")
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
@@ -548,13 +572,15 @@ def compute_distance_transform_distance_GPU(nodes, sampling = [1, 1, 1]):
     distance = cp.asnumpy(distance)
 
     if is_pseudo_3d:
-        np.expand_dims(distance, axis = 0)
+        distance = np.expand_dims(distance, axis = 0)
     
     return distance    
 
 
 def compute_distance_transform_distance(nodes, sampling = [1, 1, 1]):
 
+    print("(Now doing distance transform...)")
+
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
@@ -563,7 +589,7 @@ def compute_distance_transform_distance(nodes, sampling = [1, 1, 1]):
     # Fallback to CPU if there's an issue with GPU computation
     distance = distance_transform_edt(nodes, sampling = sampling)
     if is_pseudo_3d:
-        np.expand_dims(distance, axis = 0)
+        distance = np.expand_dims(distance, axis = 0)
     return distance
 
 
@@ -621,6 +647,14 @@ def catch_memory(e):
         downsample_needed = (memory_required/total_memory)
         return (downsample_needed)
 
+def cleanup():
+
+    try:
+        cp.get_default_memory_pool().free_all_blocks()
+    except:
+        pass
+
+
 
 if __name__ == "__main__":
     nodes = input("Labelled Nodes tiff?: ")

{nettracer3d-0.8.3.dist-info → nettracer3d-0.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.3
+Version: 0.8.4
 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/
@@ -107,6 +107,6 @@ 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.8.3 Updates -- 
+-- Version 0.8.4 Updates -- 
 
-	* Added better color legend display
+	* See Documentation Once Updated

nettracer3d-0.8.4.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=3lcWy64znl6xhl7axhWwdOk3N0dmpSep0259kLXMp9s,28135
+nettracer3d/excelotron.py,sha256=X9v_mte8gJBPNGdj6NJNUYja0Z6eorVoKAFx4nHiMnU,72058
+nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,21788
+nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
+nettracer3d/neighborhoods.py,sha256=ac_gjN7pUlXZZpMSZnUVErKbKtSlInxX2dHe22oDNJA,34532
+nettracer3d/nettracer.py,sha256=zHIUHLfWY3XAQBhcaZmKUqJ6UPCxk0A09cQBAnOK5TE,253362
+nettracer3d/nettracer_gui.py,sha256=QsHMiTW62Hl0jHOnAjSH_l8TAV7-xQBH7cdFfW8HTM0,547961
+nettracer3d/network_analysis.py,sha256=kBzsVaq4dZkMe0k-VGvQIUvM-tK0ZZ8bvb-wtsugZRQ,46150
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=kZcR1PekLg0riioNeGcALIXQyZ5PtHA_9MT6z7Zovdk,10401
+nettracer3d/proximity.py,sha256=kSc4PwBJswPup72ZFJgS03fgQLUbRSv-MQmGuAPg_0k,35325
+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=nlU5drRgD5xglb3_3tFiCtVEjyqfGgZF56RkVWylRR0,27143
+nettracer3d-0.8.4.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.8.4.dist-info/METADATA,sha256=3Q1UzbGTRyjogKPQmxPdqEiehxj1aZD9dMVV1uwVNXY,6747
+nettracer3d-0.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.8.4.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.8.4.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.8.4.dist-info/RECORD,,

nettracer3d-0.8.3.dist-info/RECORD

@@ -1,24 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/cellpose_manager.py,sha256=qZpTxSkmPb38Pru8TmjJ88xxcD_wM02EfJB5Mw9Xx4Y,6021
-nettracer3d/community_extractor.py,sha256=08WWUO94ToZFglBU9X1L-T-WJuaIa-8t35-52kN4i6g,28167
-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.3.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.8.3.dist-info/METADATA,sha256=yVQGa_obriAzfkWCzXCS0EYtxBRD8UmHL8OWmFIxFJ8,6750
-nettracer3d-0.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-0.8.3.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.8.3.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.8.3.dist-info/RECORD,,