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

nettracer3d/community_extractor.py

@@ -2,6 +2,8 @@ import pandas as pd
 import networkx as nx
 import tifffile
 import numpy as np
+from typing import List, Dict, Tuple
+from collections import defaultdict, Counter
 from networkx.algorithms import community
 from scipy import ndimage
 from scipy.ndimage import zoom
@@ -601,8 +603,159 @@ def extract_mothers(nodes, excel_file_path, centroid_dic = None, directory = Non
 
 
 
+def find_hub_nodes(G: nx.Graph, proportion: float = 0.1) -> List:
+    """
+    Identifies hub nodes in a network based on average shortest path length,
+    handling multiple connected components.
+    
+    Args:
+        G (nx.Graph): NetworkX graph (can have multiple components)
+        proportion (float): Proportion of top nodes to return (0.0 to 1.0)
+        
+    Returns:
+        List of nodes identified as hubs across all components
+    """
+    if not 0 < proportion <= 1:
+        raise ValueError("Proportion must be between 0 and 1")
+    
+    # Get connected components
+    components = list(nx.connected_components(G))
+    
+    # Dictionary to store average path lengths for all nodes
+    avg_path_lengths: Dict[int, float] = {}
+    
+    # Process each component separately
+    for component in components:
+        # Create subgraph for this component
+        subgraph = G.subgraph(component)
+        
+        # Calculate average shortest path length for each node in this component
+        for node in subgraph.nodes():
+            # Get shortest paths from this node to all others in the component
+            path_lengths = nx.single_source_shortest_path_length(subgraph, node)
+            # Calculate average path length within this component
+            avg_length = sum(path_lengths.values()) / (len(subgraph.nodes()) - 1)
+            avg_path_lengths[node] = avg_length
+    
+    # Sort nodes by average path length (ascending)
+    sorted_nodes = sorted(avg_path_lengths.items(), key=lambda x: x[1])
+    
+    # Calculate number of nodes to return
+    num_nodes = int(np.ceil(len(G.nodes()) * proportion))
+    
+    # Return the top nodes (those with lowest average path lengths)
+    hub_nodes = [node for node, _ in sorted_nodes[:num_nodes]]
+    
+    return hub_nodes
+
+
 
+def generate_distinct_colors(n_colors: int) -> List[Tuple[int, int, int]]:
+    """
+    Generate visually distinct RGB colors using HSV color space.
+    Colors are generated with maximum saturation and value, varying only in hue.
+    
+    Args:
+        n_colors: Number of distinct colors needed
+    
+    Returns:
+        List of RGB tuples
+    """
+    colors = []
+    for i in range(n_colors):
+        hue = i / n_colors
+        # Convert HSV to RGB (assuming S=V=1)
+        h = hue * 6
+        c = int(255)
+        x = int(255 * (1 - abs(h % 2 - 1)))
+        
+        if h < 1:
+            rgb = (c, x, 0)
+        elif h < 2:
+            rgb = (x, c, 0)
+        elif h < 3:
+            rgb = (0, c, x)
+        elif h < 4:
+            rgb = (0, x, c)
+        elif h < 5:
+            rgb = (x, 0, c)
+        else:
+            rgb = (c, 0, x)
+            
+        colors.append(rgb)
+    return colors
 
+def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.ndarray) -> np.ndarray:
+    """
+    Assign distinct colors to communities and create an RGB image.
+    
+    Args:
+        community_dict: Dictionary mapping node IDs to community numbers
+        labeled_array: 3D numpy array with labels corresponding to node IDs
+    
+    Returns:
+        RGB-coded numpy array (H, W, D, 3)
+    """
+    # Get unique communities and their sizes
+    communities = set(community_dict.values())
+    community_sizes = Counter(community_dict.values())
+    
+    # Sort communities by size (descending)
+    sorted_communities = sorted(communities, key=lambda x: community_sizes[x], reverse=True)
+    
+    # Generate distinct colors
+    colors = generate_distinct_colors(len(communities))
+    
+    # Create mapping from community to color
+    community_to_color = {comm: colors[i] for i, comm in enumerate(sorted_communities)}
+    
+    # Create mapping from node ID to color
+    node_to_color = {node: community_to_color[comm] for node, comm in community_dict.items()}
+    
+    # Create RGB array
+    rgb_array = np.zeros((*labeled_array.shape, 3), dtype=np.uint8)
+    
+    # Assign colors to each voxel based on its label
+    for label in np.unique(labeled_array):
+        if label in node_to_color:  # Skip background (usually label 0)
+            mask = labeled_array == label
+            for i in range(3):  # RGB channels
+                rgb_array[mask, i] = node_to_color[label][i]
+    
+    return rgb_array
+
+def assign_community_grays(community_dict: Dict[int, int], labeled_array: np.ndarray) -> np.ndarray:
+    """
+    Assign distinct grayscale values to communities.
+    
+    Args:
+        community_dict: Dictionary mapping node IDs to community numbers
+        labeled_array: 3D numpy array with labels corresponding to node IDs
+    
+    Returns:
+        grayscale numpy array
+    """
+    # Get unique communities
+    communities = set(community_dict.values())
+    n_communities = len(communities)
+    
+    # Generate evenly spaced grayscale values (excluding pure black for background)
+    gray_values = np.linspace(1, 255, n_communities, dtype=np.uint8)
+    
+    # Create direct mapping from node ID to grayscale value
+    node_to_gray = {node: gray_values[list(communities).index(comm)] 
+                   for node, comm in community_dict.items()}
+    
+    # Create output array
+    gray_array = np.zeros_like(labeled_array, dtype=np.uint8)
+    
+    # Use numpy's vectorized operations for faster assignment
+    unique_labels = np.unique(labeled_array)
+    for label in unique_labels:
+        if label in node_to_gray:
+            gray_array[labeled_array == label] = node_to_gray[label]
+    
+    return gray_array
 
 
 if __name__ == "__main__":

nettracer3d/hub_getter.py

@@ -115,7 +115,7 @@ def labels_to_boolean(label_array, labels_list):
     
     return boolean_array
 
-def get_hubs(nodepath, network, proportion = None, directory = None, centroids = None):
+def get_hubs(nodepath, network, proportion = None, directory = None, centroids = None, gen_more_images = False):
 
     if type(nodepath) == str:
         nodepath = tifffile.imread(nodepath)

nettracer3d/modularity.py

@@ -7,6 +7,8 @@ import matplotlib.colors as mcolors
 import os
 from . import network_analysis
 from . import simple_network
+import numpy as np
+import itertools
 
 def open_network(excel_file_path):
 
@@ -159,16 +161,7 @@ def louvain_mod(G, edge_weights=None, identifier=None, geometric = False, geo_in
     for i, component in enumerate(connected_components):
         # Apply the Louvain community detection on the subgraph
         partition = community_louvain.best_partition(G.subgraph(component))
-
-        # Invert the partition dictionary to get communities
-        #communities = {}
-        #for node, comm_id in partition.items():
-            #communities.setdefault(comm_id, []).append(node)
-        #communities = list(communities.values())
-        
-        # Assign a different color to each community within the component for visualization
-        #colors = [mcolors.to_hex(plt.cm.tab10(i / len(connected_components))[:3]) for _ in range(len(communities))]
-        
+    
         # Calculate modularity
         modularity = community_louvain.modularity(partition, G.subgraph(component))
         num_nodes = len(component)
@@ -180,7 +173,7 @@ def louvain_mod(G, edge_weights=None, identifier=None, geometric = False, geo_in
 
 def show_communities_flex(G, master_list, normalized_weights, geo_info = None, geometric=False, directory=None, weighted=True, partition=None, style=0):
     if partition is None:
-        partition, normalized_weights = community_partition(master_list, weighted=weighted, style=style)
+        partition, normalized_weights, _ = community_partition(master_list, weighted=weighted, style=style)
         print(partition)
     if normalized_weights is None:
         G, edge_weights = network_analysis.weighted_network(master_list)
@@ -289,7 +282,242 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
 
 
 
-def community_partition(master_list, weighted = False, style = 0):
+def community_partition(master_list, weighted = False, style = 0, dostats = True):
+
+    def calculate_network_stats(G, communities):
+        """
+        Calculate comprehensive network statistics for the graph and its communities.
+        
+        Parameters:
+        -----------
+        G : networkx.Graph
+            The input graph
+        communities : list
+            List of sets/lists containing node ids for each community
+        
+        Returns:
+        --------
+        dict
+            Dictionary containing various network statistics
+        """
+        stats = {}
+
+        try:
+        
+            # Overall network modularity
+            stats['Modularity Entire Network'] = community.modularity(G, communities)
+        except:
+            pass
+
+        try:        
+            # Component-level modularity
+            connected_components = list(nx.connected_components(G))
+            if len(connected_components) > 1:
+                for i, component in enumerate(connected_components):
+                    subgraph = G.subgraph(component)
+                    component_communities = list(community.label_propagation_communities(subgraph))
+                    modularity = community.modularity(subgraph, component_communities)
+                    num_nodes = len(component)
+                    stats[f'Modularity of component with {num_nodes} nodes'] = modularity
+        except:
+            pass
+
+        try:        
+            # Community size statistics
+            stats['Number of Communities'] = len(communities)
+            community_sizes = [len(com) for com in communities]
+            stats['Community Sizes'] = community_sizes
+            stats['Average Community Size'] = np.mean(community_sizes)
+        except:
+            pass
+
+        try:
+        
+            # Per-community statistics
+            for i, com in enumerate(communities):
+                subgraph = G.subgraph(com)
+                
+                # Basic community metrics
+                stats[f'Community {i+1} Density'] = nx.density(subgraph)
+                stats[f'Community {i+1} Conductance'] = nx.conductance(G, com)
+                stats[f'Community {i+1} Avg Clustering'] = nx.average_clustering(subgraph)
+                
+                # Degree centrality
+                degree_cent = nx.degree_centrality(subgraph)
+                stats[f'Community {i+1} Avg Degree Centrality'] = np.mean(list(degree_cent.values()))
+                
+                # Average path length (only for connected subgraphs)
+                if nx.is_connected(subgraph):
+                    stats[f'Community {i+1} Avg Path Length'] = nx.average_shortest_path_length(subgraph)
+        except:
+            pass
+
+        try:        
+            # Global network metrics
+            stats['Global Clustering Coefficient'] = nx.average_clustering(G)
+        except:
+            pass
+        try:
+            stats['Assortativity'] = nx.degree_assortativity_coefficient(G)
+        except:
+            pass
+
+        def count_inter_community_edges(G, communities):
+            inter_edges = 0
+            for com1, com2 in itertools.combinations(communities, 2):
+                inter_edges += len(list(nx.edge_boundary(G, com1, com2)))
+            return inter_edges
+
+        try:
+            stats['Inter-community Edges'] = count_inter_community_edges(G, communities)
+        except:
+            pass
+
+        # Calculate mixing parameter (ratio of external to total edges for nodes)
+        def mixing_parameter(G, communities):
+            external_edges = 0
+            total_edges = 0
+            for com in communities:
+                subgraph = G.subgraph(com)
+                internal_edges = subgraph.number_of_edges()
+                total_com_edges = sum(G.degree(node) for node in com)
+                external_edges += total_com_edges - (2 * internal_edges)
+                total_edges += total_com_edges
+            return external_edges / total_edges
+
+        try:
+            stats['Mixing Parameter'] = mixing_parameter(G, communities)
+        except:
+            pass
+        
+        return stats
+
+    def calculate_louvain_network_stats(G, partition):
+        """
+        Calculate comprehensive network statistics for the graph using Louvain community detection.
+        
+        Parameters:
+        -----------
+        G : networkx.Graph
+            The input graph
+        partition : dict
+            Dictionary mapping node -> community id from Louvain detection
+        
+        Returns:
+        --------
+        dict
+            Dictionary containing various network statistics
+        """
+        stats = {}
+        
+        # Convert partition dict to communities list format
+        communities = []
+        max_community = max(partition.values())
+        for com_id in range(max_community + 1):
+            community_nodes = {node for node, com in partition.items() if com == com_id}
+            if community_nodes:  # Only add non-empty communities
+                communities.append(community_nodes)
+        
+        try:
+            # Overall network modularity using Louvain
+            stats['Modularity Entire Network'] = community_louvain.modularity(partition, G)
+        except:
+            pass
+
+        try:        
+            # Component-level modularity
+            connected_components = list(nx.connected_components(G))
+            if len(connected_components) > 1:
+                for i, component in enumerate(connected_components):
+                    subgraph = G.subgraph(component)
+                    subgraph_partition = community_louvain.best_partition(subgraph)
+                    modularity = community_louvain.modularity(subgraph_partition, subgraph)
+                    num_nodes = len(component)
+                    stats[f'Modularity of component with {num_nodes} nodes'] = modularity
+        except:
+            pass
+
+        try:            
+            # Community size statistics
+            stats['Number of Communities'] = len(communities)
+            community_sizes = [len(com) for com in communities]
+            stats['Community Sizes'] = community_sizes
+            stats['Average Community Size'] = np.mean(community_sizes)
+        except:
+            pass
+
+        try:        
+            # Per-community statistics
+            for i, com in enumerate(communities):
+                subgraph = G.subgraph(com)
+                
+                # Basic community metrics
+                stats[f'Community {i+1} Density'] = nx.density(subgraph)
+                stats[f'Community {i+1} Conductance'] = nx.conductance(G, com)
+                stats[f'Community {i+1} Avg Clustering'] = nx.average_clustering(subgraph)
+                
+                # Degree centrality
+                degree_cent = nx.degree_centrality(subgraph)
+                stats[f'Community {i+1} Avg Degree Centrality'] = np.mean(list(degree_cent.values()))
+                
+                # Average path length (only for connected subgraphs)
+                if nx.is_connected(subgraph):
+                    stats[f'Community {i+1} Avg Path Length'] = nx.average_shortest_path_length(subgraph)
+        except:
+            pass
+
+        try:        
+            # Add some Louvain-specific statistics
+            stats['Partition Resolution'] = 1.0  # Default resolution parameter
+        except:
+            pass
+        try:
+            stats['Number of Iterations'] = len(set(partition.values()))
+        except:
+            pass
+        
+        # Global network metrics
+        try:
+            stats['Global Clustering Coefficient'] = nx.average_clustering(G)
+        except:
+            pass
+        try:
+            stats['Assortativity'] = nx.degree_assortativity_coefficient(G)
+        except:
+            pass
+
+        def count_inter_community_edges(G, communities):
+            inter_edges = 0
+            for com1, com2 in itertools.combinations(communities, 2):
+                inter_edges += len(list(nx.edge_boundary(G, com1, com2)))
+            return inter_edges
+
+        try:
+            stats['Inter-community Edges'] = count_inter_community_edges(G, communities)
+        except:
+            pass
+
+        # Calculate mixing parameter (ratio of external to total edges for nodes)
+        def mixing_parameter(G, communities):
+            external_edges = 0
+            total_edges = 0
+            for com in communities:
+                subgraph = G.subgraph(com)
+                internal_edges = subgraph.number_of_edges()
+                total_com_edges = sum(G.degree(node) for node in com)
+                external_edges += total_com_edges - (2 * internal_edges)
+                total_edges += total_com_edges
+            return external_edges / total_edges
+
+        try:
+            stats['Mixing Parameter'] = mixing_parameter(G, communities)
+        except:
+            pass
+
+        
+        return stats
+
+    stats = {}
 
     if weighted:
         G, edge_weights = network_analysis.weighted_network(master_list)
@@ -316,7 +544,12 @@ def community_partition(master_list, weighted = False, style = 0):
         # Perform Louvain community detection
         partition = community_louvain.best_partition(G)
 
-        return partition, normalized_weights
+        if dostats:
+
+            stats = calculate_louvain_network_stats(G, partition)
+
+
+        return partition, normalized_weights, stats
 
     elif style == 1:
 
@@ -330,7 +563,11 @@ def community_partition(master_list, weighted = False, style = 0):
         # Perform Louvain community detection
         partition = community_louvain.best_partition(G)
 
-        return partition, None
+        if dostats:
+
+            stats = calculate_louvain_network_stats(G, partition)
+
+        return partition, None, stats
 
     elif style == 0 and weighted:
 
@@ -357,7 +594,13 @@ def community_partition(master_list, weighted = False, style = 0):
             for node in com:
                 output[node] = i + 1
 
-        return output, normalized_weights
+        if dostats:
+
+            stats = calculate_network_stats(G, communities)
+
+
+
+        return output, normalized_weights, stats
 
     elif style == 0:
 
@@ -370,9 +613,6 @@ def community_partition(master_list, weighted = False, style = 0):
         # Add edges from the DataFrame
         G.add_edges_from(edges)
 
-        # Detect communities using label propagation
-        communities = list(community.label_propagation_communities(G))
-        output = {}
 
         # Detect communities using label propagation
         communities = list(community.label_propagation_communities(G))
@@ -381,7 +621,11 @@ def community_partition(master_list, weighted = False, style = 0):
             for node in com:
                 output[node] = i + 1
 
-        return output, None
+        if dostats:
+
+            stats = calculate_network_stats(G, communities)
+
+        return output, None, stats
 
 
 

nettracer3d/morphology.py

@@ -5,6 +5,7 @@ from scipy.ndimage import zoom
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import tifffile
+from functools import partial
 import pandas as pd
 
 def get_reslice_indices(args):
@@ -70,7 +71,7 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cor
     
     # Create a boolean mask where elements with the specified label are True
     label_array = label_array == label
-    dil_array = nettracer.dilate_3D(label_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
+    dil_array = nettracer.dilate_3D_recursive(label_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
 
     if cores == 0: #For getting the volume of objects. Cores presumes you want the 'core' included in the interaction.
         edge_array = edge_array * dil_array  # Filter the edges by the label in question
@@ -189,25 +190,161 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
 
         return edge_quants
 
-def calculate_voxel_volumes(array, xy_scale = 1, z_scale = 1):
+
+def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     """
-    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array.
+    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array
+    using parallel processing.
     
     Args:
         array: 3D numpy array where different objects are marked with different integer labels
+        xy_scale: Scale factor for x and y dimensions
+        z_scale: Scale factor for z dimension
         
     Returns:
         Dictionary mapping object labels to their voxel volumes
     """
+
+    def process_volume_chunk(chunk_data, labels, xy_scale, z_scale):
+        """
+        Calculate volumes for a chunk of the array.
+        
+        Args:
+            chunk_data: 3D numpy array chunk
+            labels: Array of unique labels to process
+            xy_scale: Scale factor for x and y dimensions
+            z_scale: Scale factor for z dimension
+            
+        Returns:
+            Dictionary of label: volume pairs for this chunk
+        """
+        chunk_volumes = {}
+        for label in labels:
+            volume = np.count_nonzero(chunk_data == label) * (xy_scale**2) * z_scale
+            if volume > 0:  # Only include if object exists in this chunk
+                chunk_volumes[label] = volume
+        return chunk_volumes
+
     # Get unique labels (excluding 0 which typically represents background)
     labels = np.unique(array)
     if len(labels) == 2:
         array, _ = nettracer.label_objects(array)
         labels = np.unique(array)
-
     labels = labels[labels != 0]  # Remove background label if present
     
-    # Create dictionary of label: volume pairs
-    volumes = {label: (np.count_nonzero(array == label) * (xy_scale**2) * z_scale) for label in labels}
+    if len(labels) == 0:
+        return {}
+        
+    # Get number of CPU cores
+    num_cores = mp.cpu_count()
+    
+    # Calculate chunk size along y-axis
+    chunk_size = array.shape[1] // num_cores
+    if chunk_size < 1:
+        chunk_size = 1
+    
+    # Create chunks along y-axis
+    chunks = []
+    for i in range(0, array.shape[1], chunk_size):
+        end = min(i + chunk_size, array.shape[1])
+        chunks.append(array[:, i:end, :])
+    
+    # Process chunks in parallel
+    process_func = partial(process_volume_chunk, 
+                         labels=labels, 
+                         xy_scale=xy_scale, 
+                         z_scale=z_scale)
+    
+    volumes = {}
+    with ThreadPoolExecutor(max_workers=num_cores) as executor:
+        chunk_results = list(executor.map(process_func, chunks))
+        
+        # Combine results from all chunks
+        for chunk_volumes in chunk_results:
+            for label, volume in chunk_volumes.items():
+                if label in volumes:
+                    volumes[label] += volume
+                else:
+                    volumes[label] = volume
+    
+    return volumes
+
+
+def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale):
+
+    
+    targets = np.isin(nodes, targets)
+    targets = nettracer.binarize(targets)
+    
+    dilate_xy, dilate_z = nettracer.dilation_length_to_pixels(xy_scale, z_scale, search, search)
+    print(f"Dilation parameters - xy: {dilate_xy}, z: {dilate_z}")
+    
+    targets = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
+    targets = targets != 0
+    print(f"After dilation - targets shape: {targets.shape}, sum: {np.sum(targets)}")
+    
+    targets = targets * nodes
+    print(f"After multiplication with nodes - unique values in targets: {np.unique(targets)}")
+    
+    unique, counts = np.unique(targets, return_counts=True)
+    count_dict = dict(zip(unique, counts))
+    print(f"Initial count_dict: {count_dict}")
+    
+    del count_dict[0]
+    print(f"count_dict after removing zeros: {count_dict}")
+    
+    unique, counts = np.unique(nodes, return_counts=True)
+    total_dict = dict(zip(unique, counts))
+    print(f"Initial total_dict: {total_dict}")
     
-    return volumes
+    del total_dict[0]
+    print(f"total_dict after removing zeros: {total_dict}")
+    
+    print(f"id_dict keys: {list(id_dict.keys())}")
+    print(f"Initial neighborhood_dict: {neighborhood_dict}")
+    print(f"Initial totals: {totals}")
+    
+    for label in total_dict:
+        if label in id_dict:
+            if label in count_dict:
+                neighborhood_dict[id_dict[label]] += count_dict[label]
+                print(f"Updated neighborhood_dict[{id_dict[label]}] with count {count_dict[label]}")
+            totals[id_dict[label]] += total_dict[label]
+            print(f"Updated totals[{id_dict[label]}] with total {total_dict[label]}")
+    
+    print(f"Final neighborhood_dict: {neighborhood_dict}")
+    print(f"Final totals: {totals}")
+    return neighborhood_dict, totals
+
+
+
+
+
+
+def get_search_space_dilate(target, centroids, id_dict, search, scaling = 1):
+
+    ymax = np.max(centroids[:, 0])
+    xmax = np.max(centroids[:, 1])
+
+
+    array = np.zeros((ymax + 1, xmax + 1))
+
+    for i, row in enumerate(centroids): 
+        if i + 1 in id_dict and target in id_dict[i+1]:
+            y = row[0]  # get y coordinate
+            x = row[1]  # get x coordinate
+            array[y, x] = 1  # set value at that coordinate
+
+
+    #array = downsample(array, 3)
+    array = dilate_2D(array, search, search)
+
+    search_space = np.count_nonzero(array) * scaling * scaling
+
+    tifffile.imwrite('search_regions.tif', array)
+
+    print(f"Search space is {search_space}")
+
+
+
+    return array