topologicpy 0.8.33__py3-none-any.whl → 0.8.35__py3-none-any.whl

topologicpy/CellComplex.py

@@ -48,99 +48,6 @@ except:
         warnings.warn("CellComplex - Error: Could not import scipy.")
 
 class CellComplex():
-    @staticmethod
-    def AdjacencyDictionary(cellComplex, cellLabelKey: str = None,  faceKey: str = None, includeWeights: bool = False, reverse: bool = False, mantissa: int = 6, silent: bool = False):
-        """
-        Returns the adjacency dictionary of the input Graph.
-
-        Parameters
-        ----------
-        cellComplex : topologic_core.CellComplex
-            The input cellComplex.
-        cellLabelKey : str , optional
-            The returned cells are labelled according to the dictionary values stored under this key.
-            If the cellLabelKey does not exist, it will be created and the cells are labelled numerically and stored in the vertex dictionary under this key. The default is None.
-        faceKey : str , optional
-            If set, the faces' dictionaries will be searched for this key to set their weight. If the key is set to "Area" (case insensitive), the area of the shared faces will be used as its weight. If set to None, a weight of 1 will be used. The default is None.
-        includeWeights : bool , optional
-            If set to True, edge weights are included. Otherwise, they are not. The default is False.
-        reverse : bool , optional
-                If set to True, the cells are sorted in reverse order (only if cellLabelKey is set). Otherwise, they are not. The default is False.
-
-        silent : bool , optional
-                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
-
-        Returns
-        -------
-        dict
-            The adjacency dictionary.
-        """
-        from topologicpy.Face import Face
-        from topologicpy.Dictionary import Dictionary
-        from topologicpy.Topology import Topology
-        from topologicpy.Helper import Helper
-
-        if not Topology.IsInstance(cellComplex, "CellComplex"):
-            if not silent:
-                print("CellComplex.AdjacencyDictionary - Error: The input cellComplex input parameter is not a valid cellComplex. Returning None.")
-            return None
-        if cellLabelKey == None:
-            cellLabelKey = "__label__"
-        if not isinstance(cellLabelKey, str):
-            if not silent:
-                print("CellComplex.AdjacencyDictionary - Error: The input cellLabelKey is not a valid string. Returning None.")
-            return None
-        all_cells = Topology.Cells(cellComplex)
-        labels = []
-        n = max(len(str(len(all_cells))), 3)
-        for i, cell in enumerate(all_cells):
-            d = Topology.Dictionary(cell)
-            value = Dictionary.ValueAtKey(d, cellLabelKey)
-            if value == None:
-                value = str(i+1).zfill(n)
-            if d == None:
-                d = Dictionary.ByKeyValue(cellLabelKey, value)
-            else:
-                d = Dictionary.SetValueAtKey(d, cellLabelKey, value)
-            cell = Topology.SetDictionary(cell, d)
-            labels.append(value)
-        all_cells = Helper.Sort(all_cells, labels)
-        labels.sort()
-        order = len(all_cells)
-        adjDict = {}
-        for i in range(order):
-            cell = all_cells[i]
-            cell_label = labels[i]
-            adjCells = Topology.AdjacentTopologies(cell, hostTopology=cellComplex, topologyType="cell")
-            temp_list = []
-            for adjCell in adjCells:
-                adj_label = Dictionary.ValueAtKey(Topology.Dictionary(adjCell), cellLabelKey)
-                adj_index = labels.index(adj_label)
-                if includeWeights == True:
-                    if faceKey == None:
-                        weight = 1
-                    elif "area" in faceKey.lower():
-                        shared_topologies = Topology.SharedTopologies(cell, adjCell)
-                        faces = shared_topologies.get("faces", [])
-                        weight = sum([Face.Area(face, mantissa=mantissa) for face in faces])
-                    else:
-                        shared_topologies = Topology.SharedTopologies(cell, adjCell)
-                        faces = shared_topologies.get("faces", [])
-                        weight = sum([Dictionary.ValueAtKey(Topology.Dictionary(face),faceKey, 0) for face in faces])
-                    if not adj_index == None:
-                        temp_list.append((adj_label, weight))
-                else:
-                    if not adj_index == None:
-                        temp_list.append(adj_label)
-            temp_list.sort()
-            adjDict[cell_label] = temp_list
-        if cellLabelKey == "__label__": # This is label we added, so remove it
-            for cell in all_cells:
-                d = Topology.Dictionary(cell)
-                d = Dictionary.RemoveKey(d, cellLabelKey)
-                cell = Topology.SetDictionary(cell, d)
-        return adjDict
-
     @staticmethod
     def Box(origin= None,
             width: float = 1.0, length: float = 1.0, height: float = 1.0,
@@ -1143,7 +1050,7 @@ class CellComplex():
         shells = Topology.Shells(cellComplex)
         return shells
 
-
+    @staticmethod
     def _grow_connected_group(seed_idx, group_size, adjacency, visited_global):
         """
         Attempts to grow a group of the given size starting from seed_idx using adjacency.
@@ -1170,98 +1077,6 @@ class CellComplex():
 
         return group if len(group) == group_size else None
 
-    def SubCombinations(cellComplex,
-                        minCells: int = 2,
-                        maxCells: int = None,
-                        maxCombinations: int = 100,
-                        timeLimit: int = 10,
-                        silent: bool = False):
-        """
-        Creates sub-combination cellComplexes of the input cellComplex. Warning: This is prone to combinatorial explosion.
-
-        Parameters
-        ----------
-        cellComplex : topologic_core.cellComplex
-            The input cellComplex
-        minCells : int , optional
-            The minimum number of cells to include in a combination. The default is 2.
-        maxCells : int , optional
-            The maximum number of cells to include in a combinations. The default is None which means the maximum will be set to the number of cells in the cellComplex minus 1.
-        maxCombinations : int , optional
-            The maximum number of combinations to create. The default is 100.
-        timeLimit : int , optional
-                The time limit in seconds. The default is 10 seconds. Note that this time limit only applies to creating the combination indices and not the actual CellComplexes.
-        tolerance : float , optional
-            The tolerance for computing if the input vertex is external to the input topology. 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
-        -------
-        list
-            The list of created CellComplex sub-combinations.
-
-        """
-        from topologicpy.Cluster import Cluster
-        from topologicpy.Topology import Topology
-        from topologicpy.Dictionary import Dictionary
-        import random
-        import time
-
-        if not Topology.IsInstance(cellComplex, "CellComplex"):
-            if not silent:
-                print("CellComplex.SubCombinations - Error: The cellComplex input parameter is not a valid cellComplex. Returning None.")
-            return None
-
-        
-        start_time = time.time()
-        all_cells = CellComplex.Cells(cellComplex)
-        num_cells = len(all_cells)
-        indices = list(range(num_cells))
-        cell_label_key = "index"
-        # 1. Assign a unique index to each cell's dictionary
-        all_cells = [Topology.SetDictionary(cell, Dictionary.ByKeyValue(cell_label_key, i)) for i, cell in enumerate(all_cells)]
-        if maxCells == None:
-            maxCells = len(all_cells) - 1
-        # 2. Allocate counts per group size
-        group_sizes = list(range(minCells, maxCells + 1))
-        combinations_per_size = maxCombinations // len(group_sizes)
-
-        # 3. Build adjacency dict
-        adjacency = CellComplex.AdjacencyDictionary(cellComplex, cellLabelKey=cell_label_key, faceKey=None, includeWeights=False)
-
-        results = []
-        seen_groups = set()  # sets of sorted indices
-
-        # 4. Start from longest group size
-        for group_size in reversed(group_sizes):
-            remaining = combinations_per_size
-            tries = 0
-            max_tries = combinations_per_size * 10  # fallback guard
-            while remaining > 0 and time.time() - start_time < timeLimit and tries < max_tries:
-                random.shuffle(indices)
-                for seed in indices:
-                    if time.time() - start_time > timeLimit:
-                        break
-                    group = CellComplex._grow_connected_group(seed, group_size, adjacency, visited_global=seen_groups)
-                    if group:
-                        key = tuple(sorted(group))
-                        if key not in seen_groups:
-                            tries += 1
-                            seen_groups.add(key)
-                            results.append(group)
-                            remaining -= 1
-                    if remaining <= 0 or tries >= max_tries:
-                        break
-        # 5. Build CellComplex SubCombinations
-        return_combinations = []
-        for i, result in enumerate(reversed(results)):
-            cells = [all_cells[i] for i in result]
-            combination = Topology.SelfMerge(Cluster.ByTopologies(cells))
-            if Topology.IsInstance(combination, "CellComplex"):
-                return_combinations.append(combination)
-        return return_combinations
-
     @staticmethod
     def Tetrahedron(origin = None, length: float = 1, depth: int = 1, direction=[0,0,1], placement="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """

topologicpy/Dictionary.py

@@ -46,6 +46,125 @@ class Dictionary():
             dictionaries.append(Dictionary.ByKeysValues(keys, values))
         return dictionaries
     '''
+    @staticmethod
+    def AdjacencyDictionary(topology, subTopologyType: str = None, labelKey: str = None,  weightKey: str = None, includeWeights: bool = False, mantissa: int = 6, silent: bool = False):
+        """
+        Returns the adjacency dictionary of the input Shell.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        subTopologyType : str , optional
+            The type of subTopology on which to base the adjacency dictionary.
+        labelKey : str , optional
+            The returned subTopologies are labelled according to the dictionary values stored under this key.
+            If the labelKey does not exist, it will be created and the subTopologies are labelled numerically and stored in the subTopologies' dictionary under this key. The default is None.
+        weightKey : str , optional
+            If set, the sharedTopologies' dictionaries will be searched for this key to set their weight. If the key is set to "Area" or "Length" (case insensitive), the area of shared faces or the length of the shared edges will be used as its weight. If set to None, a weight of 1 will be used. The default is None.
+        includeWeights : bool , optional
+            If set to True, edge weights are included. Otherwise, they are not. The default is False.
+        mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        dict
+            The adjacency dictionary.
+        """
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+        from topologicpy.Helper import Helper
+
+        if not Topology.IsInstance(topology, "Topology") and not Topology.IsInstance(topology, "Graph"):
+            if not silent:
+                print("Dictionary.AdjacencyDictionary - Error: The input topology input parameter is not a valid topology. Returning None.")
+            return None
+        # Special Case for Graphs
+
+        if Topology.IsInstance(topology, "Graph"):
+            return Graph.AdjacencyDictionary(topology, vertexLabelKey=labelKey, edgeKey=weightKey, includeWeights=includeWeights, mantissa=mantissa)
+        if labelKey == None:
+            labelKey = "__label__"
+        if not isinstance(labelKey, str):
+            if not silent:
+                print("Dictionary.AdjacencyDictionary - Error: The input labelKey is not a valid string. Returning None.")
+            return None
+        if Topology.IsInstance(topology, "cellcomplex"):
+            if subTopologyType == None:
+                subTopologyType = "cell"
+            all_subtopologies = Topology.SubTopologies(topology, subTopologyType=subTopologyType, silent=silent)
+        elif Topology.IsInstance(topology, "cell") or Topology.IsInstance(topology, "shell"):
+            if subTopologyType == None:
+                subTopologyType = "face"
+            all_subtopologies = Topology.SubTopologies(topology, subTopologyType=subTopologyType, silent=silent)
+        elif Topology.IsInstance(topology, "face") or Topology.IsInstance(topology, "wire"):
+            if subTopologyType == None:
+                subTopologyType = "edge"
+            all_subtopologies = Topology.SubTopologies(topology, subTopologyType=subTopologyType, silent=silent)
+        labels = []
+        n = max(len(str(len(all_subtopologies))), 3)
+        for i, subtopology in enumerate(all_subtopologies):
+            d = Topology.Dictionary(subtopology)
+            value = Dictionary.ValueAtKey(d, labelKey)
+            if value == None:
+                value = str(i+1).zfill(n)
+            if d == None:
+                d = Dictionary.ByKeyValue(labelKey, value)
+            else:
+                d = Dictionary.SetValueAtKey(d, labelKey, value)
+            subtopology = Topology.SetDictionary(subtopology, d)
+            labels.append(value)
+        all_subtopologies = Helper.Sort(all_subtopologies, labels)
+        labels.sort()
+        order = len(all_subtopologies)
+        adjDict = {}
+        for i in range(order):
+            subtopology = all_subtopologies[i]
+            subt_label = labels[i]
+            adjacent_topologies = Topology.AdjacentTopologies(subtopology, hostTopology=topology, topologyType=subTopologyType)
+            temp_list = []
+            for adj_topology in adjacent_topologies:
+                adj_label = Dictionary.ValueAtKey(Topology.Dictionary(adj_topology), labelKey)
+                adj_index = labels.index(adj_label)
+                if includeWeights == True:
+                    if weightKey == None:
+                        weight = 1
+                    elif "length" in weightKey.lower():
+                        shared_topologies = Topology.SharedTopologies(subtopology, adj_topology)
+                        edges = shared_topologies.get("edges", [])
+                        weight = sum([Edge.Length(edge, mantissa=mantissa) for edge in edges])
+                    elif "area" in weightKey.lower():
+                        shared_topologies = Topology.SharedTopologies(subtopology, adj_topology)
+                        faces = shared_topologies.get("faces", [])
+                        weight = sum([Edge.Length(edge, mantissa=mantissa) for face in faces])
+                    else:
+                        shared_topologies = Topology.SharedTopologies(subtopology, adj_topology)
+                        vertices = shared_topologies.get("vertices", [])
+                        edges = shared_topologies.get("edges", [])
+                        wires = shared_topologies.get("wires", [])
+                        faces = shared_topologies.get("faces", [])
+                        everything = vertices+edges+wires+faces
+                        weight = sum([Dictionary.ValueAtKey(Topology.Dictionary(x),weightKey, 0) for x in everything])
+                        weight = round(weight, mantissa)
+                    if not adj_index == None:
+                        temp_list.append((adj_label, weight))
+                else:
+                    if not adj_index == None:
+                        temp_list.append(adj_label)
+            temp_list.sort()
+            adjDict[subt_label] = temp_list
+        if labelKey == "__label__": # This is label we added, so remove it
+            for subtopology in all_subtopologies:
+                d = Topology.Dictionary(subtopology)
+                d = Dictionary.RemoveKey(d, labelKey)
+                subtopology = Topology.SetDictionary(subtopology, d)
+        return adjDict
+    
     @staticmethod
     def ByKeyValue(key, value):
         """

topologicpy/Graph.py

@@ -523,7 +523,7 @@ class Graph:
         _ = graph.AddVertices(vertices, tolerance) # Hook to Core
         return graph
     
-    def AdjacencyDictionary(graph, vertexLabelKey: str = None, edgeKey: str = "Length", includeWeights: bool = False, reverse: bool = False, mantissa: int = 6):
+    def AdjacencyDictionary(graph, vertexLabelKey: str = None, edgeKey: str = "Length", includeWeights: bool = False, mantissa: int = 6):
         """
         Returns the adjacency dictionary of the input Graph.
 
@@ -537,9 +537,7 @@ class Graph:
         edgeKey : str , optional
             If set, the edges' dictionaries will be searched for this key to set their weight. If the key is set to "length" (case insensitive), the length of the edge will be used as its weight. If set to None, a weight of 1 will be used. The default is "Length".
         includeWeights : bool , optional
-            If set to True, edge weights are included. Otherwise, they are not. The default is False.
-        reverse : bool , optional
-                If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
+            If set to True, edge weights are included. Otherwise, they are not. The default is False.        
         mantissa : int , optional
                 The desired length of the mantissa. The default is 6.
 
@@ -578,9 +576,6 @@ class Graph:
             labels.append(value)
         vertices = Helper.Sort(vertices, labels)
         labels.sort()
-        if reverse == True:
-            vertices.reverse()
-            labels.reverse()
         order = len(vertices)
         adjDict = {}
         for i in range(order):

topologicpy/Helper.py

@@ -286,6 +286,58 @@ class Helper:
             flat_list = flat_list + Helper.Flatten(item)
         return flat_list
 
+    @staticmethod
+    def Grow(seed_idx, group_size, adjacency, visited_global): 
+        """
+        Attempts to grow a spatially connected group of a specified size starting from a given seed index.
+
+        This method uses a breadth-first search strategy to explore neighboring indices from the seed index,
+        guided by the provided adjacency dictionary. It avoids reusing indices that are globally visited.
+        The growth continues until the desired group size is reached or no further expansion is possible.
+
+        Parameters
+        ----------
+        seed_idx : int
+            The index from which to start growing the group.
+        group_size : int
+            The target size of the group to be grown.
+        adjacency : dict
+            A dictionary mapping each index to a list of adjacent indices. This defines the connectivity.
+        visited_global : set
+            A set of indices that have already been used in previously grown groups and should be avoided.
+
+        Returns
+        -------
+        list[int] or None
+            A list of indices representing a connected group of the specified size if successful, otherwise None.
+
+        Notes
+        -----
+        This method is intended for internal use in functions that generate connected subgroups
+        of spatial elements (e.g., cells) based on adjacency. The result may vary between runs due to random shuffling
+        of neighbor order to diversify outputs.
+        """
+        from collections import deque
+        import random
+
+        group = [seed_idx]
+        visited = set(group)
+        queue = deque([seed_idx])
+
+        while queue and len(group) < group_size:
+            current = queue.popleft()
+            neighbors = adjacency.get(current, [])
+            random.shuffle(neighbors)
+            for neighbor in neighbors:
+                if neighbor not in visited and neighbor not in visited_global:
+                    group.append(neighbor)
+                    visited.add(neighbor)
+                    queue.append(neighbor)
+                    if len(group) >= group_size:
+                        break
+
+        return group if len(group) == group_size else None
+    
     @staticmethod
     def Iterate(listA):
         """

topologicpy/Shell.py

@@ -739,42 +739,6 @@ class Shell():
         _ = shell.Faces(None, faces)
         return faces
     
-    @staticmethod
-    def IsOnBoundary(shell, vertex, tolerance: float = 0.0001) -> bool:
-        """
-        Returns True if the input vertex is on the boundary of the input shell. Returns False otherwise. On the boundary is defined as being on the boundary of one of the shell's external or internal boundaries
-
-        Parameters
-        ----------
-        shell : topologic_core.Shell
-            The input shell.
-        vertex : topologic_core.Vertex
-            The input vertex.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-
-        Returns
-        -------
-        bool
-            Returns True if the input vertex is inside the input shell. Returns False otherwise.
-
-        """
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(shell, "Shell"):
-            return None
-        if not Topology.IsInstance(vertex, "Vertex"):
-            return None
-        boundary = Shell.ExternalBoundary(shell, tolerance=tolerance)
-        if Vertex.IsInternal(vertex, boundary, tolerance=tolerance):
-            return True
-        internal_boundaries = Shell.InternalBoundaries(shell, tolerance=tolerance)
-        for ib in internal_boundaries:
-            if Vertex.IsInternal(vertex, ib, tolerance=tolerance):
-                return True
-        return False
-    
     @staticmethod
     def HyperbolicParaboloidRectangularDomain(origin= None,
                                               llVertex= None,
@@ -1097,6 +1061,41 @@ class Shell():
         """
         return shell.IsClosed()
 
+    @staticmethod
+    def IsOnBoundary(shell, vertex, tolerance: float = 0.0001) -> bool:
+        """
+        Returns True if the input vertex is on the boundary of the input shell. Returns False otherwise. On the boundary is defined as being on the boundary of one of the shell's external or internal boundaries
+
+        Parameters
+        ----------
+        shell : topologic_core.Shell
+            The input shell.
+        vertex : topologic_core.Vertex
+            The input vertex.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        bool
+            Returns True if the input vertex is inside the input shell. Returns False otherwise.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(shell, "Shell"):
+            return None
+        if not Topology.IsInstance(vertex, "Vertex"):
+            return None
+        boundary = Shell.ExternalBoundary(shell, tolerance=tolerance)
+        if Vertex.IsInternal(vertex, boundary, tolerance=tolerance):
+            return True
+        internal_boundaries = Shell.InternalBoundaries(shell, tolerance=tolerance)
+        for ib in internal_boundaries:
+            if Vertex.IsInternal(vertex, ib, tolerance=tolerance):
+                return True
+        return False
 
     @staticmethod
     def Paraboloid(origin= None, focalLength=0.125, width: float = 1, length: float = 1, uSides: int = 16, vSides: int = 16,
@@ -1644,62 +1643,6 @@ class Shell():
         else:
             return None
 
-    def Skeleton(face, tolerance: float = 0.001):
-        """
-            Creates a shell through a straight skeleton. This method is contributed by 高熙鹏 xipeng gao <gaoxipeng1998@gmail.com>
-            This algorithm depends on the polyskel code which is included in the library. Polyskel code is found at: https://github.com/Botffy/polyskel
-
-        Parameters
-        ----------
-        face : topologic_core.Face
-            The input face.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.001. (This is set to a larger number as it was found to work better)
-
-        Returns
-        -------
-        topologic_core.Shell
-            The created straight skeleton.
-
-        """
-        from topologicpy.Wire import Wire
-        from topologicpy.Face import Face
-        from topologicpy.Topology import Topology
-        import topologic_core as topologic
-        import math
-
-        if not Topology.IsInstance(face, "Face"):
-            return None
-        roof = Wire.Skeleton(face, tolerance=tolerance)
-        if not (Topology.IsInstance(roof, "Wire") or Topology.IsInstance(roof, "Cluster")):
-            print("Shell.Skeleton - Error: Could not create base skeleton wire. Returning None.")
-            return None
-        br = Wire.BoundingRectangle(roof) #This works even if it is a Cluster not a Wire
-        if not Topology.IsInstance(br, "Wire"):
-            print("Shell.Skeleton - Error: Could not create a bounding rectangle wire. Returning None.")
-            return None
-        br = Topology.Scale(br, Topology.Centroid(br), 1.5, 1.5, 1)
-        bf = Face.ByWire(br, tolerance=tolerance)
-        if not Topology.IsInstance(bf, "Face"):
-            print("Shell.Skeleton - Error: Could not create a bounding rectangle face. Returning None.")
-            return None
-        large_shell = Topology.Boolean(bf, roof, operation="slice", tolerance=tolerance)
-        if not large_shell:
-            return None
-        faces = Topology.Faces(large_shell)
-        if not faces:
-            return None
-        final_faces = []
-        for f in faces:
-            internalBoundaries = Face.InternalBoundaries(f)
-            if len(internalBoundaries) == 0:
-                final_faces.append(f)
-        shell = Shell.ByFaces(final_faces, tolerance=tolerance)
-        if not Topology.IsInstance(shell, "Shell"):
-            print("Shell.Skeleton - Error: Could not create shell. Returning None.")
-            return None
-        return shell
-
     @staticmethod
     def Simplify(shell, simplifyBoundary: bool = True, mantissa: int = 6, tolerance: float = 0.0001):
         """
@@ -1846,6 +1789,63 @@ class Shell():
             final_result = Shell.ByFaces(final_faces, tolerance=tolerance)
         return final_result
 
+    @staticmethod
+    def Skeleton(face, tolerance: float = 0.001):
+        """
+            Creates a shell through a straight skeleton. This method is contributed by 高熙鹏 xipeng gao <gaoxipeng1998@gmail.com>
+            This algorithm depends on the polyskel code which is included in the library. Polyskel code is found at: https://github.com/Botffy/polyskel
+
+        Parameters
+        ----------
+        face : topologic_core.Face
+            The input face.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.001. (This is set to a larger number as it was found to work better)
+
+        Returns
+        -------
+        topologic_core.Shell
+            The created straight skeleton.
+
+        """
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+        import topologic_core as topologic
+        import math
+
+        if not Topology.IsInstance(face, "Face"):
+            return None
+        roof = Wire.Skeleton(face, tolerance=tolerance)
+        if not (Topology.IsInstance(roof, "Wire") or Topology.IsInstance(roof, "Cluster")):
+            print("Shell.Skeleton - Error: Could not create base skeleton wire. Returning None.")
+            return None
+        br = Wire.BoundingRectangle(roof) #This works even if it is a Cluster not a Wire
+        if not Topology.IsInstance(br, "Wire"):
+            print("Shell.Skeleton - Error: Could not create a bounding rectangle wire. Returning None.")
+            return None
+        br = Topology.Scale(br, Topology.Centroid(br), 1.5, 1.5, 1)
+        bf = Face.ByWire(br, tolerance=tolerance)
+        if not Topology.IsInstance(bf, "Face"):
+            print("Shell.Skeleton - Error: Could not create a bounding rectangle face. Returning None.")
+            return None
+        large_shell = Topology.Boolean(bf, roof, operation="slice", tolerance=tolerance)
+        if not large_shell:
+            return None
+        faces = Topology.Faces(large_shell)
+        if not faces:
+            return None
+        final_faces = []
+        for f in faces:
+            internalBoundaries = Face.InternalBoundaries(f)
+            if len(internalBoundaries) == 0:
+                final_faces.append(f)
+        shell = Shell.ByFaces(final_faces, tolerance=tolerance)
+        if not Topology.IsInstance(shell, "Shell"):
+            print("Shell.Skeleton - Error: Could not create shell. Returning None.")
+            return None
+        return shell
+    
     @staticmethod
     def Square(origin= None, size: float = 1.0,
                   uSides: int = 2, vSides: int = 2, direction: list = [0, 0, 1],
@@ -1882,6 +1882,33 @@ class Shell():
                   uSides=uSides, vSides=vSides, direction=direction,
                   placement=placement, tolerance=tolerance)
     
+    @staticmethod
+    def _grow_connected_group(seed_idx, group_size, adjacency, visited_global):
+        """
+        Attempts to grow a group of the given size starting from seed_idx using adjacency.
+        Returns a list of indices if successful, else None.
+        """
+        from collections import deque
+        import random
+
+        group = [seed_idx]
+        visited = set(group)
+        queue = deque([seed_idx])
+
+        while queue and len(group) < group_size:
+            current = queue.popleft()
+            neighbors = adjacency.get(current, [])
+            random.shuffle(neighbors)
+            for neighbor in neighbors:
+                if neighbor not in visited and neighbor not in visited_global:
+                    group.append(neighbor)
+                    visited.add(neighbor)
+                    queue.append(neighbor)
+                    if len(group) >= group_size:
+                        break
+
+        return group if len(group) == group_size else None
+    
     @staticmethod
     def Vertices(shell) -> list:
         """

topologicpy/Topology.py

@@ -7897,13 +7897,6 @@ class Topology():
                 calframe = inspect.getouterframes(curframe, 2)
                 print('caller name:', calframe[1][3])
             return topology
-        # if len(dictionary.Keys()) < 1:
-        #     if not silent:
-        #         print("Topology.SetDictionary - Warning: the input dictionary parameter is empty. Returning original input.")
-        #         curframe = inspect.currentframe()
-        #         calframe = inspect.getouterframes(curframe, 2)
-        #         print('caller name:', calframe[1][3])
-        #     return topology
         _ = topology.SetDictionary(dictionary)
         return topology
     
@@ -8861,6 +8854,177 @@ class Topology():
                 pass
         return returnTopology
     
+    @staticmethod
+    def SubCombinations(topology,
+                        subTopologyType=None,
+                        minSize: int = 2,
+                        maxSize: int = None,
+                        maxCombinations: int = 100,
+                        timeLimit: int = 10,
+                        removeCoplanarFaces: bool = False,
+                        removeCollinearEdges: bool = False,
+                        tolerance: float = 0.001,
+                        silent: bool = False):
+        """
+        Creates connected sub-combination topologies of the input topology. Warning: This is prone to combinatorial explosion.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology. This cannot be vertex or edge.
+        subTopologyType : str , optional except when topology is a Cluster
+            The type of subTopology to include in the combinations.
+            If the input is a Cluster, you must specify the subTopologyType.
+            The options are (case insensitive):
+                - "CellComplex"
+                - "Shell"
+                - "Wire"
+            If set to None, it will be set according to the input topology type as follows:
+                - "Cluster" -> User-defined
+                - "CellComplex" -> "CellComplexes"
+                - "Cell" -> "Shells"
+                - "Shell" -> "Shells"
+                - "Face" -> "Wires"
+                - "Wire" -> "Wires"
+                - "Edge" -> None
+                - "Vertex" -> None
+                - "Graph" -> "Graphs"
+        minSize : int , optional
+            The minimum number of subtopologies to include in a combination. This number cannot be less than 2. The default is 2.
+        maxSize : int , optional
+            The maximum number of faces to include in a combinations. This number cannot be less than the number of subtopologies minus 1. The default is None which means the maximum will be set to the number of subtopologies minus 1.
+        maxCombinations : int , optional
+            The maximum number of combinations to create. The default is 100.
+        timeLimit : int , optional
+                The time limit in seconds. The default is 10 seconds. Note that this time limit only applies to creating the combination indices and not the actual Shells.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed. Otherwise they are not. The default is False.
+        removeCollinearEdges : bool , optional
+            If set to True, collinear edges are removed. Otherwise they are not. The default is False.
+        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
+        -------
+        list
+            The list of created sub-combinations.
+
+        """
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+        import random
+        import time
+
+        if Topology.IsInstance(topology, "cluster") and subTopologyType is None:
+            if not silent:
+                print("Topology.SubCombinations - Error: The topology input parameter is a cluster but the subTopologyType is not specified. Returning None.")
+            return None
+
+        if Topology.IsInstance(topology, "vertex") or Topology.IsInstance(topology, "edge"):
+            if not silent:
+                print("Topology.SubCombinations - Error: The topology input parameter cannot be a vertex or an edge. Returning None.")
+            return None
+
+        mapping = {
+            "cellcomplex": "cell",
+            "cell": "face",
+            "shell": "face",
+            "face": "edge",
+            "wire": "edge",
+            "graph": "vertex"
+        }
+
+        type_string = Topology.TypeAsString(topology).lower()
+        if type_string not in mapping:
+            if not silent:
+                print(f"Topology.SubCombinations - Error: The input topology type ({type_string}) is not supported. Returning None.")
+            return None
+
+        if subTopologyType is None:
+            subTopologyType = mapping[type_string]
+        subTopologyType = subTopologyType.lower()
+
+        if subTopologyType not in ["cell", "face", "edge", "vertex"]:
+            if not silent:
+                print(f"Topology.SubCombinations - Error: Unknown subTopologyType: {subTopologyType}. Returning None.")
+            return None
+
+        if ((type_string in ["cell", "shell"]) and subTopologyType not in ["face", "edge"]) or \
+        ((type_string in ["wire", "face"]) and subTopologyType != "edge"):
+            if not silent:
+                print(f"Topology.SubCombinations - Error: The subTopology type {subTopologyType} is not appropriate for topology of type {type_string}. Returning None.")
+            return None
+
+        all_subtopologies = Topology.SubTopologies(topology, subTopologyType=subTopologyType, silent=silent)
+        num_subtopologies = len(all_subtopologies)
+        if num_subtopologies < 2:
+            if not silent:
+                print("Topology.SubCombinations - Warning: Not enough subtopologies found. Returning empty list.")
+            return []
+
+        indices = list(range(num_subtopologies))
+        minSize = max(2, minSize)
+        maxSize = num_subtopologies - 1 if maxSize is None else min(maxSize, num_subtopologies - 1)
+
+        subt_label_key = "__index__"
+        all_subtopologies = [Topology.SetDictionary(subt, Dictionary.ByKeyValue(subt_label_key, i)) for i, subt in enumerate(all_subtopologies)]
+
+        group_sizes = list(range(minSize, maxSize + 1))
+        num_sizes = len(group_sizes)
+        per_size_combinations = maxCombinations // num_sizes
+        per_size_time = timeLimit / num_sizes
+
+        adjacency = Dictionary.AdjacencyDictionary(topology, subTopologyType=subTopologyType, labelKey=subt_label_key, weightKey=None, includeWeights=False)
+
+        results = []
+        seen_groups = set()
+
+        for group_size in reversed(group_sizes):
+            size_start_time = time.time()
+            remaining = per_size_combinations
+            tries = 0
+            max_tries = per_size_combinations * 10
+
+            while remaining > 0 and (time.time() - size_start_time) < per_size_time and tries < max_tries:
+                random.shuffle(indices)
+                for seed in indices:
+                    if (time.time() - size_start_time) > per_size_time:
+                        break
+                    group = Helper.Grow(seed, group_size, adjacency, visited_global=seen_groups)
+                    if group:
+                        key = tuple(sorted(group))
+                        if key not in seen_groups:
+                            tries += 1
+                            seen_groups.add(key)
+                            results.append(group)
+                            remaining -= 1
+                    if remaining <= 0 or tries >= max_tries:
+                        break
+
+        return_combinations = []
+        for result in reversed(results):
+            subtopologies = [all_subtopologies[i] for i in result]
+            # Special case for graphs
+            if Topology.IsInstance(topology, "Graph"):
+                edges = Graph.Edges(topology, vertices = subtopologies)
+                combination = Graph.ByVerticesEdges(subtopologies, edges)
+            else:
+                combination = Topology.SelfMerge(Cluster.ByTopologies(subtopologies), tolerance=tolerance)
+                if removeCollinearEdges:
+                    if Topology.IsInstance(combination, "face") or Topology.IsInstance(combination, "wire"):
+                        combination = Topology.RemoveCollinearEdges(combination, tolerance=tolerance)
+                if removeCoplanarFaces:
+                    if Topology.IsInstance(combination, "cellcomplex") or Topology.IsInstance(combination, "cell") or Topology.IsInstance(combination, "shell"):
+                        combination = Topology.RemoveCoplanarFaces(combination, tolerance=tolerance)
+            return_combinations.append(combination)
+
+        return return_combinations
+
     @staticmethod
     def Taper(topology, origin=None, ratioRange: list = [0, 1], triangulate: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
         """
@@ -9188,7 +9352,7 @@ class Topology():
         return Topology.SubTopologies(topology=topology, subTopologyType="cluster")
     
     @staticmethod
-    def SubTopologies(topology, subTopologyType="vertex"):
+    def SubTopologies(topology, subTopologyType="vertex", silent: bool = False):
         """
         Returns the subtopologies of the input topology as specified by the subTopologyType input string.
 
@@ -9198,7 +9362,8 @@ class Topology():
             The input topology.
         subTopologyType : str , optional
             The requested subtopology type. This can be one of "vertex", "edge", "wire", "face", "shell", "cell", "cellcomplex", "cluster". It is case insensitive. The default is "vertex".
-
+        silent : bool , optional
+            If set to True, no warnings or errors will be printed. The default is False.
         Returns
         -------
         list
@@ -9206,15 +9371,28 @@ class Topology():
 
         """
         from topologicpy.Face import Face
+        from topologicpy.Graph import Graph
 
-        if not Topology.IsInstance(topology, "Topology"):
-            print("Topology.SubTopologies - Error: the input topology parameter is not a valid topology. Returning None.")
+        if not Topology.IsInstance(topology, "Topology") and not Topology.IsInstance(topology, "Graph"):
+            if not silent:
+                print("Topology.SubTopologies - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
         if Topology.TypeAsString(topology).lower() == subTopologyType.lower():
             return [topology]
         
         subTopologies = []
 
+        # Special case for Graphs
+        if Topology.IsInstance(topology, "graph"):
+            if subTopologyType.lower() == "vertex":
+                return Graph.Vertices(topology)
+            elif subTopologyType.lower() == "edge":
+                return Graph.Edges(topology)
+            else:
+                if not silent:
+                    print(f"Topology.SubTopologies - Error: the input subTopologyType parameter {subTopologyType} is not a valid subTopology of Graphs. Returning None.")
+                return None
+
         # Spcecial case for faces to return vertices in CW/CCW order.
         if Topology.IsInstance(topology, "face") and (subTopologyType.lower() == "vertex" or subTopologyType.lower() == "edge"):
             wires = Face.Wires(topology)

topologicpy/Wire.py

@@ -4629,7 +4629,7 @@ class Wire():
         """
         sv, ev = Wire.StartEndVertices(wire)
         return sv
-    
+
     @staticmethod
     def Trapezoid(origin= None, widthA: float = 1.0, widthB: float = 0.75, offsetA: float = 0.0, offsetB: float = 0.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.33'
+__version__ = '0.8.35'

{topologicpy-0.8.33.dist-info → topologicpy-0.8.35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.33
+Version: 0.8.35
 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.8.33.dist-info → topologicpy-0.8.35.dist-info}/RECORD

@@ -3,18 +3,18 @@ topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
 topologicpy/BVH.py,sha256=ti-23A2HIxaqnJ3C9GWhCjQev9qQwdrSfZVfXVZujYE,13127
 topologicpy/CSG.py,sha256=hqFPg3RvAnRgzwyyWbc4N80ZYO9AfvbWn0RsjXvaz8k,15695
 topologicpy/Cell.py,sha256=WQyi2xKT5PFovGZzu1oiw0ICuJultsOXnNbfELrMLTI,173467
-topologicpy/CellComplex.py,sha256=nrQmlqr0wUkd6CrpaMRfgBo6O8Crgk1rM1jDEphiDmc,70051
+topologicpy/CellComplex.py,sha256=muhqLpnlZXZKVSF3j_v4uF1LbdVyrZqmLqH_uoACYRU,60919
 topologicpy/Cluster.py,sha256=Wv81yPlQ3Qlnylpvs2aBVNV77M0Z9oHTUfTeLbAuX74,58790
 topologicpy/Color.py,sha256=ZVVQRKGjebY9aOU1gpN_AbssdRRiVKlZV3f8TrsTNgg,20307
 topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
 topologicpy/DGL.py,sha256=HQXy9iDnrvWGDxaBfe5pRbweQ2zLBvAf6UdjfhKkQYI,139041
-topologicpy/Dictionary.py,sha256=Lf24WHW8q_RCq0l8VpT3XJTn6UuStY66JI4Lb4W08jI,34126
+topologicpy/Dictionary.py,sha256=Rdd8RwBkuoqndcDWOHfO5oZHngoF2brNdWEB7P5Bns4,40900
 topologicpy/Edge.py,sha256=6M7UMPZj_JXXH9mFieEcQu3haYQ6Rn64yRcL0b_axl8,73484
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
 topologicpy/Face.py,sha256=1r6j4DOhDJEVyRTuFhxh1wmRMEvqZe8FQ0_Yy-J0pzg,202021
-topologicpy/Graph.py,sha256=0w3GP1CuJyE6xq1mALB93R3s4OFJnF6k9HkRZDhwkoQ,581043
+topologicpy/Graph.py,sha256=VNJsJpJW2fJADzgT_yYDljEc_2YjGgHBmWjIqcVplNE,580758
 topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
-topologicpy/Helper.py,sha256=JdvC30WMrla46mTj5TdwCV_bRv-6y8vK5Bkx0prluy4,29100
+topologicpy/Helper.py,sha256=9YdcJ8P6HYi-3v0lV_QNQw-PwUcl3TnBrw2QPBdNiqo,31287
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=BHGDRkBn1pf5DkRoY8feAhDGHTF3bjFM4jluiEb_A0w,22779
 topologicpy/Neo4j.py,sha256=vNMaqTWerwr-3luLjYEXNhf8T97aFee6x5sIKBHY73s,22392
@@ -22,17 +22,17 @@ topologicpy/Plotly.py,sha256=5E6M2N0MbdkA5iMZ_Y71PaPB9wilEneYVUba8RqeKe0,119400
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
 topologicpy/ShapeGrammar.py,sha256=ay2kOkMvoa_KqGd_ZCLgDk0hmyMniI636N_YbMsyM60,23259
-topologicpy/Shell.py,sha256=h8S2nP1e0JtMxeOdAFZVhOYTJWTW8vlZRM5lxK0gu2o,89577
+topologicpy/Shell.py,sha256=4zqC5m7RRQAmeIugqH098vSfBuW77L9ao5erdh8gA1Y,90585
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=SFC3YBiLDH5zoZgJ1fPyZ72W_fTSbjkMOoXPI2mexU8,457623
+topologicpy/Topology.py,sha256=Bc16DUPrigdTiN_ShS6JViHRjsmR3jxChRBTe12S7Cw,466405
 topologicpy/Vector.py,sha256=mx7fgABdioikPWM9HzXKzmqfx3u_XBcU_jlLD4qK2x8,42407
 topologicpy/Vertex.py,sha256=sY9M7sMep7iTGiRYlmr8ed18Yz_RLyH6-Fm_L6SJTTw,84688
-topologicpy/Wire.py,sha256=5k6KflNQv2HGI1ncWLywwjqdNzJGJT2IsPbU7qnfM2Q,231723
+topologicpy/Wire.py,sha256=lxlooqXjSWntwlg_h6AepNpOw_JPDIUpQKkrvvNYERk,231719
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=n8OQUN0fcpz2N9lYYXEoI8M_7OTKzN9D-4I2JYQIW6s,23
-topologicpy-0.8.33.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.33.dist-info/METADATA,sha256=UeGTrzifYBHgIosB2QHKADZQ3Kd8PmoG4ZRUAgWhp6A,10535
-topologicpy-0.8.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.33.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.33.dist-info/RECORD,,
+topologicpy/version.py,sha256=3ZOp-2mi5vS_FqQuNhjU7Os4xS6SwCO3uIAj_kgDx28,23
+topologicpy-0.8.35.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.35.dist-info/METADATA,sha256=vRbd2Mu3HprTBjKk-chx8zZXvRdPIm7x0I_oPvNhdaA,10535
+topologicpy-0.8.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.35.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.35.dist-info/RECORD,,