topologicpy 0.8.61__py3-none-any.whl → 0.8.72__py3-none-any.whl

topologicpy/Dictionary.py

@@ -885,7 +885,10 @@ class Dictionary():
             temp_value = attr.StringValue()
             topologies = None
             try:
-                topologies = Topology.ByJSONString(temp_value)
+                if is_json_string(temp_value):
+                    topologies = Topology.ByJSONString(temp_value)
+                else:
+                    topologies = None
             except:
                 topologies = None
             if isinstance(topologies, list):
@@ -910,13 +913,21 @@ class Dictionary():
         elif isinstance(attr, float) or isinstance(attr, int):
             return attr
         elif isinstance(attr, str):
-            topologies = Topology.ByJSONString(attr)
             if attr == "__NONE__":
                 return None
-            elif len(topologies) > 1:
-                return topologies
-            elif len(topologies) == 1:
-                return topologies[0]
+            topologies = None
+            try:
+                if is_json_string(attr):
+                    topologies = Topology.ByJSONString(attr)
+                else:
+                    topologies = None
+            except:
+                topologies = None
+            if isinstance(topologies, list):
+                if len(topologies) > 1:
+                    return topologies
+                elif len(topologies) == 1:
+                    return topologies[0]
             elif is_json_string(attr):
                 return json_to_dict(attr)
             else:

topologicpy/Face.py

@@ -870,12 +870,14 @@ class Face():
                 print('caller name:', calframe[1][3])
             return None
         if not Wire.IsClosed(wire):
-            if not silent:
-                print("Face.ByWire - Error: The input wire parameter is not a closed topologic wire. Returning None.")
-                curframe = inspect.currentframe()
-                calframe = inspect.getouterframes(curframe, 2)
-                print('caller name:', calframe[1][3])
-            return None
+            wire = Wire.Close(wire, tolerance=tolerance)
+            if not Wire.IsClosed(wire):
+                if not silent:
+                    print("Face.ByWire - Error: The input wire parameter is not a closed topologic wire. Returning None.")
+                    curframe = inspect.currentframe()
+                    calframe = inspect.getouterframes(curframe, 2)
+                    print('caller name:', calframe[1][3])
+                return None
         
         edges = Wire.Edges(wire)
         wire = Topology.SelfMerge(Cluster.ByTopologies(edges), tolerance=tolerance)
@@ -1882,53 +1884,24 @@ class Face():
             The created vertex.
 
         """
-        def get_uv_radially():
-            """
-            Generate the points of a grid with a given size n, sorted radially from the center to the periphery.
-            n should be an odd number, ensuring that there's a center point (0, 0).
-            
-            Args:
-                n (int): The size of the grid. It should be odd for a clear center point.
-                
-            Returns:
-                list: A list of tuples (x, y) sorted by radial distance from the center (0, 0).
-            """
-            import math
-
-            points = []
-            n = 100
-            # Iterate over the grid, ranging from -n//2 to n//2
-            for x in range(-n//2, n//2 + 1):
-                for y in range(-n//2, n//2 + 1):
-                    points.append((x, y))
-            
-            # Sort points by their Euclidean distance from the center (0, 0)
-            points.sort(key=lambda point: math.sqrt(point[0]**2 + point[1]**2))
-            return_points = []
-            for p in points:
-                new_p = ((p[0]+50)*0.01, (p[1]+50)*0.01)
-                return_points.append(new_p)
-            return return_points
-        
         from topologicpy.Vertex import Vertex
+        from topologicpy.Shell import Shell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.BVH import BVH
         from topologicpy.Topology import Topology
 
-        if not Topology.IsInstance(face, "Face"):
-            return None
-        vert = Topology.Centroid(face)
-        if Vertex.IsInternal(vert, face, tolerance=tolerance):
-            return vert
-        uv_list = get_uv_radially()
-        for uv in uv_list:
-            u, v = uv
-            vert = Face.VertexByParameters(face, u, v)
-            if Vertex.IsInternal(vert, face, tolerance=tolerance):
-                return vert
-        if not silent:
-            print("Face.InternalVertex - Warning: Could not find an internal vertex. Returning the first vertex of the face.")
-        vert = Topology.Vertices(face)[0]
-        #v = topologic.FaceUtility.InternalVertex(face, tolerance) # Hook to Core
-        return vert
+        centroid = Topology.Centroid(face)
+        if Vertex.IsInternal(centroid, face):
+            return centroid
+
+        shell = Topology.Triangulate(face)
+        ib = Shell.InternalBoundaries(shell)
+        cluster = Cluster.ByTopologies(ib)
+        edges = Topology.Edges(cluster)
+        bvh = BVH.ByTopologies(edges, tolerance=tolerance, silent=True)
+        nearest_edge = BVH.Nearest(bvh, centroid)
+        return Topology.Centroid(nearest_edge)
+
 
     @staticmethod
     def Invert(face, tolerance: float = 0.0001, 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

@@ -224,8 +224,17 @@ class Topology():
             The input topology with the apertures added to it.
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.BVH import BVH
         
+        def best_candidate(aperture, candidates, tolerance=0.0001):
+            ap_iv = Topology.InternalVertex(aperture)
+            for candidate in candidates:
+                if Vertex.IsInternal(ap_iv, candidate, tolerance=tolerance):
+                    return candidate
+            return None
+
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.AddApertures - Error: The input topology parameter is not a valid topology. Returning None.")
             return None
@@ -248,7 +257,27 @@ 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:
+                candidates = BVH.Clashes(bvh, aperture)
+                if isinstance(candidates, list):
+                    if len(candidates) == 0:
+                        return topology
+                    elif len(candidates) == 1:
+                        subTopology = candidates[0]
+                    if len(candidates) > 0:
+                        subTopology = best_candidate(aperture, candidates, tolerance=tolerance)
+                    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 +302,11 @@ class Topology():
             The input topology with the contents added to it.
 
         """
+
+        from topologicpy.Context import Context
+        from topologicpy.Dictionary import Dictionary
+
+
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.AddContent - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
@@ -291,11 +325,21 @@ class Topology():
         if not subTopologyType.lower() in ["self", "cellcomplex", "cell", "shell", "face", "wire", "edge", "vertex"]:
             print("Topology.AddContent - Error: the input subtopology type parameter is not a recognized type. Returning None.")
             return None
+        
+        copy_contents = [Topology.Copy(x) for x in contents]
+        for i, content in enumerate(contents):
+            d = Topology.Dictionary(content)
+            copy_contents[i] = Topology.SetDictionary(copy_contents[i], d)
+
         if subTopologyType.lower() == "self":
-            t = 0
+            context = Context.ByTopologyParameters(topology)
+            for content in copy_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(copy_contents, t) # Hook to Core
+        return topology
     
     @staticmethod
     def AddDictionary(topology, dictionary):
@@ -886,7 +930,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:
@@ -2686,11 +2730,15 @@ 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 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)
 
@@ -3995,7 +4043,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
@@ -4018,7 +4066,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
@@ -9734,45 +9782,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.")
@@ -9780,51 +9792,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):
         """