nettracer3d 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

nettracer3d/network_analysis.py

@@ -1,5 +1,6 @@
 import pandas as pd
 import networkx as nx
+import json
 import tifffile
 import numpy as np
 from networkx.algorithms import community
@@ -36,6 +37,52 @@ def compute_centroid(binary_stack, label):
         
     return centroid
 
+def create_bar_graph(data_dict, title, x_label, y_label, directory=None):
+    """
+    Create a bar graph from a dictionary where keys are bar names and values are heights.
+    
+    Parameters:
+    data_dict (dict): Dictionary with bar names as keys and heights as values
+    title (str): Title of the graph
+    x_label (str): Label for x-axis
+    y_label (str): Label for y-axis
+    directory (str, optional): Directory path to save the plot. If None, plot is not saved
+    """
+    import matplotlib.pyplot as plt
+    
+    # Create figure and axis
+    plt.figure(figsize=(10, 6))
+    
+    # Create bars
+    plt.bar(list(data_dict.keys()), list(data_dict.values()))
+    
+    # Add labels and title
+    plt.title(title)
+    plt.xlabel(x_label)
+    plt.ylabel(y_label)
+    
+    # Rotate x-axis labels if there are many bars
+    plt.xticks(rotation=45, ha='right')
+    
+    # Adjust layout to prevent label cutoff
+    plt.tight_layout()
+
+    try:
+    
+        # Save plot if directory is specified
+        if directory:
+            plt.savefig(f"{directory}/bar_graph.png")
+
+    except:
+        pass
+
+    try:
+        
+        # Display the plot
+        plt.show()
+    except:
+        pass
+
 def open_network(excel_file_path):
     """opens an unweighted network from the network excel file"""
 
@@ -59,6 +106,25 @@ def open_network(excel_file_path):
 
 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):
+        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
         if file_path.lower().endswith('.xlsx'):
@@ -69,8 +135,11 @@ def read_excel_to_lists(file_path, sheet_name=0):
             # Read the CSV file into a DataFrame without headers
             df = pd.read_csv(file_path, header=None)
             df = df.drop(0)
+        elif file_path.lower().endswith('.json'):
+            df = load_json_to_list(file_path)
+            return df
         else:
-            raise ValueError("File must be either .xlsx or .csv format")
+            raise ValueError("File must be either .xlsx, .csv, or .json format")
     else:
         df = file_path
 
@@ -88,7 +157,7 @@ def read_excel_to_lists(file_path, sheet_name=0):
         try:
             master_list[2].extend(data_lists[i+2])
         except IndexError:
-            pass
+            master_list[2].extend(0)
             
     return master_list
 
@@ -356,13 +425,28 @@ def read_centroids_to_dict(file_path):
     Returns:
     dict: Dictionary with first column as keys and next three columns as numpy array values
     """
+    def load_json_to_dict(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 k, v in data.items():
+            try:
+                converted_data[int(k)] = v
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
     # Check file extension
     if file_path.lower().endswith('.xlsx'):
         df = pd.read_excel(file_path)
     elif file_path.lower().endswith('.csv'):
         df = pd.read_csv(file_path)
+    elif file_path.lower().endswith('.json'):
+        df = load_json_to_dict(file_path)
     else:
-        raise ValueError("Unsupported file format. Please provide either .xlsx or .csv file")
+        raise ValueError("Unsupported file format. Please provide either .xlsx, .csv, or .json file")
     
     # Initialize an empty dictionary
     data_dict = {}
@@ -388,13 +472,30 @@ def read_excel_to_singval_dict(file_path):
     Returns:
     dict: Dictionary with first column as keys and second column as values
     """
+    def load_json_to_dict(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 k, v in data.items():
+            try:
+                converted_data[int(k)] = v
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
+
     # Check file extension and read accordingly
     if file_path.lower().endswith('.xlsx'):
         df = pd.read_excel(file_path)
     elif file_path.lower().endswith('.csv'):
         df = pd.read_csv(file_path)
+    elif file_path.lower().endswith('.json'):
+        df = load_json_to_dict(file_path)
+        return df
     else:
-        raise ValueError("Unsupported file format. Please provide either .xlsx or .csv file")
+        raise ValueError("Unsupported file format. Please provide either .xlsx, .csv, or .json file")
     
     # Convert the DataFrame to a dictionary
     data_dict = {}
@@ -836,7 +937,10 @@ def radial_analysis(nodes, network, rad_dist, xy_scale = None, z_scale = None, c
     dist_list = get_distance_list(centroids, network, xy_scale, z_scale)
     x_vals, y_vals = buckets(dist_list, num_objects, rad_dist, directory = directory)
     histogram(x_vals, y_vals, directory = directory)
-    return dist_list
+    output = {}
+    for i in range(len(x_vals)):
+        output[y_vals[i]] = x_vals[i]
+    return output
 
 def buckets(dists, num_objects, rad_dist, directory = None):
     y_vals = []
@@ -859,13 +963,17 @@ def buckets(dists, num_objects, rad_dist, directory = None):
     data = {'Radial Distance From Any Node': y_vals, 'Average Number of Neighboring Nodes': x_vals}
     df = pd.DataFrame(data)
 
-    if directory is None:
-        # Save the DataFrame to an Excel file
-        df.to_excel('radial_distribution.xlsx', index=False)
-        print("Radial distribution saved to radial_distribution.xlsx")
-    else:
-        df.to_excel(f'{directory}/radial_distribution.xlsx', index=False)
-        print(f"Radial distribution saved to {directory}/radial_distribution.xlsx")
+    try:
+
+        if directory is None:
+            # Save the DataFrame to an Excel file
+            df.to_excel('radial_distribution.xlsx', index=False)
+            print("Radial distribution saved to radial_distribution.xlsx")
+        else:
+            df.to_excel(f'{directory}/radial_distribution.xlsx', index=False)
+            print(f"Radial distribution saved to {directory}/radial_distribution.xlsx")
+    except:
+        pass
 
     return x_vals, y_vals
 
@@ -881,8 +989,14 @@ def histogram(counts, y_vals, directory = None):
     plt.xlabel('Distance from any node')
     plt.ylabel('Avg Number of Neigbhoring Vertices')
 
-    if directory is not None:
-        plt.savefig(f'{directory}/radial_plot.png')
+    try:
+
+        if directory is not None:
+            plt.savefig(f'{directory}/radial_plot.png')
+        else:
+            plt.savefig('radial_plot.png')
+    except:
+        pass
 
     # Show the plot
     plt.show()
@@ -1090,8 +1204,8 @@ def edge_to_node(network, node_identities = None):
     alledges = set(edgesC)
 
     for i in range(len(edgesC)):
-        newpair1 = [nodesA[i], edgesC[i], None]
-        newpair2 = [edgesC[i], nodesB[i], None]
+        newpair1 = [nodesA[i], edgesC[i], 0]
+        newpair2 = [edgesC[i], nodesB[i], 0]
         new_network.append(newpair1)
         new_network.append(newpair2)
 
@@ -1140,7 +1254,7 @@ def rand_net_weighted(num_rows, num_nodes, nodes):
                 while random_partner == nodes[i]:
                     random_partner = random.randint(0, len(nodes)-1)
                     random_partner = nodes[random_partner]
-            random_pair = [nodes[i], random_partner, None]
+            random_pair = [nodes[i], random_partner, 0]
             random_network.append(random_pair)
             k+= 1
             if k == num_rows:
@@ -1152,7 +1266,7 @@ def rand_net_weighted(num_rows, num_nodes, nodes):
 
     G, edge_weights = weighted_network(df)
 
-    return G
+    return G, df
 
 def rand_net(num_rows, num_nodes, nodes):
     random_network = []
@@ -1167,10 +1281,10 @@ def rand_net(num_rows, num_nodes, nodes):
                 
                 # Check if the random partner is different from the current node
                 # and if the pair is not already in the network
-                if random_partner != nodes[i] and [nodes[i], random_partner, None] not in random_network and [random_partner, nodes[i], None] not in random_network:
+                if random_partner != nodes[i] and [nodes[i], random_partner, 0] not in random_network and [random_partner, nodes[i], 0] not in random_network:
                     break
 
-            random_pair = [nodes[i], random_partner, None]
+            random_pair = [nodes[i], random_partner, 0]
             random_network.append(random_pair)
             k += 1
 
@@ -1187,7 +1301,7 @@ def rand_net(num_rows, num_nodes, nodes):
 
     G, edge_weights = weighted_network(df)
 
-    return G
+    return G, df
 
 def generate_random(G, net_lists, weighted = True):
 
@@ -1250,13 +1364,17 @@ def degree_distribution(G, directory = None):
         'Proportion of nodes with degree (p(k))': proportion_list
     })
 
-    if directory is None:
-        # Save the DataFrame to an Excel file
-        df.to_excel('degree_dist.xlsx', index=False)
-        print("Degree distribution saved to degree_dist.xlsx")
-    else:
-        df.to_excel(f'{directory}/degree_dist.xlsx', index=False)
-        print(f"Degree distribution saved to {directory}/degree_dist.xlsx")
+    try:
+
+        if directory is None:
+            # Save the DataFrame to an Excel file
+            df.to_excel('degree_dist.xlsx', index=False)
+            print("Degree distribution saved to degree_dist.xlsx")
+        else:
+            df.to_excel(f'{directory}/degree_dist.xlsx', index=False)
+            print(f"Degree distribution saved to {directory}/degree_dist.xlsx")
+    except:
+        pass
 
 
     power_trendline(degrees, proportion_list, directory = directory)
@@ -1310,8 +1428,15 @@ def power_trendline(x, y, directory = None):
         verticalalignment='top'
     )
 
-    if directory is not None:
-        plt.savefig(f'{directory}/degree_plot.png')
+    try:
+
+        if directory is not None:
+            plt.savefig(f'{directory}/degree_plot.png')
+        else:
+            plt.savefig('degree_plot.png')
+    except:
+        pass
+
 
     plt.show()
 

nettracer3d/node_draw.py

@@ -139,7 +139,9 @@ def degree_draw(degree_dict, centroid_dict, nodes):
     draw_array = np.zeros_like(nodes, dtype=np.uint8)
     #font_size = 24
 
-    for node, degree in degree_dict.items():
+    for node in centroid_dict:
+
+        degree = degree_dict[node]
         z, y, x = centroid_dict[node].astype(int)
 
         try:

nettracer3d/proximity.py

@@ -6,6 +6,7 @@ from scipy.spatial import KDTree
 import concurrent.futures
 import multiprocessing as mp
 import pandas as pd
+from typing import Dict, Union, Tuple, List, Optional
 
 
 # Related to morphological border searching:
@@ -74,7 +75,7 @@ def _get_node_node_dict(label_array, label, dilate_xy, dilate_z):
     
     # Create a boolean mask where elements with the specified label are True
     binary_array = label_array == label
-    binary_array = nettracer.dilate_3D(binary_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
+    binary_array = nettracer.dilate_3D_recursive(binary_array, dilate_xy, dilate_xy, 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
@@ -95,22 +96,26 @@ def process_label(args):
     return label, sub_nodes
 
 
-def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z):
+def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets = None):
     """Internal method used for the secondary algorithm to process nodes in parallel."""
     # Initialize the dictionary to be returned
     node_dict = {}
 
     array_shape = nodes.shape
 
+
     # Use ThreadPoolExecutor for parallel execution
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
         # First parallel section to process labels
         # List of arguments for each parallel task
         args_list = [(nodes, i, dilate_xy, dilate_z, array_shape) for i in range(1, num_nodes + 1)]
 
-        # Execute parallel tasks to process labels
+        if targets is not None:
+            args_list = [tup for tup in args_list if tup[1] in targets]
+
         results = executor.map(process_label, args_list)
 
+
         # Second parallel section to create dictionary entries
         for label, sub_nodes in results:
             executor.submit(create_dict_entry, node_dict, label, sub_nodes, dilate_xy, dilate_z)
@@ -182,15 +187,19 @@ 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
     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
         
         # Convert to numpy array for querying
         query_points = np.array(target_points)
+        query_indices = target_indices  # Add this line
         
         # Handle case where no target values were found
         if len(query_points) == 0:
@@ -203,14 +212,14 @@ def find_neighbors_kdtree(array, radius, targets=None):
     output = []
     
     # Generate pairs
-    for query_idx, neighbors in enumerate(neighbor_indices):
+    for i, neighbors in enumerate(neighbor_indices):
+        query_idx = query_indices[i]  # Modified this line
         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])]
                 output.append([query_value, neighbor_value, 0])
-
     
     return output
 
@@ -225,4 +234,55 @@ def extract_pairwise_connections(connections):
                 output.append([list_index_value, number, 0])
                 print(f'sublist: {sublist}, adding: {[list_index_value, number, 0]}')
 
-    return output
+    return output
+
+
+
+#voronois:
+def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, int, int], List[int]]], 
+                            shape: Optional[Tuple[int, int, int]] = None) -> np.ndarray:
+    """
+    Create a 3D Voronoi diagram using scipy's KDTree for faster computation.
+    
+    Args:
+        centroids: Dictionary with labels as keys and (z,y,x) coordinates as values
+        shape: Optional tuple of (Z,Y,X) dimensions. If None, calculated from centroids
+    
+    Returns:
+        3D numpy array where each cell contains the label of the closest centroid as uint32
+    """
+    from scipy.spatial import cKDTree
+    
+    # Convert string labels to integers if necessary
+    if any(isinstance(k, str) for k in centroids.keys()):
+        label_map = {label: idx for idx, label in enumerate(centroids.keys())}
+        centroids = {label_map[k]: v for k, v in centroids.items()}
+    
+    # Convert centroids to array and keep track of labels
+    labels = np.array(list(centroids.keys()), dtype=np.uint32)
+    centroid_points = np.array([centroids[label] for label in labels])
+    
+    # Calculate shape if not provided
+    if shape is None:
+        max_coords = centroid_points.max(axis=0)
+        shape = tuple(max_coord + 1 for max_coord in max_coords)
+    
+    # Create KD-tree
+    tree = cKDTree(centroid_points)
+    
+    # Create coordinate arrays
+    coords = np.array(np.meshgrid(
+        np.arange(shape[0]),
+        np.arange(shape[1]),
+        np.arange(shape[2]),
+        indexing='ij'
+    )).reshape(3, -1).T
+    
+    # Find nearest centroid for each point
+    _, indices = tree.query(coords)
+    
+    # Convert indices to labels and ensure uint32 dtype
+    label_array = labels[indices].astype(np.uint32)
+    
+    # Reshape to final shape
+    return label_array.reshape(shape)

nettracer3d/simple_network.py

@@ -237,21 +237,6 @@ def show_simple_network(excel_file_path, geometric = False, geo_info = None, dir
     # Add edges from the DataFrame
     G.add_edges_from(edges)
 
-    # Print basic information about the graph
-    num_nodes = G.number_of_nodes()
-    num_edge = G.number_of_edges()
-
-    print("Number of nodes:", num_nodes)
-    print("Number of edges:", num_edge)
-
-    # Calculate the average degree connectivity
-    average_degree_connectivity = nx.average_degree_connectivity(G)
-    print("Average degree connectivity:", average_degree_connectivity)
-
-    # Calculate the average number of edges attached to a node
-    average_edges_per_node = num_nodes/num_edge
-    print("Average edges per node:", average_edges_per_node)
-
     if geometric:
         for node in list(G.nodes()):
             if node not in geo_info[0]:
@@ -272,12 +257,10 @@ def show_simple_network(excel_file_path, geometric = False, geo_info = None, dir
     plt.show()
 
 
-def show_identity_network(excel_file_path, node_identities, geometric = False, geo_info = None, directory = None):
-
+def show_identity_network(excel_file_path, node_identities, geometric=False, geo_info=None, directory=None):
     if type(node_identities) == str:
         # Read the Excel file into a DataFrame
         df = pd.read_excel(node_identities)
-        
         # Convert the DataFrame to a dictionary
         identity_dict = pd.Series(df.iloc[:, 1].values, index=df.iloc[:, 0]).to_dict()
     else:
@@ -289,74 +272,101 @@ def show_identity_network(excel_file_path, node_identities, geometric = False, g
         master_list = excel_file_path
 
     edges = zip(master_list[0], master_list[1])
-
+    
     # Create a graph
     G = nx.Graph()
-
-    # Add edges from the lists
     G.add_edges_from(edges)
 
-    # Print basic information about the graph
-    num_nodes = G.number_of_nodes()
-    num_edge = G.number_of_edges()
-
-    print("Number of nodes:", num_nodes)
-    print("Number of edges:", num_edge)
-
-    # Calculate the average number of edges attached to a node
-    average_edges_per_node = num_edge / num_nodes
-    print("Average edges per node:", average_edges_per_node)
-
-    # Calculate the average degree connectivity
-    average_degree_connectivity = nx.average_degree_connectivity(G)
-    print("Average degree connectivity:", average_degree_connectivity)
-
-    # Create a color map based on the categories in identity_dict
+    # Create a more sophisticated color palette using a combination of colormap sequences
     unique_categories = list(set(identity_dict.values()))
-    color_map = {category: mcolors.to_hex(plt.cm.tab10(i / len(unique_categories))[:3]) for i, category in enumerate(unique_categories)}
-
-    node_dict = {}
-    edges_list = []
-    nodes_list = []
-
-    for node in list(G.nodes()):
-        if identity_dict[node] == 'Edge':
-            node_dict[node] = 30
-            edges_list.append(node)
-        else:
-            node_dict[node] = 100
-            nodes_list.append(node)
-
-    node_sizes_list = [node_dict[node] for node in G.nodes()]
-
-    # Visualize the graph with different node colors based on categories
+    num_categories = len(unique_categories)
+    
+    # Create a color palette that combines multiple colormaps for more distinct colors
+    if num_categories <= 10:
+        colors = plt.cm.tab10(np.linspace(0, 1, num_categories))
+    elif num_categories <= 20:
+        colors1 = plt.cm.tab20(np.linspace(0, 1, min(num_categories, 20)))
+        colors = colors1[:num_categories]
+    else:
+        # For large number of categories, combine multiple distinct colormaps
+        colors1 = plt.cm.tab20(np.linspace(0, 1, 20))
+        colors2 = plt.cm.Set3(np.linspace(0, 1, 12))
+        colors3 = plt.cm.Pastel1(np.linspace(0, 1, 9))
+        colors4 = plt.cm.Paired(np.linspace(0, 1, 12))
+        
+        # Combine and take needed number of colors
+        all_colors = np.vstack([colors1, colors2, colors3, colors4])
+        # Shuffle the colors to ensure adjacent categories have distinct colors
+        np.random.seed(42)  # For consistency
+        np.random.shuffle(all_colors)
+        colors = all_colors[:num_categories]
+
+    color_map = {category: mcolors.to_hex(color[:3]) 
+                 for category, color in zip(unique_categories, colors)}
+
+    # Node size handling
+    node_dict = {node: 30 if identity_dict[node] == 'Edge' else 100 
+                 for node in G.nodes()}
+    
     if geometric:
+        # Handle geometric positioning
         for node in list(G.nodes()):
             if node not in geo_info[0]:
                 G.remove_node(node)
-                print(f"Removing node {node} from network visualization (no centroid - likely due to downsampling when finding centroids)")
-
-        pos, z_pos  = geometric_positions(geo_info[0], geo_info[1])
+                print(f"Removing node {node} from network visualization "
+                      f"(no centroid - likely due to downsampling when finding centroids)")
+        
+        pos, z_pos = geometric_positions(geo_info[0], geo_info[1])
         node_sizes_list = [z_pos[node] for node in G.nodes()]
-        # Assign a color to each node based on its category
-        node_colors = [color_map[identity_dict[node]] for node in G.nodes]
-        nx.draw(G, pos, with_labels=True, font_color='black', font_weight='bold', node_size= node_sizes_list, node_color=node_colors, alpha=0.8, font_size = 12)
     else:
-        # Assign a color to each node based on its category
-        node_colors = [color_map[identity_dict[node]] for node in G.nodes]
         pos = nx.spring_layout(G)
-        nx.draw(G, pos, with_labels=True, font_color='black', font_weight='bold', node_size= 100, node_color=node_colors, alpha=0.8, font_size = 12)
-
-    # Create custom legend handles
-    legend_handles = [Patch(color=color, label=category) for category, color in color_map.items()]
-
-    # Add legend to the plot
-    plt.legend(handles=legend_handles, loc='upper right', title='Categories')
+        node_sizes_list = [node_dict[node] for node in G.nodes()]
 
+    # Create figure with custom size
+    plt.figure(figsize=(12, 8))
+    
+    # Create separate axes for the graph and legend
+    graph_ax = plt.gca()
+    
+    # Draw the network
+    node_colors = [color_map[identity_dict[node]] for node in G.nodes()]
+    nx.draw(G, pos, ax=graph_ax, with_labels=True, font_color='black', 
+            font_weight='bold', node_size=node_sizes_list, 
+            node_color=node_colors, alpha=0.8, font_size=12)
+
+    # Create custom legend with multiple columns if needed
+    legend_handles = [Patch(color=color, label=category) 
+                     for category, color in color_map.items()]
+    
+    # Adjust number of columns based on number of categories
+    if len(unique_categories) > 20:
+        ncol = 3
+        bbox_to_anchor = (1.2, 1)
+    elif len(unique_categories) > 10:
+        ncol = 2
+        bbox_to_anchor = (1.1, 1)
+    else:
+        ncol = 1
+        bbox_to_anchor = (1.05, 1)
+
+    # Add legend with adjusted parameters
+    legend = plt.legend(handles=legend_handles, 
+                       bbox_to_anchor=bbox_to_anchor,
+                       loc='upper left',
+                       title='Categories',
+                       ncol=ncol,
+                       fontsize='small',
+                       title_fontsize='medium')
+    
+    # Adjust layout to prevent legend overlap
+    plt.tight_layout()
+    
+    # Save if directory provided
     if directory is not None:
-        plt.savefig(f'{directory}/identity_network_plot.png')
-
-    # Display the graph
+        plt.savefig(f'{directory}/identity_network_plot.png',
+                    bbox_inches='tight',
+                    dpi=300)
+    
     plt.show()
 
 

{nettracer3d-0.2.6.dist-info → nettracer3d-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.6
+Version: 0.2.8
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link

nettracer3d-0.2.8.dist-info/RECORD

@@ -0,0 +1,18 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/community_extractor.py,sha256=o-W0obPAzCgvPB2SAJ3BhPgykevH6GyD8Y5lcd4t3Vw,29725
+nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,8298
+nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
+nettracer3d/morphology.py,sha256=wv7v06YUcn5lMyefcc_znQlXF5iDxvUdoc0fXOKlGTw,12982
+nettracer3d/nettracer.py,sha256=X33ehVPkfrQHgh4zUTqWlESsZnzs5kc45__llG3UCRc,204438
+nettracer3d/nettracer_gui.py,sha256=aO8gwEgI0pt9rEu1BGNHW9WpSu8xLJohoP7vZ_3Yjnc,281387
+nettracer3d/network_analysis.py,sha256=Nv47U3VcmiTK8b5oEa7rgnYLL4n1r2dF9XCDiQiza4A,45788
+nettracer3d/network_draw.py,sha256=JWWEX7zT6Y9fcO75TtBwkGpPKFIkvBy8pfyB3YB-H_E,12599
+nettracer3d/node_draw.py,sha256=AL8KfFNYBybOx4q6y2pGsAD4QdMebnS-FGRVTqDa0tA,8234
+nettracer3d/proximity.py,sha256=KYs4QUbt1U79RLzTvt8BmrxeGVaeKOQ2brtzTjjA78c,11011
+nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
+nettracer3d/smart_dilate.py,sha256=howfO6Lw5PxNjkaOBSCjkmf7fyau_-_8iTct2mAuTAQ,22083
+nettracer3d-0.2.8.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.2.8.dist-info/METADATA,sha256=spJkNDOCkTGqbv7GPGZc7pletM3c5hfXRpQ79u0GRXA,2258
+nettracer3d-0.2.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nettracer3d-0.2.8.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.2.8.dist-info/RECORD,,