nettracer3d 0.2.5__tar.gz → 0.2.7__tar.gz

{nettracer3d-0.2.5/src/nettracer3d.egg-info → nettracer3d-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.5
+Version: 0.2.7
 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.5 → nettracer3d-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.2.5"
+version = "0.2.7"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]

{nettracer3d-0.2.5 → nettracer3d-0.2.7}/src/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-0.2.5 → nettracer3d-0.2.7}/src/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-0.2.5 → nettracer3d-0.2.7}/src/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