topologicpy 0.7.98__py3-none-any.whl → 0.8.0__py3-none-any.whl

topologicpy/Graph.py

@@ -1421,6 +1421,75 @@ class Graph:
                 graph_edges[i] = Topology.SetDictionary(graph_edges[i], d)
             return edge_betweenness_scores
 
+    @staticmethod
+    def BetweennessPartition(graph, n=2, m=10, key="partition", tolerance=0.0001, silent=False):
+        """
+        Computes a partition of the input graph based on the edge betweenness method. See https://en.wikipedia.org/wiki/Graph_partition.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        n : int , optional
+            The desired number of partitions when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 2.
+        m : int , optional
+            The desired maximum number of tries to partition the graph when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 10.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the parition number. The default is "partition".
+            Valid partition numbers start from 1. Cut edges receive a partition number of 0.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+        from topologicpy.Dictionary import Dictionary
+
+        edge_scores = Graph.BetweennessCentrality(graph, method="edge")
+        graph_edges = Graph.Edges(graph)
+
+        graph_edges = Helper.Sort(graph_edges, edge_scores)
+        graph_edges.reverse()
+        cut_edges = []
+        components = 1
+        tries = 0
+        while components < n and tries < m:
+            components = len(Graph.ConnectedComponents(graph, key=key, tolerance=tolerance, silent=silent))
+            if components == n:
+                if not silent:
+                    print("Graph.BetweennessPartition - Warning: The input graph is already partitioned into partitions that are equal in number to the desired number of partitions.")
+                return graph
+            elif components > n:
+                if not silent:
+                    print("Graph.BetweennessPartition - Warning: The input graph is already partitioned into partitions that are greater in number than the desired number of partitions.")
+                return graph
+            elif len(graph_edges) < 1:
+                components = n
+            else:
+                edge = graph_edges[0]
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, key, 0) # 0 indicates a cut edge
+                edge = Topology.SetDictionary(edge, d)
+                cut_edges.append(edge)
+                graph = Graph.RemoveEdge(graph, edge, tolerance=tolerance)
+                graph_edges = graph_edges[1:]
+                components = len(Graph.ConnectedComponents(graph, key=key, tolerance=tolerance, silent=silent))
+            tries += 1
+            if tries == m:
+                if not silent:
+                    print("Graph.Partition - Warning: Reached the maximum number of tries.")
+        return_vertices = Graph.Vertices(graph)
+        return_edges = Graph.Edges(graph) + cut_edges
+        graph = Graph.ByVerticesEdges(return_vertices, return_edges)
+        return graph
+    
     @staticmethod
     def Bridges(graph, key: str = "bridge", silent: bool = False):
         """
@@ -4394,7 +4463,7 @@ class Graph:
         return Graph.ByVerticesEdges(vertices, edges)
 
     @staticmethod
-    def ConnectedComponents(graph, tolerance: float = 0.0001, silent: bool = False):
+    def ConnectedComponents(graph, key: str = "component", tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the connected components (islands) of the input graph.
 
@@ -4402,6 +4471,8 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the component number. The default is "component".
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -4447,23 +4518,36 @@ class Graph:
         labelKey = "__label__"
         lengths = [] #List of lengths to sort the list of components by number of their vertices
         vertices = Graph.Vertices(graph)
+        vertex_map = {}
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, labelKey, i)
+            v = Topology.SetDictionary(v, d)
+            vertex_map[i] = v
         g_dict = Graph.AdjacencyDictionary(graph, vertexLabelKey=labelKey)
         components = find_connected_components(g_dict)
         return_components = []
-        for component in components:
+        for i, component in enumerate(components):
             i_verts = []
-            for v in component:        
-                vert = Topology.Filter(vertices, searchType="equal to", key=labelKey, value=v)['filtered'][0]
+            for v in component:
+                vert = vertex_map[v]
                 d = Topology.Dictionary(vert)
                 d = Dictionary.RemoveKey(d, labelKey)
+                d = Dictionary.SetValueAtKey(d, key, i+1)
                 vert = Topology.SetDictionary(vert, d)
                 i_verts.append(vert)
-            i_edges = Graph.Edges(graph, i_verts)
-            lengths.append(len(i_verts))
-            g_component = Graph.ByVerticesEdges(i_verts, i_edges)
-            return_components.append(g_component)
-        return_components = Helper.Sort(return_components, lengths)
-        return_components.reverse()
+            if len(i_verts) > 0:
+                i_edges = Graph.Edges(graph, i_verts)
+                for i_edge in i_edges:
+                    d = Topology.Dictionary(i_edge)
+                    d = Dictionary.SetValueAtKey(d, key, i+1)
+                    i_edge = Topology.SetDictionary(i_edge, d)
+                lengths.append(len(i_verts))
+                g_component = Graph.ByVerticesEdges(i_verts, i_edges)
+                return_components.append(g_component)
+        if len(return_components) > 0:
+            return_components = Helper.Sort(return_components, lengths)
+            return_components.reverse()
         return return_components
 
     @staticmethod
@@ -4658,17 +4742,16 @@ class Graph:
             return centralities
 
     @staticmethod
-    def Community(graph, key: str = "community", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+    def Community(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Computes the best community partition of the input graph based on the Louvain method. See https://en.wikipedia.org/wiki/Louvain_method.
-        This method depends on NetworkX and the python-louvain libraries
 
         Parameters
         ----------
         graph : topologicp.Graph
             The input topologic graph.
         key : str , optional
-            The dictionary key under which to store the closeness centrality score. The default is "community".
+            The dictionary key under which to store the partition number. The default is "partition".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -4678,9 +4761,38 @@ class Graph:
         Returns
         -------
         topologicpy.Graph
-            The created topologic graph.
+            The partitioned topologic graph.
+
+        """
+        if not silent:
+            print("Graph.Community - Warning: This method is deprectated. Please use Graph.CommunityPartition instead.")
+        return Graph.CommunityPartition(graph=graph, key=key, mantissa=mantissa, tolerance=tolerance, silent=silent)
+    
+    @staticmethod
+    def CommunityPartition(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Computes the best community partition of the input graph based on the Louvain method. See https://en.wikipedia.org/wiki/Louvain_method.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        key : str , optional
+            The dictionary key under which to store the partition number. The default is "partition".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
 
         """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
         import os
@@ -4713,13 +4825,39 @@ class Graph:
         communities = ig_graph.community_multilevel()
 
         # Get the list of communities sorted same as vertices
-        community_list = communities.membership
+        partition_list = communities.membership
         vertices = Graph.Vertices(graph)
         for i, v in enumerate(vertices):
             d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, community_list[i])
+            d = Dictionary.SetValueAtKey(d, key, partition_list[i]+1)
             v = Topology.SetDictionary(v, d)
-        return community_list
+        edges = Graph.Edges(graph)
+        if not edges == None:
+            for edge in edges:
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                status_1 = False
+                status_2 = False
+                partition_1 = 0
+                partition_2 = 0
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(sv, v, tolerance=tolerance):
+                        status_1 = True
+                        partition_1 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(ev, v, tolerance=tolerance):
+                        status_2 = True
+                        partition_2 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                partition = 0
+                if status_1 and status_2:
+                    if partition_1 == partition_2:
+                        partition = partition_1
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, key, partition)
+                edge = Topology.SetDictionary(edge, d)
+        return graph
 
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
@@ -6412,6 +6550,80 @@ class Graph:
         eigenvalues, eigenvectors = Matrix.EigenvaluesAndVectors(laplacian, mantissa=mantissa)
         return eigenvectors[1]
 
+    @staticmethod
+    def FiedlerVectorPartition(graph, key="partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Partitions the input graph based on FiedlerVector method. See https://en.wikipedia.org/wiki/Graph_partition.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the parition number. The default is "partition".
+            Valid partition numbers start from 1. Cut edges receive a partition number of 0.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
+
+        """ 
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge    
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.FiedlerVectorPartition - Error: The input graph parameter is not a valid topologic graph. Returning None.")
+            return None
+
+        fiedler_vector = Graph.FiedlerVector(graph, mantissa=mantissa, silent=silent)
+
+        vertices = Graph.Vertices(graph)
+        for i, f_v in enumerate(fiedler_vector):
+            if f_v >=0:
+                partition = 1
+            else:
+                partition = 2 
+            d = Topology.Dictionary(vertices[i])
+            d = Dictionary.SetValueAtKey(d, key, partition)
+            vertices[i] = Topology.SetDictionary(vertices[i], d)
+        edges = Graph.Edges(graph)
+        if not edges == None:
+            for edge in edges:
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                status_1 = False
+                status_2 = False
+                partition_1 = 0
+                partition_2 = 0
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(sv, v, tolerance=tolerance):
+                        status_1 = True
+                        partition_1 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                for i, v in enumerate(vertices):
+                    if Vertex.IsCoincident(ev, v, tolerance=tolerance):
+                        status_2 = True
+                        partition_2 = Dictionary.ValueAtKey(Topology.Dictionary(v), key)
+                        break
+                partition = 0
+                if status_1 and status_2:
+                    if partition_1 == partition_2:
+                        partition = partition_1
+                d = Topology.Dictionary(edge)
+                d = Dictionary.SetValueAtKey(d, key, partition)
+                edge = Topology.SetDictionary(edge, d)
+        return graph
+
     @staticmethod
     def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
@@ -9163,7 +9375,60 @@ class Graph:
             d = Dictionary.SetValueAtKey(d, key, scores[i])
             v = Topology.SetDictionary(v, d)
         return scores
-    
+
+    @staticmethod
+    def Partition(graph, method: str = "Betweenness", n: int = 2, m: int = 10, key: str ="partition",
+                mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Partitions the input graph based on the desired partition method. See https://en.wikipedia.org/wiki/Graph_partition.
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        method : str , optional
+            The desired partitioning method. The options are:
+            - "Betweenness"
+            - "Community" or "Louvain"
+            - "Fiedler" or "Eigen"
+            It is case insensitive. The default is "Betweenness"
+        n : int , optional
+            The desired number of partitions when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 2.
+        m : int , optional
+            The desired maximum number of tries to partition the graph when selecting the "Betweenness" method. This parameter is ignored for other methods. The default is 10.
+        key : str , optional
+            The vertex and edge dictionary key under which to store the parition number. The default is "partition".
+            Valid partition numbers start from 1. Cut edges receive a partition number of 0.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        topologicpy.Graph
+            The partitioned topologic graph.
+
+        """ 
+
+        m_d = Graph.MeshData(graph)
+        new_graph = Graph.ByMeshData(vertices = m_d['vertices'],
+                                    edges = m_d['edges'],
+                                    vertexDictionaries = m_d['vertexDictionaries'],
+                                    edgeDictionaries = m_d['edgeDictionaries'])
+        if "between" in method.lower():
+            return Graph.BetweennessPartition(new_graph, n=n, m=m, key=key, tolerance=tolerance, silent=silent)
+        elif "community" in method.lower() or "louvain" in method.lower():
+            return Graph.CommunityPartition(new_graph, key=key, mantissa=mantissa, tolerance=tolerance, silent=silent)
+        elif "fied" in method.lower() or "eig" in method.lower():
+            return Graph.FiedlerVectorPartition(new_graph, key=key, mantissa=mantissa, tolerance=tolerance, silent=silent)
+        else:
+            if not silent:
+                print("Graph.Partition - Error: The chosen method is not supported. Returning None.")
+            return None
+
     @staticmethod
     def Path(graph, vertexA, vertexB, tolerance=0.0001):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.98'
+__version__ = '0.8.0'

{topologicpy-0.7.98.dist-info → topologicpy-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.98
+Version: 0.8.0
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.7.98.dist-info → topologicpy-0.8.0.dist-info}/RECORD

@@ -11,7 +11,7 @@ topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,331
 topologicpy/Edge.py,sha256=gaLqyjFOqFHpw69Ftr4rc-kvakYpauQwhOK4ZO-V35g,67287
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=wczXpMcfub8Eb10lA4rrXksvi5YYCbRjBdp3lOTUwK0,172618
-topologicpy/Graph.py,sha256=IL7htimFIpRIFSGlNgXqdIkq6KgHFUe9T144yGIk2Qc,479404
+topologicpy/Graph.py,sha256=T_NC-Gvf7F7DWdfWvQB7sQ_v790lTT74SLKTl-UhSZE,492072
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=F3h4_qcOD_PHAoVe0tEbEE7_jYyVcaHjtwVs4QHOZuI,23978
 topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
@@ -28,9 +28,9 @@ topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
 topologicpy/Vertex.py,sha256=tv6C-rbuNgXHDGgVLT5fbalynLdXqlUuiCDKtkeQ0vk,77814
 topologicpy/Wire.py,sha256=bX8wO96gFa7HZPY0CFlmYQBOUP_1e0jCb02BPxaY-ao,222981
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=edt03iPp-fWm-GyKIDUNJimGnmtCRb6Pjv3dsEvhru4,23
-topologicpy-0.7.98.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.98.dist-info/METADATA,sha256=U6xzVbESx3zzAX4CakRjfE90LNZLqEdPZMN3SKbRBdQ,10513
-topologicpy-0.7.98.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.98.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.98.dist-info/RECORD,,
+topologicpy/version.py,sha256=27YY3zFpeaDh6JoC40AqkjBrn68SqFlsWZzjZtw5jwU,22
+topologicpy-0.8.0.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.0.dist-info/METADATA,sha256=OqI6ytVUGQkoA75zzzwsqmh2nhxJg5KbX42vCQPST3c,10512
+topologicpy-0.8.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.8.0.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.0.dist-info/RECORD,,