topologicpy 0.4.95__py3-none-any.whl → 0.4.97__py3-none-any.whl

topologicpy/Graph.py

@@ -359,7 +359,11 @@ class Graph:
             new_vertices.append(nv)
         new_edge = Edge.ByVertices([new_vertices[0], new_vertices[1]], tolerance=tolerance)
         if transferEdgeDictionaries == True:
-            _ = Topology.SetDictionary(new_edge, Topology.Dictionary(edge))
+            d = Topology.Dictionary(edge)
+            keys = Dictionary.Keys(d)
+            if isinstance(keys, list):
+                if len(keys) > 0:
+                    _ = Topology.SetDictionary(new_edge, d)
         graph_edges.append(new_edge)
         new_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
         return new_graph
@@ -2303,7 +2307,7 @@ class Graph:
             return [vertices, edges]
 
         def processFace(item):
-            from topologic.Face import Face
+            from topologicpy.Face import Face
             topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBRep, tolerance = item
             graph = None
             vertices = []
@@ -3003,27 +3007,91 @@ class Graph:
         return topologic.Graph.ByVerticesEdges(vertices, edges)
     
     @staticmethod
-    def Color(graph, vertices=None, key="color", delta=1, tolerance=0.0001):
+    def ChromaticNumber(graph: topologic.Graph, maxColors: int = 3, silent: bool = False):
         """
-        Colors the input vertices within the input graph. The saved value is an integer rather than an actual color. See Color.ByValueInRange to convert to an actual color. Any vertices that have been pre-colored will not be affected. See https://en.wikipedia.org/wiki/Graph_coloring.
+        Returns the chromatic number of the input graph. See https://en.wikipedia.org/wiki/Graph_coloring.
 
         Parameters
         ----------
         graph : topologic.Graph
             The input graph.
-        vertices : list , optional
-            The input list of graph vertices. If no vertices are specified, all vertices in the input graph are colored. The default is None.
-        key : str , optional
-            The dictionary key to use to save the color information.
-        delta : int , optional
-            The desired minimum delta value between the assigned colors.
+        maxColors : int , optional
+            The desired maximum number of colors to test against. The default is 3.
+        silent : bool , optional
+            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+        
+        Returns
+        -------
+        int
+            The chromatic number of the input graph.
+
+        """
+        # This is based on code from https://www.geeksforgeeks.org/graph-coloring-applications/
+        
+        def is_safe(graph, v, color, c):
+            for i in range(len(graph)):
+                if graph[v][i] == 1 and color[i] == c:
+                    return False
+            return True
+
+        def graph_coloring(graph, m, color, v):
+            V = len(graph)
+            if v == V:
+                return True
+
+            for c in range(1, m + 1):
+                if is_safe(graph, v, color, c):
+                    color[v] = c
+                    if graph_coloring(graph, m, color, v + 1):
+                        return True
+                    color[v] = 0
+
+            return False
+
+        def chromatic_number(graph):
+            V = len(graph)
+            color = [0] * V
+            m = 1
+
+            while True:
+                if graph_coloring(graph, m, color, 0):
+                    return m
+                m += 1
+        
+        if not isinstance(graph, topologic.Graph):
+            if not silent:
+                print("Graph.ChromaticNumber - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        if maxColors < 1:
+            if not silent:
+                print("Graph.ChromaticNumber - Error: The input maxColors parameter is not a valid positive number. Returning None.")
+            return None
+        adj_matrix = Graph.AdjacencyMatrix(graph)
+        return chromatic_number(adj_matrix)
+
+    @staticmethod
+    def Color(graph, oldKey: str = "color", newKey: str = "color", maxColors: int = None, tolerance: float = 0.0001):
+        """
+        Colors the input vertices within the input graph. The saved value is an integer rather than an actual color. See Color.ByValueInRange to convert to an actual color.
+        Any vertices that have been pre-colored will not be affected. See https://en.wikipedia.org/wiki/Graph_coloring.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        oldKey : str , optional
+            The existing dictionary key to use to read any pre-existing color information. The default is "color".
+        newKey : str , optional
+            The new dictionary key to use to write out new color information. The default is "color".
+        maxColors : int , optional
+            The desired maximum number of colors to use. If set to None, the chromatic number of the graph is used. The default is None.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
         Returns
         -------
-        list
-            The colored list of vertices.
+        topologic.Graph
+            The input graph, but with its vertices colored.
 
         """
         from topologicpy.Vertex import Vertex
@@ -3032,76 +3100,171 @@ class Graph:
         from topologicpy.Topology import Topology
         import math
 
-        delta = max(abs(delta), 1) # Ensure that delta is never less than 1
+        def is_safe(v, graph, colors, c):
+            # Check if the color 'c' is safe for the vertex 'v'
+            for i in range(len(graph)):
+                if graph[v][i] and c == colors[i]:
+                    return False
+            return True
 
-        def satisfiesCondition(i, used_colors, delta):
-            if delta == 1:
-                return i not in used_colors
-            else:
-                for j in used_colors:
-                    if abs(j-i) < delta:
-                        return False
+        def graph_coloring_util(graph, m, colors, v):
+            # Base case: If all vertices are assigned a color, return true
+            if v == len(graph):
                 return True
-        def color_graph(graph, vertices, key, delta):
-            # Create a dictionary to store the colors of each vertex
-            colors = {}                
-            # Iterate over each vertex in the graph
-            for j, vertex in enumerate(vertices):
-                d = Topology.Dictionary(vertex)
-                color_value = Dictionary.ValueAtKey(d, key)
-                if color_value != None:
-                    colors[j] = color_value
-                # Initialize an empty set of used colors
-                used_colors = set()
-
-                # Iterate over each neighbor of the vertex
-                for neighbor in Graph.AdjacentVertices(graph, vertex):
-                    # If the neighbor has already been colored, add its color to the used colors set
-                    index = Vertex.Index(neighbor, vertices)
-                    if index in colors:
-                        used_colors.add(colors[index])
-
-                if color_value == None:
-                    # Choose the smallest unused color for the vertex
-                    for i in range(0,int(math.ceil(len(vertices)*int(math.ceil(delta)))), int(math.ceil(delta))):
-                        #if i not in used_colors:
-                        if satisfiesCondition(i, used_colors, int(math.ceil(delta))):
-                            v_d = Topology.Dictionary(vertex)
-                            if not v_d == None:
-                                keys = Dictionary.Keys(v_d)
-                                values = Dictionary.Values(v_d)
-                            else:
-                                keys = []
-                                values = []
-                            if len(keys) > 0:
-                                keys.append(key)
-                                values.append(i)
-                            else:
-                                keys = [key]
-                                values = [i]
-                            d = Dictionary.ByKeysValues(keys, values)
-                            vertex = Topology.SetDictionary(vertex, d)
-                            colors[j] = i
-                            break
 
-            return colors
+            # Try different colors for the current vertex 'v'
+            for c in range(1, m + 1):
+                # Check if assignment of color 'c' to 'v' is fine
+                if is_safe(v, graph, colors, c):
+                    colors[v] = c
+
+                    # Recur to assign colors to the rest of the vertices
+                    if graph_coloring_util(graph, m, colors, v + 1):
+                        return True
+
+                    # If assigning color 'c' doesn't lead to a solution, remove it
+                    colors[v] = 0
+
+            # If no color can be assigned to this vertex, return false
+            return False
+
+        def graph_coloring(graph, m, colors):
+
+            # Call graph_coloring_util() for vertex 0
+            if not graph_coloring_util(graph, m, colors, 0):
+                return None
+            return [x-1 for x in colors]
 
         if not isinstance(graph, topologic.Graph):
             print("Graph.Color - Error: The input graph is not a valid graph. Returning None.")
             return None
-        if vertices == None:
-            vertices = Graph.Vertices(graph)
-        vertices = [v for v in vertices if isinstance(v, topologic.Vertex)]
-        if len(vertices) == 0:
-            print("Graph.Color - Error: The input list of vertices does not contain any valid vertices. Returning None.")
-            return None
-        graph_vertices = [Graph.NearestVertex(graph,v) for v in vertices]
-        degrees = [Graph.VertexDegree(graph, v) for v in graph_vertices]
-        graph_vertices = Helper.Sort(graph_vertices, degrees)
-        graph_vertices.reverse()
-        _ = color_graph(graph, graph_vertices, key, delta)
-        return graph_vertices
+        
+        vertices = Graph.Vertices(graph)
+        adj_mat = Graph.AdjacencyMatrix(graph)
+        # Isolate vertices that have pre-existing colors as they shouldn't affect graph coloring.
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            c = Dictionary.ValueAtKey(d, oldKey)
+            if not c == None:
+                adj_mat[i] = [0] * len(vertices)
+                for j in range(len(adj_mat)):
+                    row = adj_mat[j]
+                    row[i] = 0
+        temp_graph = Graph.ByAdjacencyMatrix(adj_mat)
+        # If the maximum number of colors are not provided, compute it using the graph's chromatic number.
+        if maxColors == None:
+            maxColors = Graph.ChromaticNumber(temp_graph)
+        print("MaxColors:", maxColors)
+        colors = [0] * len(vertices)
+        colors = graph_coloring(adj_mat, maxColors, colors)
+        print("Colors:", colors)
+        for i, v in enumerate(vertices):
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, newKey, colors[i])
+                v = Topology.SetDictionary(v,d)
+        return graph
+    
+    @staticmethod
+    def ContractEdge(graph, edge, vertex=None, tolerance=0.0001):
+        """
+        Contracts the input edge in the input graph into a single vertex. Please note that the dictionary of the edge is transferred to the
+        vertex that replaces it. See https://en.wikipedia.org/wiki/Edge_contraction
 
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        edge : topologic.Edge
+            The input graph edge that needs to be contracted.
+        vertex : topollogic.Vertex , optional
+            The vertex to replace the contracted edge. If set to None, the centroid of the edge is chosen. The default is None.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic.Graph
+            The input graph, but with input edge contracted into a single vertex.
+
+        """
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        def OppositeVertex(edge, vertex, tolerance=0.0001):
+            sv = Edge.StartVertex(edge)
+            ev = Edge.EndVertex(edge)
+            d1 = Vertex.Distance(vertex, sv)
+            d2 = Vertex.Distance(vertex, ev)
+            if d1 < d2:
+                return [ev,1]
+            return [sv,0]
+        if not isinstance(graph, topologic.Graph):
+            print("Graph.ContractEdge - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        if not isinstance(edge, topologic.Edge):
+            print("Graph.ContractEdge - Error: The input edge parameter is not a valid edge. Returning None.")
+            return None
+        if vertex == None:
+            vertex = Topology.Centroid(edge)
+        sv = Edge.StartVertex(edge)
+        ev = Edge.EndVertex(edge)
+        vd = Topology.Dictionary(vertex)
+        sd = Topology.Dictionary(sv)
+        dictionaries = []
+        keys = Dictionary.Keys(vd)
+        if isinstance(keys, list):
+            if len(keys) > 0:
+                dictionaries.append(vd)
+        keys = Dictionary.Keys(sd)
+        if isinstance(keys, list):
+            if len(keys) > 0:
+                dictionaries.append(sd)
+        ed = Topology.Dictionary(ev)
+        keys = Dictionary.Keys(ed)
+        if isinstance(keys, list):
+            if len(keys) > 0:
+                dictionaries.append(ed)
+        if len(dictionaries) == 1:
+            vertex = Topology.SetDictionary(vertex, dictionaries[0])
+        elif len(dictionaries) > 1:
+            cd = Dictionary.ByMergedDictionaries(dictionaries)
+            vertex = Topology.SetDictionary(vertex, cd)
+        graph = Graph.RemoveEdge(graph, edge, tolerance=tolerance)
+        graph = Graph.AddVertex(graph, vertex, tolerance=tolerance)
+        adj_edges_sv = Graph.Edges(graph, [sv])
+        adj_edges_ev = Graph.Edges(graph, [ev])
+        new_edges = []
+        for adj_edge_sv in adj_edges_sv:
+            ov, flag = OppositeVertex(adj_edge_sv, sv)
+            if flag == 0:
+                new_edge = Edge.ByVertices([ov, vertex])
+            else:
+                new_edge = Edge.ByVertices([vertex, ov])
+            d = Topology.Dictionary(adj_edge_sv)
+            keys = Dictionary.Keys(d)
+            if isinstance(keys, list):
+                if len(keys) > 0:
+                    new_edge = Topology.SetDictionary(new_edge, d)
+            new_edges.append(new_edge)
+        for adj_edge_ev in adj_edges_ev:
+            ov, flag = OppositeVertex(adj_edge_ev, ev)
+            if flag == 0:
+                new_edge = Edge.ByVertices([ov, vertex])
+            else:
+                new_edge = Edge.ByVertices([vertex, ov])
+            d = Topology.Dictionary(adj_edge_ev)
+            keys = Dictionary.Keys(d)
+            if isinstance(keys, list):
+                if len(keys) > 0:
+                    new_edge = Topology.SetDictionary(new_edge, d)
+            new_edges.append(new_edge)
+        for new_edge in new_edges:
+            graph = Graph.AddEdge(graph, new_edge, transferVertexDictionaries=True, transferEdgeDictionaries=True, tolerance=tolerance)
+        graph = Graph.RemoveVertex(graph,sv, tolerance=tolerance)
+        graph = Graph.RemoveVertex(graph,ev, tolerance=tolerance)
+        return graph
+    
     @staticmethod
     def ClosenessCentrality(graph, vertices=None, tolerance = 0.0001):
         """

topologicpy/Shell.py

@@ -146,7 +146,7 @@ class Shell(Topology):
                 iv = Topology.InternalVertex(w1, tolerance=tolerance)
                 flag = False
                 for w2 in faces:
-                    if Face.IsInternal(w2, iv):
+                    if Vertex.IsInternal(iv, w2):
                         flag = True
                         break;
                 if flag == False:
@@ -285,7 +285,7 @@ class Shell(Topology):
             return None
         shell = topologic.Shell.ByFaces(faceList, tolerance)
         if not isinstance(shell, topologic.Shell):
-            shell = Topology.SelfMerge(shell)
+            shell = Topology.SelfMerge(shell, tolerance=tolerance)
             if isinstance(shell, topologic.Shell):
                 return shell
             else:
@@ -520,29 +520,17 @@ class Shell(Topology):
             flatFace = Topology.Flatten(face, origin=origin, direction=normal)
             faceVertices = Face.Vertices(face)
             vertices += faceVertices
-            # Retrieve the needed transformations
-            dictionary = Topology.Dictionary(flatFace)
-            xTran = Dictionary.ValueAtKey(dictionary,"x")
-            yTran = Dictionary.ValueAtKey(dictionary,"y")
-            zTran = Dictionary.ValueAtKey(dictionary,"z")
-            phi = Dictionary.ValueAtKey(dictionary,"phi")
-            theta = Dictionary.ValueAtKey(dictionary,"theta")
 
             # Create a cluster of the input vertices
             verticesCluster = Cluster.ByTopologies(vertices)
 
             # Flatten the cluster using the same transformations
-            verticesCluster = Topology.Translate(verticesCluster, -xTran, -yTran, -zTran)
-            verticesCluster = Topology.Rotate(verticesCluster, origin=world_origin, x=0, y=0, z=1, degree=-phi)
-            verticesCluster = Topology.Rotate(verticesCluster, origin=world_origin, x=0, y=1, z=0, degree=-theta)
+            verticesCluster = Topology.Flatten(verticesCluster, origin=origin, direction=normal)
 
             vertices = Cluster.Vertices(verticesCluster)
-        tempFlatVertices = []
         points = []
         for v in vertices:
-            tempFlatVertices.append(Vertex.ByCoordinates(Vertex.X(v), Vertex.Y(v), 0))
             points.append([Vertex.X(v), Vertex.Y(v)])
-        #flatVertices = tempFlatVertices
         delaunay = SCIDelaunay(points)
         simplices = delaunay.simplices
 
@@ -569,9 +557,7 @@ class Shell(Topology):
                 ibList = [Face.ByWire(w) for w in wires]
                 cluster = Cluster.ByTopologies(ibList)
                 shell = Topology.Difference(shell, cluster)
-            shell = Topology.Rotate(shell, origin=world_origin, x=0, y=1, z=0, degree=theta)
-            shell = Topology.Rotate(shell, origin=world_origin, x=0, y=0, z=1, degree=phi)
-            shell = Topology.Translate(shell, xTran, yTran, zTran)
+            shell = Topology.Unflatten(shell, origin=origin, direction=normal)
         return shell
 
     @staticmethod
@@ -652,47 +638,6 @@ class Shell(Topology):
         _ = shell.Faces(None, faces)
         return faces
     
-    @staticmethod
-    def IsInside(shell: topologic.Shell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
-        """
-        DEPRECATED METHOD. DO NOT USE. INSTEAD USE Shell.IsInternal.
-        """
-        print("Shell.IsInside - Warning: Deprecated method. This method will be removed in the future. Instead, use Cell.IsInternal.")
-        return Shell.IsInternal(shell=shell, vertex=vertex, tolerance=tolerance)
-    
-    @staticmethod
-        
-    def IsInternal(shell: topologic.Shell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
-        """
-        Returns True if the input vertex is an internal vertex of the input shell. Returns False otherwise. Intenral is defined as being inside one of the shell's faces.
-
-        Parameters
-        ----------
-        shell : topologic.Shell
-            The input shell.
-        vertex : topologic.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.Face import Face
-        if not isinstance(shell, topologic.Shell):
-            return None
-        if not isinstance(vertex, topologic.Vertex):
-            return None
-        faces = Shell.Faces(shell)
-        for f in faces:
-            if Face.IsInternal(face=f, vertex=vertex, tolerance=tolerance):
-                return True
-        return False
-    
     @staticmethod
     def IsOnBoundary(shell: topologic.Shell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
         """
@@ -714,47 +659,21 @@ class Shell(Topology):
 
         """
 
-        from topologicpy.Wire import Wire
+        from topologicpy.Vertex import Vertex
 
         if not isinstance(shell, topologic.Shell):
             return None
         if not isinstance(vertex, topologic.Vertex):
             return None
         boundary = Shell.ExternalBoundary(shell, tolerance=tolerance)
-        if Wire.IsInternal(wire=boundary, vertex=vertex, tolerance=tolerance):
+        if Vertex.IsInternal(vertex, boundary, tolerance=tolerance):
             return True
         internal_boundaries = Shell.InternalBoundaries(shell, tolerance=tolerance)
         for ib in internal_boundaries:
-            if Wire.IsInternal(wire=ib, vertex=vertex, tolerance=tolerance):
+            if Vertex.IsInternal(vertex, ib, tolerance=tolerance):
                 return True
         return False
     
-    @staticmethod
-    def IsOutside(shell: topologic.Shell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
-        """
-        Returns True if the input vertex is outside the input shell. Returns False otherwise. Outside is defined as being outside all of the shell's faces
-
-        Parameters
-        ----------
-        shell : topologic.Shell
-            The input shell.
-        vertex : topologic.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.
-
-        """
-        if not isinstance(shell, topologic.Shell):
-            return None
-        if not isinstance(vertex, topologic.Vertex):
-            return None
-        return not Shell.IsInternal(shell=shell, vertex=vertex, tolerance=tolerance)
-    
     @staticmethod
     def HyperbolicParaboloidRectangularDomain(origin: topologic.Vertex = None, llVertex: topologic.Vertex = None, lrVertex: topologic.Vertex =None, ulVertex: topologic.Vertex =None, urVertex: topologic.Vertex = None,
                                               uSides: int = 10, vSides: int = 10, direction: list = [0,0,1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Shell:
@@ -1372,13 +1291,13 @@ class Shell(Topology):
         origin = Topology.Centroid(face)
         normal = Face.Normal(face)
         flat_face = Topology.Flatten(face, origin=origin, direction=normal)
-        d = Topology.Dictionary(flat_face)
         roof = Wire.Roof(flat_face, degree=degree, tolerance=tolerance)
         if not roof:
             return None
         shell = Shell.Skeleton(flat_face, tolerance=tolerance)
+        print(shell)
         faces = Shell.Faces(shell)
-        
+        Topology.Show(shell)
         if not faces:
             return None
         triangles = []
@@ -1423,14 +1342,7 @@ class Shell(Topology):
             shell = Topology.RemoveCoplanarFaces(shell, epsilon=epsilon, tolerance=tolerance)
         except:
             pass
-        xTran = Dictionary.ValueAtKey(d,"x")
-        yTran = Dictionary.ValueAtKey(d,"y")
-        zTran = Dictionary.ValueAtKey(d,"z")
-        phi = Dictionary.ValueAtKey(d,"phi")
-        theta = Dictionary.ValueAtKey(d,"theta")
-        shell = Topology.Rotate(shell, origin=Vertex.Origin(), x=0, y=1, z=0, degree=theta)
-        shell = Topology.Rotate(shell, origin=Vertex.Origin(), x=0, y=0, z=1, degree=phi)
-        shell = Topology.Translate(shell, xTran, yTran, zTran)
+        #shell = Topology.Unflatten(shell, origin=origin, direction=normal)
         return shell
     
     @staticmethod
@@ -1689,7 +1601,7 @@ class Shell(Topology):
             faces = Topology.Faces(result)
             final_faces = []
             for face in faces:
-                if not Face.IsInternal(face, v, tolerance=0.01):
+                if not Vertex.IsInternal(v, face, tolerance=0.01):
                     final_faces.append(face)
             final_result = Shell.ByFaces(final_faces, tolerance=tolerance)
         return final_result
@@ -1759,26 +1671,25 @@ class Shell(Topology):
         origin = Topology.Centroid(face)
         normal = Face.Normal(face)
         flatFace = Topology.Flatten(face, origin=origin, direction=normal)
-        # Retrieve the needed transformations
-        dictionary = Topology.Dictionary(flatFace)
-        xTran = Dictionary.ValueAtKey(dictionary,"x")
-        yTran = Dictionary.ValueAtKey(dictionary,"y")
-        zTran = Dictionary.ValueAtKey(dictionary,"z")
-        phi = Dictionary.ValueAtKey(dictionary,"phi")
-        theta = Dictionary.ValueAtKey(dictionary,"theta")
-
-        # Create a Vertex at the world's origin (0,0,0)
-        world_origin = Vertex.ByCoordinates(0,0,0)
+        eb = Face.ExternalBoundary(flatFace)
+        ibList = Face.InternalBoundaries(flatFace)
+        temp_verts = Topology.Vertices(eb)
+        new_verts = [Vertex.ByCoordinates(Vertex.X(v), Vertex.Y(v), 0) for v in temp_verts]
+        eb = Wire.ByVertices(new_verts, close=True)
+        new_ibList = []
+        for ib in ibList:
+            temp_verts = Topology.Vertices(ib)
+            new_verts = [Vertex.ByCoordinates(Vertex.X(v), Vertex.Y(v), 0) for v in temp_verts]
+            new_ibList.append(Wire.ByVertices(new_verts, close=True))
+        flatFace = Face.ByWires(eb, new_ibList)
 
         # Create a cluster of the input vertices
         verticesCluster = Cluster.ByTopologies(vertices)
 
         # Flatten the cluster using the same transformations
-        verticesCluster = Topology.Translate(verticesCluster, -xTran, -yTran, -zTran)
-        verticesCluster = Topology.Rotate(verticesCluster, origin=world_origin, x=0, y=0, z=1, degree=-phi)
-        verticesCluster = Topology.Rotate(verticesCluster, origin=world_origin, x=0, y=1, z=0, degree=-theta)
-
-        flatVertices = Cluster.Vertices(verticesCluster)
+        verticesCluster = Topology.Flatten(verticesCluster, origin=origin, direction=normal)
+        flatVertices = Topology.Vertices(verticesCluster)
+        flatVertices = [Vertex.ByCoordinates(Vertex.X(v), Vertex.Y(v), 0) for v in flatVertices]
         points = []
         for flatVertex in flatVertices:
             points.append([flatVertex.X(), flatVertex.Y()])
@@ -1814,14 +1725,20 @@ class Shell(Topology):
             if len(region) > 1 and not -1 in region:
                 for v in region:
                     tempWire.append(Vertex.ByCoordinates(voronoiVertices[v].X(), voronoiVertices[v].Y(),0))
+                temp_verts = []
+                for v in tempWire:
+                    if len(temp_verts) == 0:
+                        temp_verts.append(v)
+                    elif Vertex.Index(v, temp_verts) == None:
+                        temp_verts.append(v)
+                tempWire = temp_verts
+                temp_w = Wire.ByVertices(tempWire, close=True)
                 faces.append(Face.ByWire(Wire.ByVertices(tempWire, close=True), tolerance=tolerance))
         shell = Shell.ByFaces(faces, tolerance=tolerance)
         edges = Shell.Edges(shell)
         edgesCluster = Cluster.ByTopologies(edges)
-        shell = Topology.Boolean(flatFace,edgesCluster, operation="slice", tolerance=tolerance)
-        shell = Topology.Rotate(shell, origin=world_origin, x=0, y=1, z=0, degree=theta)
-        shell = Topology.Rotate(shell, origin=world_origin, x=0, y=0, z=1, degree=phi)
-        shell = Topology.Translate(shell, xTran, yTran, zTran)
+        shell = Topology.Slice(flatFace,edgesCluster, tolerance=tolerance)
+        shell = Topology.Unflatten(shell, origin=origin, direction=normal)
         return shell
 
     @staticmethod