nettracer3d 1.3.1__py3-none-any.whl → 1.3.6__py3-none-any.whl

nettracer3d/modularity.py

@@ -6,6 +6,7 @@ import matplotlib.colors as mcolors
 import os
 from . import network_analysis
 from . import simple_network
+from . import nettracer as n3d
 import numpy as np
 import itertools
 
@@ -230,9 +231,9 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info=None, geo
 
 
 
-def community_partition(master_list, weighted = False, style = 0, dostats = True, seed = None):
+def community_partition(G, weighted = False, style = 0, dostats = True, seed = None):
 
-    def calculate_network_stats(G, communities):
+    def calculate_network_stats(G, unweighted_G, communities):
         """
         Calculate comprehensive network statistics for the graph and its communities.
         
@@ -283,7 +284,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         
             # Per-community statistics
             for i, com in enumerate(communities):
-                subgraph = G.subgraph(com)
+                subgraph = unweighted_G.subgraph(com)
                 
                 # Basic community metrics
                 stats[f'Community {i+1} Density'] = nx.density(subgraph)
@@ -302,7 +303,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
 
         try:        
             # Global network metrics
-            stats['Global Clustering Coefficient'] = nx.average_clustering(G)
+            stats['Global Clustering Coefficient'] = nx.average_clustering(unweighted_G)
         except:
             pass
         try:
@@ -340,7 +341,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         
         return stats
 
-    def calculate_louvain_network_stats(G, partition, seed):
+    def calculate_louvain_network_stats(G, unweighted_G, partition, seed):
         """
         Calculate comprehensive network statistics for the graph using Louvain community detection.
         
@@ -371,7 +372,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
             if len(connected_components) > 1:
                 for i, component in enumerate(connected_components):
                     subgraph = G.subgraph(component)
-                    subgraph_partition = nx.community.louvain_communities(G, weight='weight', seed = seed)
+                    subgraph_partition = list(nx.community.louvain_communities(subgraph, seed = seed))
                     modularity = community.modularity(subgraph, subgraph_partition)
                     num_nodes = len(component)
                     stats[f'Modularity of component with {num_nodes} nodes'] = modularity
@@ -396,7 +397,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         
         # Global network metrics
         try:
-            stats['Global Clustering Coefficient'] = nx.average_clustering(G)
+            stats['Global Clustering Coefficient'] = nx.average_clustering(unweighted_G)
         except:
             pass
         try:
@@ -435,7 +436,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         try:        
             # Per-community statistics
             for i, com in enumerate(communities):
-                subgraph = G.subgraph(com)
+                subgraph = unweighted_G.subgraph(com)
                 
                 # Basic community metrics
                 stats[f'Community {i+1} Density'] = nx.density(subgraph)
@@ -451,52 +452,16 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
                 if nx.is_connected(subgraph):
                     stats[f'Community {i+1} Avg Path Length'] = nx.average_shortest_path_length(subgraph)
         except:
-            import traceback
             pass
         
         return stats
 
     stats = {}
-
+    unweighted_G = G
     if weighted:
-        G, edge_weights = network_analysis.weighted_network(master_list)
-        edge_weights = get_edge_weights(G)
-
-    if style == 1 and weighted:
-        G = nx.Graph()
-
-        # Find the maximum and minimum edge weights
-        max_weight = max(weight for edge, weight in edge_weights.items())
-        min_weight = min(weight for edge, weight in edge_weights.items())
-
-        if max_weight > 1:
-            # Normalize edge weights to the range [0.1, 1.0]
-            normalized_weights = {edge: 0.1 + 0.9 * ((weight - min_weight) / (max_weight - min_weight)) for edge, weight in edge_weights.items()}
-        else:
-            normalized_weights = {edge: 0.1 for edge, weight in edge_weights.items()}
-
-        # Add edges to the graph with normalized weights
-        for edge, normalized_weight in normalized_weights.items():
-            G.add_edge(edge[0], edge[1], weight=normalized_weight)
-
-        # Replace Louvain with NetworkX's implementation
-        communities = list(nx.community.louvain_communities(G, weight='weight', seed = seed))
-        
-        # Convert to the same format as community_louvain.best_partition
-        output = {}
-        for i, com in enumerate(communities):
-            for node in com:
-                output[node] = i + 1
+        G = n3d.convert_to_multigraph(G)
 
-        if dostats:
-            stats = calculate_louvain_network_stats(G, communities, seed)
-
-        return output, normalized_weights, stats
-
-    elif style == 1:
-        edges = list(zip(master_list[0], master_list[1]))
-        G = nx.Graph()
-        G.add_edges_from(edges)
+    if style == 1:
 
         # Louvain with NetworkX's implementation
         communities = list(nx.community.louvain_communities(G, seed = seed))
@@ -508,60 +473,13 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
                 output[node] = i + 1
 
         if dostats:
-            stats = calculate_louvain_network_stats(G, communities, seed)
+            stats = calculate_louvain_network_stats(G, unweighted_G, communities, seed)
 
         return output, None, stats
 
-    elif style == 0 and weighted:
-
-        G = nx.Graph()
-
-        # Find the maximum and minimum edge weights
-        max_weight = max(weight for edge, weight in edge_weights.items())
-        min_weight = min(weight for edge, weight in edge_weights.items())
-
-        if max_weight > 1:
-            # Normalize edge weights to the range [0.1, 1.0]
-            normalized_weights = {edge: 0.1 + 0.9 * ((weight - min_weight) / (max_weight - min_weight)) for edge, weight in edge_weights.items()}
-        else:
-            normalized_weights = {edge: 0.1 for edge, weight in edge_weights.items()}
-
-        # Add edges to the graph with normalized weights
-        for edge, normalized_weight in normalized_weights.items():
-            G.add_edge(edge[0], edge[1], weight=normalized_weight)
-
-        if seed is not None:
-            import random
-            import numpy as np
-            # Set seeds
-            random.seed(seed)
-            np.random.seed(seed)
-
-        # Detect communities using label propagation
-        communities = list(community.label_propagation_communities(G))
-        output = {}
-        for i, com in enumerate(communities):
-            for node in com:
-                output[node] = i + 1
-
-        if dostats:
-
-            stats = calculate_network_stats(G, communities)
-
-        return output, normalized_weights, stats
-
     elif style == 0:
 
 
-        edges = list(zip(master_list[0], master_list[1]))
-
-        # Create a graph
-        G = nx.Graph()
-
-        # Add edges from the DataFrame
-        G.add_edges_from(edges)
-
-
         # Detect communities using label propagation
 
         if seed is not None:
@@ -579,7 +497,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
 
         if dostats:
 
-            stats = calculate_network_stats(G, communities)
+            stats = calculate_network_stats(G, unweighted_G, communities)
 
         return output, None, stats
 

nettracer3d/neighborhoods.py

@@ -10,6 +10,7 @@ from sklearn.neighbors import NearestNeighbors
 import matplotlib.colors as mcolors
 from collections import Counter
 from . import community_extractor
+import random
 
 
 import os
@@ -418,7 +419,7 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         non_outlier_neighborhoods = {node: neighborhood for node, neighborhood in original_communities.items() if neighborhood != 0}
         
         # Get neighborhoods excluding outliers
-        unique_neighborhoods = set(non_outlier_neighborhoods.values()) if non_outlier_neighborhoods else set()
+        unique_neighborhoods = sorted(set(non_outlier_neighborhoods.values())) if non_outlier_neighborhoods else list()
         
         # Generate colors for non-outlier neighborhoods only (same as assign_community_colors)
         colors = community_extractor.generate_distinct_colors(len(unique_neighborhoods)) if unique_neighborhoods else []
@@ -427,7 +428,7 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         # Use the ORIGINAL node counts from original_communities
         if non_outlier_neighborhoods:
             neighborhood_sizes = Counter(non_outlier_neighborhoods.values())
-            sorted_neighborhoods = sorted(unique_neighborhoods, key=lambda x: (-neighborhood_sizes[x], x))
+            sorted_neighborhoods = random.Random(42).sample(list(unique_neighborhoods), len(unique_neighborhoods))
             neighborhood_to_color = {neighborhood: colors[i] for i, neighborhood in enumerate(sorted_neighborhoods)}
         else:
             neighborhood_to_color = {}

nettracer3d/nettracer.py

@@ -1315,21 +1315,29 @@ def z_project(array3d, method='max'):
     Returns:
         numpy.ndarray: 2D projected array with shape (Y, X)
     """
-    if not isinstance(array3d, np.ndarray) or array3d.ndim != 3:
-        raise ValueError("Input must be a 3D numpy array")
-        
-    if method == 'max':
-        return np.max(array3d, axis=0)
-    elif method == 'mean':
-        return np.mean(array3d, axis=0)
-    elif method == 'min':
-        return np.min(array3d, axis=0)
-    elif method == 'sum':
-        return np.sum(array3d, axis=0)
-    elif method == 'std':
-        return np.std(array3d, axis=0)
+    #if not isinstance(array3d, np.ndarray):
+     #   raise ValueError("Input must be a 3D numpy array")
+    
+
+    if len(array3d.shape) == 3:
+        if method == 'max':
+            return np.max(array3d, axis=0)
+        elif method == 'mean':
+            return np.mean(array3d, axis=0)
+        elif method == 'min':
+            return np.min(array3d, axis=0)
+        elif method == 'sum':
+            return np.sum(array3d, axis=0)
+        elif method == 'std':
+            return np.std(array3d, axis=0)
+        else:
+            raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
     else:
-        raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
+        array_list = []
+        for i in range(array3d.shape[-1]):
+            array_list.append(z_project(array3d[:, :, :, i], method = method))
+        return np.stack(array_list, axis=-1)
+
 
 def fill_holes_3d(array, head_on = False, fill_borders = True):
     def process_slice(slice_2d, border_threshold=0.08, fill_borders = True):
@@ -1631,24 +1639,6 @@ def hash_inners(search_region, inner_edges, GPU = False):
 
     return inner_edges
 
-def hash_inners_old(search_region, inner_edges, GPU = True):
-    """Internal method used to help sort out inner edge connections. The inner edges of the array will not differentiate between what nodes they contact if those nodes themselves directly touch each other.
-    This method allows these elements to be efficiently seperated from each other. Originally this was implemented using the gaussian blur because i didn't yet realize skimage could do the same more efficiently."""
-
-    print("Performing gaussian blur to hash inner edges.")
-
-    blurred_search = smart_dilate.gaussian(search_region, GPU = GPU) 
-
-    borders = binarize((blurred_search - search_region)) #By subtracting the original image from the guassian blurred version, we set all non-border regions to 0
-
-    del blurred_search
-
-    inner_edges = inner_edges * borders #And as a result, we can mask out only 'inner edges' that themselves exist within borders
-
-    inner_edges = dilate_3D_old(inner_edges, 3, 3, 3) #Not sure if dilating is necessary. Want to ensure that the inner edge pieces still overlap with the proper nodes after the masking.
-
-    return inner_edges
-
 
 def dilate_2D(array, search, scaling = 1):
 
@@ -2308,6 +2298,51 @@ def binarize(arrayimage, directory = None):
 
     return arrayimage.astype(np.uint8)
 
+def convert_to_multigraph(G, weight_attr='weight'):
+    """
+    Convert weighted graph to MultiGraph by creating parallel edges.
+    
+    Args:
+        G: NetworkX Graph with edge weights representing multiplicity
+        weight_attr: Name of the weight attribute (default: 'weight')
+    
+    Returns:
+        MultiGraph with parallel edges instead of weights
+    
+    Note:
+        - Weights are rounded to integers
+        - Original node/edge attributes are preserved on first edge
+        - Directed graphs become MultiDiGraphs
+    """
+
+    MG = nx.MultiGraph()
+    
+    # Copy nodes with all their attributes
+    MG.add_nodes_from(G.nodes(data=True))
+    
+    # Convert weighted edges to multiple parallel edges
+    for u, v, data in G.edges(data=True):
+        # Get weight (default to 1 if missing)
+        weight = data.get(weight_attr, 1)
+        
+        # Round to integer for number of parallel edges
+        num_edges = int(round(weight))
+        
+        if num_edges < 1:
+            num_edges = 1  # At least one edge
+        
+        # Create parallel edges
+        for i in range(num_edges):
+            # First edge gets all the original attributes (except weight)
+            if i == 0:
+                edge_data = {k: v for k, v in data.items() if k != weight_attr}
+                MG.add_edge(u, v, **edge_data)
+            else:
+                # Subsequent parallel edges are simple
+                MG.add_edge(u, v)
+    
+    return MG
+
 def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False, dilate_xy = None, dilate_z = None):
     """
     Can be used to dilate a binary image in 3D. Dilated output will be saved to the active directory if none is specified. Note that dilation is done with single-instance kernels and not iterations, and therefore
@@ -4261,27 +4296,30 @@ class Network_3D:
         else:
             outer_edges = dilate_3D_old(outer_edges)
 
-        labelled_edges, num_edge = label_objects(outer_edges)
+        #labelled_edges, num_edge = ndimage.label(outer_edges)
 
-        if inners:
-            inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
+        inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
 
-            del binary_edges
+        del binary_edges
+
+        outer_edges = (inner_edges > 0) | (outer_edges > 0)
 
-            inner_labels, num_edge = label_objects(inner_edges)
+            #inner_labels, num_edge = ndimage.label(inner_edges)
 
-            del inner_edges
+        del inner_edges
 
-            labelled_edges = combine_edges(labelled_edges, inner_labels)
+        outer_edges, num_edge = ndimage.label(outer_edges)
 
-            num_edge = np.max(labelled_edges)
+            #labelled_edges = combine_edges(labelled_edges, inner_labels)
 
-            if num_edge < 256:
-                labelled_edges = labelled_edges.astype(np.uint8)
-            elif num_edge < 65536:
-                labelled_edges = labelled_edges.astype(np.uint16)
+            #num_edge = np.max(labelled_edges)
 
-        self._edges = labelled_edges
+            #if num_edge < 256:
+             #   labelled_edges = labelled_edges.astype(np.uint8)
+            #elif num_edge < 65536:
+             #   labelled_edges = labelled_edges.astype(np.uint16)
+
+        self._edges = outer_edges
 
     def label_nodes(self):
         """
@@ -4748,7 +4786,7 @@ class Network_3D:
         Sets the communities attribute by splitting the network into communities
         """
 
-        self._communities, self.normalized_weights, stats = modularity.community_partition(self._network_lists, weighted = weighted, style = style, dostats = dostats, seed = seed)
+        self._communities, self.normalized_weights, stats = modularity.community_partition(self._network, weighted = weighted, style = style, dostats = dostats, seed = seed)
 
         return stats
 
@@ -4764,6 +4802,8 @@ class Network_3D:
         self._network = network_analysis.open_network(self._network_lists)
 
 
+
+
     def rescale(self, array, directory = None):
         """
         Scale a downsampled overlay or extracted image object back to the size that is present in either a Network_3D's node or edge properties.
@@ -5530,7 +5570,8 @@ class Network_3D:
         Returns:
         dict: Dictionary containing various network statistics
         """
-        G = self._network
+        G_unweighted = self._network
+        G = convert_to_multigraph(self._network)
         stats = {}
         
         # Basic graph properties
@@ -5561,13 +5602,13 @@ class Network_3D:
         try:
             stats['avg_betweenness_centrality'] = np.mean(list(nx.betweenness_centrality(G).values()))
             stats['avg_closeness_centrality'] = np.mean(list(nx.closeness_centrality(G).values()))
-            stats['avg_eigenvector_centrality'] = np.mean(list(nx.eigenvector_centrality(G, max_iter=1000).values()))
+            stats['avg_eigenvector_centrality'] = np.mean(list(nx.eigenvector_centrality(G_unweighted, max_iter=1000).values()))
         except:
             stats['centrality_measures'] = "Failed to compute - graph might be too large or disconnected"
         
         # Clustering and transitivity
-        stats['avg_clustering_coefficient'] = nx.average_clustering(G)
-        stats['transitivity'] = nx.transitivity(G)
+        stats['avg_clustering_coefficient'] = nx.average_clustering(G_unweighted)
+        stats['transitivity'] = nx.transitivity(G_unweighted)
         
         # Path lengths
         if nx.is_connected(G):