topologicpy 0.8.59__py3-none-any.whl → 0.8.71__py3-none-any.whl

topologicpy/Kuzu.py

@@ -476,7 +476,7 @@ class Kuzu:
     def GraphsByQuery(
         manager,
         query: str,
-        params: dict | None = None,
+        params: dict = None,
         silent: bool = False,
     ):
         """

topologicpy/Shell.py

@@ -1013,12 +1013,15 @@ class Shell():
     @staticmethod
     def InternalBoundaries(shell, tolerance=0.0001):
         """
-        Returns the internal boundaries (closed wires) of the input shell. Internal boundaries are considered holes.
+        Returns the internal boundaries of the input shell.
 
         Parameters
         ----------
         shell : topologic_core.Shell
             The input shell.
+        groupKey : str , optional
+            The edge dictionary key under which to save the edge group number. The default is "group".
+            Edges that separate the same faces belong to the same group.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
 
@@ -1028,19 +1031,54 @@ class Shell():
             The list of internal boundaries
 
         """
+        from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
-        edges = []
-        _ = shell.Edges(None, edges)
+        from topologicpy.Dictionary import Dictionary
+        faces = Shell.Faces(shell)
+        for i, f in enumerate(faces):
+            d = Topology.Dictionary(f)
+            d = Dictionary.SetValueAtKey(d, "__id__", i)
+            f = Topology.SetDictionary(f, d)
+
+        edges = Topology.Edges(shell)
         ibEdges = []
+        groups = []
         for anEdge in edges:
-            faces = []
-            _ = anEdge.Faces(shell, faces)
+            faces = Topology.SuperTopologies(anEdge, shell, topologyType="face")
             if len(faces) > 1:
+                d = Topology.Dictionary(anEdge)
+                ids = []
+                for aFace in faces:
+                    face_d = Topology.Dictionary(aFace)
+                    ids.append(Dictionary.ValueAtKey(face_d, "__id__", -1))
+                ids.sort()
+                ids = str(ids)
+                groups.append(ids)
+                d = Dictionary.SetValueAtKey(d, "__group__", ids)
+                anEdge = Topology.SetDictionary(anEdge, d)
                 ibEdges.append(anEdge)
-        returnTopology = Topology.SelfMerge(Cluster.ByTopologies(ibEdges), tolerance=tolerance)
-        wires = Topology.Wires(returnTopology)
-        return wires
+                for aFace in faces:
+                    face_d = Topology.Dictionary(aFace)
+                    face_d = Dictionary.RemoveKey(face_d, "__id__")
+
+        groups = list(set(groups))
+        for edge in ibEdges:
+            d = Topology.Dictionary(edge)
+            id = groups.index(Dictionary.ValueAtKey(d, "__group__"))
+            d = Dictionary.SetValueAtKey(d, "__group__", id)
+        edge_groups = []
+        for group in groups:
+            edge_group = Topology.Filter(ibEdges, searchType="equal to", key="__group__", value=group)['filtered']
+            edge_groups.append(edge_group)
+        final_groups = []
+        for edge_group in edge_groups:
+            final_groups.append(Topology.SelfMerge(Cluster.ByTopologies(edge_group, silent=True), tolerance=tolerance))
+        for edge in ibEdges:
+            d = Topology.Dictionary(edge)
+            d = Dictionary.RemoveKey(d, "__group__")
+            edge = Topology.SetDictionary(edge, d)
+        return final_groups
 
     
     @staticmethod
@@ -1750,8 +1788,7 @@ class Shell():
             else:
                 return f
         elif Topology.IsInstance(ext_boundary, "Cluster"):
-            wires = []
-            _ = ext_boundary.Wires(None, wires)
+            wires = Topology.Wires(ext_boundary)
             faces = []
             areas = []
             for aWire in wires:
@@ -1770,8 +1807,7 @@ class Shell():
                 temp_wires = []
                 _ = int_boundary.Wires(None, temp_wires)
                 int_wires.append(Topology.RemoveCollinearEdges(temp_wires[0], angTolerance))
-            temp_wires = []
-            _ = ext_boundary.Wires(None, temp_wires)
+            temp_wires = Topology.Wire(ext_boundary)
             ext_wire = Topology.RemoveCollinearEdges(temp_wires[0], angTolerance)
             try:
                 return Face.ByWires(ext_wire, int_wires, tolerance=tolerance)
@@ -2067,7 +2103,7 @@ class Shell():
         if not Topology.IsInstance(shell, "Shell"):
             return None
         vertices = []
-        _ = shell.Vertices(None, vertices)
+        _ = shell.Vertices(None, vertices) # Hook to core
         return vertices
 
     @staticmethod
@@ -2205,7 +2241,7 @@ class Shell():
         if not Topology.IsInstance(shell, "Shell"):
             return None
         wires = []
-        _ = shell.Wires(None, wires)
+        _ = shell.Wires(None, wires) # Hook to core
         return wires
 
     

topologicpy/Topology.py

@@ -225,6 +225,7 @@ class Topology():
 
         """
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.BVH import BVH
         
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.AddApertures - Error: The input topology parameter is not a valid topology. Returning None.")
@@ -248,7 +249,23 @@ class Topology():
             d = Dictionary.SetValueAtKey(d, "type", "Aperture")
             aperture = Topology.SetDictionary(aperture, d)
         
-        topology = Topology.AddContent(topology, apertures, subTopologyType=subTopologyType, tolerance=tolerance)
+        if subTopologyType == "self":
+            topology = Topology.AddContent(topology, apertures, subTopologyType=subTopologyType, tolerance=tolerance)
+            return topology
+        else:
+            bvh = BVH.ByTopologies(Topology.SubTopologies(topology, subTopologyType=subTopologyType), silent=True)
+            used = []
+            for aperture in apertures:
+                result = BVH.Clashes(bvh, aperture)
+                if isinstance(result, list):
+                    if len(result) > 0:
+                        subTopology = result[0]
+                        if Topology.IsInstance(subTopology, "topology"):
+                            used.append(subTopology)
+                            if exclusive == True:
+                                if subTopology in used:
+                                    continue
+                            subTopology = Topology.AddContent(subTopology, [aperture], subTopologyType="self", tolerance=tolerance)
         return topology
     
     @staticmethod
@@ -273,6 +290,9 @@ class Topology():
             The input topology with the contents added to it.
 
         """
+
+        from topologicpy.Context import Context
+
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.AddContent - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
@@ -292,10 +312,14 @@ class Topology():
             print("Topology.AddContent - Error: the input subtopology type parameter is not a recognized type. Returning None.")
             return None
         if subTopologyType.lower() == "self":
-            t = 0
+            context = Context.ByTopologyParameters(topology)
+            for content in contents:
+                content.AddContext(context) # Hook to Core
+                topology.AddContent(content) # Hook to Core
         else:
             t = Topology.TypeID(subTopologyType)
-        return topology.AddContents(contents, t)
+            topology.AddContents(contents, t) # Hook to Core
+        return topology
     
     @staticmethod
     def AddDictionary(topology, dictionary):
@@ -886,7 +910,7 @@ class Topology():
                     for i, eb in enumerate(eb_list):
                         v = Topology.Vertices(eb)[0]
                         if found == False:
-                            if Vertex.IsInternal(v, topologyA_wire) or Vertex.IsInternal(v, topologyB_wire):
+                            if Vertex.IsInternal(v, topologyA_wire, tolerance=tolerance) or Vertex.IsInternal(v, topologyB_wire, tolerance=tolerance):
                                 external_boundary = eb
                                 found = True
                         else:
@@ -2390,7 +2414,7 @@ class Topology():
         return topology
     '''
     @staticmethod
-    def ByJSONFile(file, tolerance=0.0001):
+    def ByJSONFile(file, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON file.
 
@@ -2400,6 +2424,8 @@ class Topology():
             The input JSON file.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -2407,14 +2433,21 @@ class Topology():
             The list of imported topologies (Warning: the list could contain 0, 1, or many topologies, but this method will always return a list)
 
         """
+        import json
         if not file:
-            print("Topology.ByJSONFile - Error: the input file parameter is not a valid file. Returning None.")
+            if not silent:
+                print("Topology.ByJSONFile - Error: the input file parameter is not a valid file. Returning None.")
+            return None
+        try:
+            json_dict = json.load(file)
+        except Exception as e:
+            if not silent:
+                print("Topology.ByJSONFile - Error: Could not load the JSON file: {e}. Returning None.")
             return None
-        json_dict = json.load(file)
-        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
+        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def ByJSONPath(path, tolerance=0.0001):
+    def ByJSONPath(path, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON file.
 
@@ -2424,6 +2457,8 @@ class Topology():
             The file path to the json file.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -2433,15 +2468,20 @@ class Topology():
         """
         import json
         if not path:
-            print("Topology.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
+            if not silent:
+                print("Topology.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
             return None
-        with open(path) as file:
-            json_dict = json.load(file)
-        entities = Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
-        return entities
+        try:
+            with open(path) as file:
+                json_dict = json.load(file)
+        except Exception as e:
+            if not silent:
+                print("Topology.ByJSONPath - Error: Could not load file: {e}. Returning None.")
+            return None
+        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def ByJSONDictionary(jsonDictionary, tolerance=0.0001):
+    def ByJSONDictionary(jsonDictionary: dict, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON dictionary.
 
@@ -2451,6 +2491,8 @@ class Topology():
             The input JSON dictionary.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -2489,41 +2531,41 @@ class Topology():
             # Create basic topological entities
             if entity_type == 'Vertex':
                 parent_entity = Vertex.ByCoordinates(*entity['coordinates'])
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 vertices[entity['uuid']] = parent_entity
 
             elif entity_type == 'Edge':
                 vertex1 = vertices[entity['vertices'][0]]
                 vertex2 = vertices[entity['vertices'][1]]
-                parent_entity = Edge.ByVertices([vertex1, vertex2])
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Edge.ByVertices([vertex1, vertex2], tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 edges[entity['uuid']] = parent_entity
 
             elif entity_type == 'Wire':
                 wire_edges = [edges[uuid] for uuid in entity['edges']]
-                parent_entity = Wire.ByEdges(wire_edges)
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Wire.ByEdges(wire_edges, tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 wires[entity['uuid']] = parent_entity
 
             elif entity_type == 'Face':
                 face_wires = [wires[uuid] for uuid in entity['wires']]
                 if len(face_wires) > 1:
-                    parent_entity = Face.ByWires(face_wires[0], face_wires[1:])
+                    parent_entity = Face.ByWires(face_wires[0], face_wires[1:], tolerance=tolerance, silent=silent)
                 else:
-                    parent_entity = Face.ByWire(face_wires[0])
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                    parent_entity = Face.ByWire(face_wires[0], tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 faces[entity['uuid']] = parent_entity
 
             elif entity_type == 'Shell':
                 shell_faces = [faces[uuid] for uuid in entity['faces']]
-                parent_entity = Shell.ByFaces(shell_faces)
-                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                parent_entity = Shell.ByFaces(shell_faces, tolerance=tolerance, silent=silent)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict, silent=silent)
                 shells[entity['uuid']] = parent_entity
 
             elif entity_type == 'Cell':
                 cell_shells = [shells[uuid] for uuid in entity['shells']]
                 if len(cell_shells) > 1:
-                    parent_entity = Cell.ByShells(cell_shells[0], cell_shells[1:])
+                    parent_entity = Cell.ByShells(cell_shells[0], cell_shells[1:], tolerance=tolerance, silent=silent)
                 else:
                     parent_entity = Cell.ByShell(cell_shells[0])
                 parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
@@ -2649,7 +2691,7 @@ class Topology():
         return top_level_list
     
     @staticmethod
-    def ByJSONString(string, tolerance=0.0001):
+    def ByJSONString(string: str, tolerance: float = 0.0001, silent: bool = False):
         """
         Imports the topology from a JSON string.
 
@@ -2659,6 +2701,8 @@ class Topology():
             The input JSON string.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -2666,9 +2710,17 @@ class Topology():
             The list of imported topologies (Warning: the list could contain 0, 1, or many topologies, but this method will always return a list)
 
         """
-
-        json_dict = json.loads(string)
-        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
+        import inspect
+        try:
+            json_dict = json.loads(string)
+        except Exception as e:
+            if not silent:
+                print(f"Topology.ByJSONString - Error: Could not read the input string: {e}. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None 
+        return Topology.ByJSONDictionary(json_dict, tolerance=tolerance, silent=silent)
 
     @staticmethod
     def ByMeshData(dictionary, transferDictionaries: bool = False, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
@@ -3971,7 +4023,7 @@ class Topology():
             print("Topology.Contents - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
         contents = []
-        _ = topology.Contents(contents)
+        _ = topology.Contents(contents) # Hook to Core
         return contents
     
     @staticmethod
@@ -3994,7 +4046,7 @@ class Topology():
             print("Topology.Contexts - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
         contexts = []
-        _ = topology.Contexts(contexts)
+        _ = topology.Contexts(contexts) # Hook to Core
         return contexts
 
     @staticmethod
@@ -9710,45 +9762,9 @@ class Topology():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Dictionary import Dictionary
         from topologicpy.Cluster import Cluster
-        from topologicpy.Plotly import Plotly
-
-
-        def transfer_dictionaries_by_selectors(object, selectors, tranVertices=False, tranEdges=False, tranFaces=False, tranCells=False, tolerance=0.0001):
-            if tranVertices == True:
-                vertices = Topology.Vertices(object)
-                for vertex in vertices:
-                    for selector in selectors:
-                        d = Vertex.Distance(selector, vertex)
-                        if d <= tolerance:
-                            vertex = Topology.SetDictionary(vertex, Topology.Dictionary(selector), silent=True)
-                            break
-            if tranEdges == True:
-                edges = Topology.Edges(object)
-                for selector in selectors:
-                    for edge in edges:
-                        d = Vertex.Distance(selector, edge)
-                        if d <= tolerance:
-
-                            edge = Topology.SetDictionary(edge, Topology.Dictionary(selector), silent=True)
-                            break
-            if tranFaces == True:
-                faces = Topology.Faces(object)
-                for face in faces:
-                    for selector in selectors:
-                        d = Vertex.Distance(selector, face)
-                        if d <= tolerance:
-                            face = Topology.SetDictionary(face, Topology.Dictionary(selector), silent=True)
-                            break
-            if tranCells == True:
-                cells = Topology.Cells(object)
-                for cell in cells:
-                    for selector in selectors:
-                        if Vertex.IsInternal(selector, cell):
-                            cell = Topology.SetDictionary(cell, Topology.Dictionary(selector), silent=True)
-                            break
-            return object
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.BVH import BVH
         
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.TransferDictionariesBySelectors - Error: The input topology parameter is not a valid topology. Returning None.")
@@ -9756,51 +9772,65 @@ class Topology():
         if not isinstance(selectors, list):
             print("Topology.TransferDictionariesBySelectors - Error: The input selectors parameter is not a valid list. Returning None.")
             return None
-        if numWorkers == None:
-            import multiprocessing
-            numWorkers = multiprocessing.cpu_count()*2
         selectors_tmp = [x for x in selectors if Topology.IsInstance(x, "Vertex")]
         if len(selectors_tmp) < 1:
             print("Topology.TransferDictionariesBySelectors - Error: The input selectors do not contain any valid topologies. Returning None.")
             return None
         
-        if numWorkers == 1:
-            return transfer_dictionaries_by_selectors(topology, selectors, tranVertices=tranVertices, tranEdges=tranEdges, tranFaces=tranFaces, tranCells=tranCells, tolerance=tolerance)
-        sinkEdges = []
-        sinkFaces = []
-        sinkCells = []
-        hidimSink = Topology.HighestType(topology)
-        if tranVertices == True:
-            sinkVertices = []
-            if Topology.Type(topology) == Topology.TypeID("Vertex"):
-                sinkVertices.append(topology)
-            elif hidimSink >= Topology.TypeID("Vertex"):
-                sinkVertices = Topology.Vertices(topology)
-            _ = Topology.TransferDictionaries(selectors, sinkVertices, tolerance=tolerance, numWorkers=numWorkers)
-        if tranEdges == True:
-            sinkEdges = []
-            if Topology.Type(topology) == Topology.TypeID("Edge"):
-                sinkEdges.append(topology)
-            elif hidimSink >= Topology.TypeID("Edge"):
-                topology.Edges(None, sinkEdges)
-                _ = Topology.TransferDictionaries(selectors, sinkEdges, tolerance=tolerance, numWorkers=numWorkers)
-        if tranFaces == True:
-            sinkFaces = []
-            if Topology.Type(topology) == Topology.TypeID("Face"):
-                sinkFaces.append(topology)
-            elif hidimSink >= Topology.TypeID("Face"):
-                topology.Faces(None, sinkFaces)
-            _ = Topology.TransferDictionaries(selectors, sinkFaces, tolerance=tolerance, numWorkers=numWorkers)
-        if tranCells == True:
-            sinkCells = []
-            if Topology.IsInstance(topology, "Cell"):
-                sinkCells = [topology]
-            elif hidimSink >= Topology.TypeID("Cell"):
-                sinkCells = Topology.Cells(topology)
-            _ = Topology.TransferDictionaries(selectors, sinkCells, tolerance=tolerance, numWorkers=numWorkers)
+        
+        # --------------------------
+        # Collect primitives
+        # --------------------------
+        def collect_cells(topo):
+            if Topology.IsInstance(topo, "cell"):
+                return [topo]
+            else:
+                return Topology.Cells(topo)
+
+        def collect_faces(topo):
+            if Topology.IsInstance(topo, "face"):
+                return [topo]
+            else:
+                return Topology.Faces(topo)
+
+        def collect_edges(topo):
+            if Topology.IsInstance(topo, "edge"):
+                return [topo]
+            else:
+                return Topology.Edges(topo)
+        def collect_vertices(topo):
+            if Topology.IsInstance(topo, "vertex"):
+                return [topo]
+            else:
+                return Topology.Vertices(topo)
+
+        vertices = []
+        edges = []
+        faces = []
+        cells = []
+        if tranVertices:
+            vertices = collect_vertices(topology)
+        if tranEdges:
+            edges = collect_edges(topology)
+        if tranFaces:
+            faces = collect_faces(topology)
+        if tranCells:
+            cells = collect_cells(topology)
+        primitives = []
+        primitives.extend(cells)
+        primitives.extend(faces)
+        primitives.extend(edges)
+        primitives.extend(vertices)
+        cluster = Cluster.ByTopologies(primitives)
+        for s in selectors:
+            status, element = Vertex.IsInternal(s, cluster, identify=True, tolerance=tolerance)
+            if status:
+                d1 = Topology.Dictionary(s)
+                d2 = Topology.Dictionary(element)
+                d3 = Dictionary.ByMergedDictionaries(d1, d2)
+                element = Topology.SetDictionary(element, d3)
         return topology
 
-    
     @staticmethod
     def Transform(topology, matrix: list, silent: bool = False):
         """