nettracer3d 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

nettracer3d/community_extractor.py

@@ -8,7 +8,6 @@ from networkx.algorithms import community
 from scipy import ndimage
 from scipy.ndimage import zoom
 from networkx.algorithms import community
-from community import community_louvain
 import random
 from . import node_draw
 
@@ -229,38 +228,11 @@ def _isolate_connected(G, key = None):
         return G0
 
 
-def extract_mothers(nodes, excel_file_path, centroid_dic = None, directory = None, louvain = True, ret_nodes = False, called = False):
-
-    if type(nodes) == str:
-        nodes = tifffile.imread(nodes)
-
-        if np.unique(nodes) < 3:
-            structure_3d = np.ones((3, 3, 3), dtype=int)
-            nodes, num_nodes = ndimage.label(nodes, structure=structure_3d)
-
-    if type(excel_file_path) == str:
-        G, edge_weights = weighted_network(excel_file_path)
-    else:
-        G = excel_file_path
-
-    if not called:
-
-        if louvain:
-            # Apply the Louvain algorithm for community detection
-            partition = community_louvain.best_partition(G)
-            some_communities = set(partition.values())
-        else:
-            some_communities = list(nx.community.label_propagation_communities(G))
-            partition = {}
-            for i, community in enumerate(some_communities):
-                for node in community:
-                    partition[node] = i + 1
-    else:
-        partition = louvain
-        some_communities = (partition.keys())
+def extract_mothers(nodes, G, partition, centroid_dic = None, directory = None, ret_nodes = False, called = False):
 
 
     my_nodes, intercom_connections, connected_coms = get_border_nodes(partition, G)
+    some_communities = partition.keys()
 
     print(f"Number of intercommunity connections: {intercom_connections}")
     print(f"{len(connected_coms)} communities with any connectivity of {len(some_communities)} communities")
@@ -390,10 +362,14 @@ def find_hub_nodes(G: nx.Graph, proportion: float = 0.1) -> List:
     # Dictionary to store average path lengths for all nodes
     avg_path_lengths: Dict[int, float] = {}
     
+    output = []
+
     # Process each component separately
     for component in components:
         # Create subgraph for this component
         subgraph = G.subgraph(component)
+        if not (len(subgraph.nodes()) * proportion >= 0.75): #Skip components that are too small
+            continue
         
         # Calculate average shortest path length for each node in this component
         for node in subgraph.nodes():
@@ -403,16 +379,18 @@ def find_hub_nodes(G: nx.Graph, proportion: float = 0.1) -> List:
             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]]
+        # 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]]
+        output.extend(hub_nodes)
+        avg_path_lengths: Dict[int, float] = {}
     
-    return hub_nodes
+    return output
 
 def get_color_name_mapping():
     """Return a dictionary of common colors and their RGB values."""

nettracer3d/modularity.py

@@ -1,5 +1,4 @@
 from networkx.algorithms import community
-from community import community_louvain
 import pandas as pd
 import networkx as nx
 import matplotlib.pyplot as plt
@@ -104,77 +103,8 @@ def read_excel_to_lists(file_path, sheet_name=0):
 
 
 
-
-def louvain_mod_solo(G, edge_weights = None, identifier = None, directory_path = None):
-
-    if type(G) == str:
-        G, edge_weights = weighted_network(G)
-
-    if edge_weights is None:
-        edge_weights = get_edge_weights(G)
-
-    # Assuming G is your NetworkX graph
-    # Louvain community detection
-    partition = community_louvain.best_partition(G)
-
-    # Print modularity
-    modularity = community_louvain.modularity(partition, G)
-    number_of_nodes = G.number_of_nodes()
-    print("Modularity:", modularity)
-    num_components = nx.number_connected_components(G)
-
-    if directory_path:
-        with open(f'{directory_path}/{identifier} network stats.txt', 'a') as f:
-            f.write(f'\nlouvain full graph modularity: {modularity} constructed from {num_components} components containing {number_of_nodes} nodes')
-        f.close()
-
-    louvain_graph(edge_weights, identifier, directory_path)
-
-def louvain_mod(G, edge_weights=None, identifier=None, geometric = False, geo_info = None, directory = None):
-
-    if type(G) == list:
-        num_edge = len(G[0])
-    else:
-        num_edge = None
-
-
-    if type(G) == str or type(G) == list:
-        G, edge_weights = network_analysis.weighted_network(G)
-
-    if edge_weights is None:
-        edge_weights = get_edge_weights(G)
-
-    connected_components = list(nx.connected_components(G))
-    num_nodes = float(G.number_of_nodes())
-
-    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)
-
-    for i, component in enumerate(connected_components):
-        # Apply the Louvain community detection on the subgraph
-        partition = community_louvain.best_partition(G.subgraph(component))
-    
-        # Calculate modularity
-        modularity = community_louvain.modularity(partition, G.subgraph(component))
-        num_nodes = len(component)
-
-        print(f"Louvain modularity for component with {num_nodes} nodes: {modularity}")
-
-
-    louvain_graph(edge_weights, identifier, directory, geometric, geo_info)
-
 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)
-        print(partition)
+
     if normalized_weights is None:
         G, edge_weights = network_analysis.weighted_network(master_list)
 
@@ -276,13 +206,7 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
 
 
 
-
-
-
-
-
-
-def community_partition(master_list, weighted = False, style = 0, dostats = True):
+def community_partition(master_list, weighted = False, style = 0, dostats = True, seed = None):
 
     def calculate_network_stats(G, communities):
         """
@@ -392,7 +316,7 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         
         return stats
 
-    def calculate_louvain_network_stats(G, partition):
+    def calculate_louvain_network_stats(G, partition, seed):
         """
         Calculate comprehensive network statistics for the graph using Louvain community detection.
         
@@ -410,17 +334,10 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         """
         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)
+            stats['Modularity Entire Network'] = community.modularity(partition, G)
         except:
             pass
 
@@ -430,8 +347,8 @@ 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 = community_louvain.best_partition(subgraph)
-                    modularity = community_louvain.modularity(subgraph_partition, subgraph)
+                    subgraph_partition = nx.community.louvain_communities(G, weight='weight', seed = seed)
+                    modularity = community.modularity(subgraph_partition, subgraph)
                     num_nodes = len(component)
                     stats[f'Modularity of component with {num_nodes} nodes'] = modularity
         except:
@@ -523,7 +440,6 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         edge_weights = get_edge_weights(G)
 
     if style == 1 and weighted:
-
         G = nx.Graph()
 
         # Find the maximum and minimum edge weights
@@ -540,33 +456,38 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         for edge, normalized_weight in normalized_weights.items():
             G.add_edge(edge[0], edge[1], weight=normalized_weight)
 
-        # Perform Louvain community detection
-        partition = community_louvain.best_partition(G)
+        # 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
 
         if dostats:
+            stats = calculate_louvain_network_stats(G, communities, seed)
 
-            stats = calculate_louvain_network_stats(G, partition)
-
-
-        return partition, normalized_weights, stats
+        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)
 
+        # Replace Louvain with NetworkX's implementation
+        communities = list(nx.community.louvain_communities(G, seed = seed))
 
-        # Perform Louvain community detection
-        partition = community_louvain.best_partition(G)
+        # 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
 
         if dostats:
+            stats = calculate_louvain_network_stats(G, communities, seed)
 
-            stats = calculate_louvain_network_stats(G, partition)
-
-        return partition, None, stats
+        return output, None, stats
 
     elif style == 0 and weighted:
 
@@ -586,6 +507,13 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         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 = {}
@@ -614,6 +542,14 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
 
 
         # Detect communities using label propagation
+
+        if seed is not None:
+            import random
+            import numpy as np
+            # Set seeds
+            random.seed(seed)
+            np.random.seed(seed)
+
         communities = list(community.label_propagation_communities(G))
         output = {}
         for i, com in enumerate(communities):
@@ -627,127 +563,6 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         return output, None, stats
 
 
-
-def _louvain_mod_solo(G, edge_weights = None):
-
-
-    if type(G) == str:
-        G, edge_weights = weighted_network(G)
-
-    # Louvain community detection
-    partition = community_louvain.best_partition(G)
-
-    # modularity
-    modularity = community_louvain.modularity(partition, G)
-
-    print(f"Modularity is {modularity}")
-
-    return modularity
-
-def _louvain_mod(G, edge_weights = None):
-
-    if type(G) == str:
-        G, edge_weights = weighted_network(G)
-
-    connected_components = list(nx.connected_components(G))
-    return_dict = {}
-
-    for i, component in enumerate(connected_components):
-        # Apply the Louvain community detection on the subgraph
-        partition = community_louvain.best_partition(G.subgraph(component))
-        
-        # Calculate modularity
-        modularity = community_louvain.modularity(partition, G.subgraph(component))
-        num_nodes = len(component)
-        return_dict[num_nodes] = modularity
-
-        print(f"Louvain modularity for component with {num_nodes} nodes: {modularity}")
-
-    return return_dict
-
-def louvain_graph(edge_weights, identifier, directory_path, geometric, geo_info):
-    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 geometric:
-        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)")
-
-    # Perform Louvain community detection
-    partition = community_louvain.best_partition(G)
-
-    # Invert the partition dictionary to group nodes by their community
-    print(f"louvain_communities_initial: {partition}")
-    communities = {}
-    for node, community_id in partition.items():
-        communities.setdefault(community_id, []).append(node)
-
-    print(f"louvain_communities_after: {partition}")
-
-    # Prepare colors for each community
-    unique_communities = set(partition.values())
-    colors = [plt.cm.jet(i / len(unique_communities)) for i in range(len(unique_communities))]
-
-    if geometric:
-
-        pos, z_pos  = simple_network.geometric_positions(geo_info[0], geo_info[1])
-        #nx.draw(G, pos, with_labels=True, font_color='black', font_weight='bold', node_size = node_sizes_list, node_color = node_color_list, alpha=0.8, font_size = 12)
-
-        # Draw the nodes, coloring them according to their community
-        for community_id, nodes in communities.items():
-            node_sizes_list = [z_pos[node] for node in nodes]
-            nx.draw_networkx_nodes(G, pos, nodelist=nodes, node_color=[colors[community_id]], node_size=node_sizes_list, alpha=0.8)
-
-        # Modify edge drawing to consider normalized weights
-        for edge in G.edges():
-            normalized_weight = G[edge[0]][edge[1]]['weight']
-            
-            # Scale the width based on a constant factor (e.g., 5)
-            nx.draw_networkx_edges(G, pos, edgelist=[edge], width=5 * normalized_weight, edge_color='black')
-
-        # Optionally, draw node labels
-        nx.draw_networkx_labels(G, pos)
-
-
-    else:
-        # Position nodes using the spring layout
-        pos = nx.spring_layout(G)
-
-        # Draw the nodes, coloring them according to their community
-        for community_id, nodes in communities.items():
-            nx.draw_networkx_nodes(G, pos, nodelist=nodes, node_color=[colors[community_id]], node_size=100, alpha=0.8)
-
-        # Modify edge drawing to consider normalized weights
-        for edge in G.edges():
-            normalized_weight = G[edge[0]][edge[1]]['weight']
-            
-            # Scale the width based on a constant factor (e.g., 5)
-            nx.draw_networkx_edges(G, pos, edgelist=[edge], width=5 * normalized_weight, edge_color='black')
-
-        # Optionally, draw node labels
-        nx.draw_networkx_labels(G, pos)
-
-    plt.axis('off')
-    if directory_path is not None:
-        plt.savefig(f'{directory_path}/community_louvain_network_plot.png')
-
-    plt.show()
-
 def create_directory(directory_name):
     try:
         os.mkdir(directory_name)
@@ -782,43 +597,5 @@ def remove_small_components(G, threshold):
     return G
 
 
-def louvain_analysis_5x(G, excel_file, identifier, directory_path):
-    print("Performing Louvain Community Detection...")
-    df = pd.read_excel(excel_file)
-    G, edge_weights = weighted_network(excel_file)
-    threshold = find_threshold(G)
-    G = remove_small_components(G, threshold)
-    louvain_mod(G, identifier, directory_path)
-    louvain_graph(edge_weights, identifier, directory_path)
-    print("Done")
-
-def louvain_analysis_20x(G, excel_file, identifier, directory_path):
-    print("Performing Louvain Community Detection...")
-    df = pd.read_excel(excel_file)
-    G, edge_weights = weighted_network(excel_file)
-    louvain_mod_20x(G, identifier, directory_path)
-    louvain_graph(edge_weights, identifier, directory_path)
-    print("Done")
-
-
 if __name__ == "__main__":
-    excel_name = input("excel file?: ")
-    is_5x = input("Is 5x? (Type Y for 5x): ")
-    if is_5x == 'Y':
-
-        df = pd.read_excel(excel_name)
-        identifier = "output"
-        directory_path = 'output'
-        create_directory(directory_path)
-        G, edge_weights = weighted_network(excel_name)
-        #threshold = find_threshold(G)
-        #G = remove_small_components(G, threshold)
-        louvain_mod_solo(G, edge_weights, identifier, directory_path)
-
-    else:
-        df = pd.read_excel(excel_name)
-        identifier = "output"
-        directory_path = 'output'
-        create_directory(directory_path)
-        G, edge_weights = weighted_network(excel_name)
-        louvain_mod(G, edge_weights, identifier, directory_path)
+    pass

nettracer3d/nettracer.py

@@ -3564,12 +3564,12 @@ class Network_3D:
 
     #Some methods that may be useful:
 
-    def community_partition(self, weighted = False, style = 0, dostats = True):
+    def community_partition(self, weighted = False, style = 0, dostats = True, seed = None):
         """
         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)
+        self._communities, self.normalized_weights, stats = modularity.community_partition(self._network_lists, weighted = weighted, style = style, dostats = dostats, seed = seed)
 
         return stats
 
@@ -4027,66 +4027,6 @@ class Network_3D:
         self._communities, self.normalized_weights = modularity.show_communities_flex(self._network, self._network_lists, self.normalized_weights, geo_info = [self._node_centroids, self._nodes.shape], geometric = geometric, directory = directory, weighted = weighted, partition = partition, style = style)
 
 
-    def show_communities(self, geometric = False, directory = None):
-        """
-        Shows the network property, and some basic stats, as a graph where nodes are labelled by colors representing the community they belong to as determined by a label propogation algorithm. Does not support viewing edge weights.
-        :param geoemtric: (Optional - Val = False; boolean). If False, node placement in the graph will be random. If True, nodes
-        will be placed in their actual spatial location (from the original node segmentation) along the XY plane, using node_centroids.
-        The node size will then represent the nodes Z location, with smaller nodes representing a larger Z value. If False, nodes will be placed randomly.
-        :param directory: (Optional – Val = None; string). An optional string path to a directory to save the network plot image to. If not set, nothing will be saved.
-        """
-
-        if not geometric:
-
-            simple_network.show_community_network(self._network_lists, directory = directory)
-
-        else:
-            simple_network.show_community_network(self._network_lists, geometric = True, geo_info = [self._node_centroids, self._nodes.shape], directory = directory)
-
-
-    def show_communities_louvain(self, geometric = False, directory = None):
-        """
-        Shows the network property as a graph, and some basic stats, where nodes are labelled by colors representing the community they belong to as determined by a louvain algorithm. Supports viewing edge weights.
-        :param geoemtric: (Optional - Val = False; boolean). If False, node placement in the graph will be random. If True, nodes
-        will be placed in their actual spatial location (from the original node segmentation) along the XY plane, using node_centroids.
-        The node size will then represent the nodes Z location, with smaller nodes representing a larger Z value. If False, nodes will be placed randomly.
-        """
-
-        if not geometric:
-
-            modularity.louvain_mod(self._network_lists, directory = directory)
-        else:
-            modularity.louvain_mod(self._network_lists, geometric = True, geo_info = [self._node_centroids, self._nodes.shape], directory = directory)
-
-    def louvain_modularity(self, solo_mod = False):
-        """
-        Shows some basic stats of the network, including modularity (essentially strength of community structure), using a louvain algorithm that accounts for edge weights.
-        :param solo_mod: (Optional - Val = False; boolean). If True, will return a singular modularity for the network, taking into
-        account all disconnected components as pieces of a network. If False, will return the modularity of each singular disconnected component of the network with the number of nodes in the component as a key
-        and the modularity of the component as a value.
-        :returns: A dictionary containing the modularity for each disconnected component in the network, key-indexed by that component's node count, or a single modularity value accounting for all disconnected components of the network if the solo_mod param is True.
-        """
-
-        if not solo_mod:
-            mod = modularity._louvain_mod(self._network)
-        else:
-            mod = modularity._louvain_mod_solo(self._network)
-
-        return mod
-
-    def modularity(self, solo_mod = False):
-        """
-        Shows some basic stats of the network, including modularity (essentially strength of community structure), using a label propogation algorithm that does not consider edge weights.
-        :param solo_mod: (Optional - Val = False; boolean). If True, will return a singular modularity for the network, taking into
-        account all disconnected components as pieces of a network. If False, will return the modularity of each singular disconnected component of the network with the number of nodes in the component as a key
-        and the modularity of the component as a value.
-        :returns: A dictionary containing the modularity for each disconnected component in the network, key-indexed by that component's node count, or a single modularity value accounting for all disconnected components of the network if the solo_mod param is True.
-        """
-
-        modularity = simple_network.modularity(self._network, solo_mod = solo_mod)
-
-        return modularity
-
 
     def show_identity_network(self, geometric = False, directory = None):
         """
@@ -4149,7 +4089,7 @@ class Network_3D:
         return G
 
 
-    def isolate_mothers(self, directory = None, down_factor = 1, louvain = True, ret_nodes = False, called = False):
+    def isolate_mothers(self, directory = None, down_factor = 1, ret_nodes = False, called = False):
 
         """
         Method to isolate 'mother' nodes of a network (in this case, this means nodes that exist betwixt communities), also generating overlays that relate this information to the 3D structure.
@@ -4163,7 +4103,7 @@ class Network_3D:
         """
 
         if ret_nodes:
-            mothers = community_extractor.extract_mothers(None, self._network, louvain = louvain, ret_nodes = True, called = called)
+            mothers = community_extractor.extract_mothers(None, self._network, self._communities, ret_nodes = True, called = called)
             return mothers
         else:
 
@@ -4172,9 +4112,9 @@ class Network_3D:
                 for item in self._node_centroids:
                     centroids[item] = np.round((self._node_centroids[item]) / down_factor)
                 nodes = downsample(self._nodes, down_factor)
-                mothers, overlay = community_extractor.extract_mothers(nodes, self._network, directory = directory, centroid_dic = centroids, louvain = louvain, called = called)
+                mothers, overlay = community_extractor.extract_mothers(nodes, self._network, self._communities, directory = directory, centroid_dic = centroids, called = called)
             else:
-                mothers, overlay = community_extractor.extract_mothers(self._nodes, self._network, centroid_dic = self._node_centroids, directory = directory, louvain = louvain, called = called)
+                mothers, overlay = community_extractor.extract_mothers(self._nodes, self._network, self._communities, centroid_dic = self._node_centroids, directory = directory, called = called)
             return mothers, overlay
 
 
@@ -4186,7 +4126,7 @@ class Network_3D:
 
             hub_img = np.isin(self._nodes, hubs) * self._nodes
         else:
-            hub_iimg = None
+            hub_img = None
 
         return hubs, hub_img
 
@@ -4248,33 +4188,6 @@ class Network_3D:
         
 
 
-
-
-    def extract_communities_louvain(self, directory = None, down_factor = 1, color_code = True):
-        """
-        Method to generate overlays that relate community detection in a network to the 3D structure.
-        Overlays include a grayscale image where nodes are assigned a grayscale value corresponding to their community, a numerical index where numbers are drawn at nodes corresponding to their community, and a
-        color coded overlay where a nodes color corresponds to its community. Community detection will be done with louvain algorithm.
-        These will be saved to the active directory if none is specified.
-        :param directory: (Optional - Val = None; string). A path to a directory to save outputs.
-        :param down_factor: (Optional - Val = 1; int). A factor to downsample nodes by while drawing overlays. Note this option REQUIRES node_centroids to already be set.
-        :param color code: (Optional - Val = True; boolean). If set to False, the color-coded overlay will not be drawn.
-        :returns: A dictionary where nodes are grouped by community.
-        """
-
-        if down_factor > 1:
-            centroids = self._node_centroids.copy()
-            for item in self._node_centroids:
-                centroids[item] = np.round((self._node_centroids[item]) / down_factor)
-            nodes = downsample(self._nodes, down_factor)
-            partition = network_analysis.community_partition(nodes, self._network_lists, directory = directory, centroids = centroids, color_code = color_code)
-
-        else:
-            partition = network_analysis.community_partition(self._nodes, self._network_lists, directory = directory, centroids = self._node_centroids, color_code = color_code)
-
-        return partition
-
-
     #Methods related to analysis:
 
     def radial_distribution(self, radial_distance, directory = None):