topologicpy 0.7.67__py3-none-any.whl → 0.7.69__py3-none-any.whl

topologicpy/Graph.py

@@ -575,7 +575,7 @@ class Graph:
             return graph
         graph_vertices = Graph.Vertices(graph)
         graph_edges = Graph.Edges(graph, graph_vertices, tolerance)
-        vertices = Edge.Vertices(edge)
+        vertices = Topology.Vertices(edge)
         new_vertices = []
         for vertex in vertices:
             graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance)
@@ -623,7 +623,7 @@ class Graph:
             if not silent:
                 print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning the input graph.")
             return graph
-        _ = graph.AddVertices([vertex], tolerance) # Hook to core library
+        _ = graph.AddVertices([vertex], tolerance) # Hook to Core
         return graph
 
     @staticmethod
@@ -663,7 +663,7 @@ class Graph:
             if not silent:
                 print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
             return None
-        _ = graph.AddVertices(vertices, tolerance) # Hook to core library
+        _ = graph.AddVertices(vertices, tolerance) # Hook to Core
         return graph
     
     @staticmethod
@@ -697,7 +697,7 @@ class Graph:
                 print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
             return None
         vertices = []
-        _ = graph.AdjacentVertices(vertex, vertices) # Hook to core library
+        _ = graph.AdjacentVertices(vertex, vertices) # Hook to Core
         return list(vertices)
     
     @staticmethod
@@ -739,7 +739,7 @@ class Graph:
                 print("Graph.AllPaths - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
         paths = []
-        _ = graph.AllPaths(vertexA, vertexB, True, timeLimit, paths) # Hook to core library
+        _ = graph.AllPaths(vertexA, vertexB, True, timeLimit, paths) # Hook to Core
         return paths
 
     @staticmethod
@@ -4039,7 +4039,7 @@ class Graph:
         if not len(verticesA) == len(verticesB):
             print("Graph.Connect - Error: The input lists verticesA and verticesB have different lengths. Returning None.")
             return None
-        _ = graph.Connect(verticesA, verticesB, tolerance) # Hook to core library
+        _ = graph.Connect(verticesA, verticesB, tolerance) # Hook to Core
         return graph
     
     @staticmethod
@@ -4179,7 +4179,7 @@ class Graph:
             print("Graph.DegreeSequence - Error: The input graph is not a valid graph. Returning None.")
             return None
         sequence = []
-        _ = graph.DegreeSequence(sequence) # Hook to core library
+        _ = graph.DegreeSequence(sequence) # Hook to Core
         return sequence
     
     @staticmethod
@@ -4493,7 +4493,7 @@ class Graph:
             return None
         if not vertices:
             edges = []
-            _ = graph.Edges(edges, tolerance) # Hook to core library
+            _ = graph.Edges(edges, tolerance) # Hook to Core
             return edges
         else:
             vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
@@ -4501,7 +4501,7 @@ class Graph:
             print("Graph.Edges - Error: The input list of vertices does not contain any valid vertices. Returning None.")
             return None
         edges = []
-        _ = graph.Edges(vertices, tolerance, edges) # Hook to core library
+        _ = graph.Edges(vertices, tolerance, edges) # Hook to Core
         return list(dict.fromkeys(edges)) # remove duplicates
     
     @staticmethod
@@ -5526,7 +5526,7 @@ class Graph:
         return False
     
     @staticmethod
-    def Flatten(graph, layout="spring", k=0.8, seed=None, iterations=50, rootVertex=None, tolerance=0.0001):
+    def Flatten(graph, layout="spring", k=0.8, seed=None, iterations=50, rootVertex=None, radius=0.5, tolerance=0.0001):
         """
         Flattens the input graph.
 
@@ -5536,8 +5536,9 @@ class Graph:
             The input graph.
         layout : str , optional
             The desired mode for flattening. If set to 'spring', the algorithm uses a simplified version of the Fruchterman-Reingold force-directed algorithm to flatten and distribute the vertices.
-            If set to 'radial', the nodes will be distributed along a circle.
-            If set to 'tree', the nodes will be distributed using the Reingold-Tillford layout. The default is 'spring'.
+            If set to 'radial', the nodes will be distributed along concentric circles.
+            If set to 'tree', the nodes will be distributed using the Reingold-Tillford layout.
+            If set to 'circle', the nodes will be distributed on the cirumference of a circle. The default is 'spring'.
         k : float, optional
             The desired spring constant to use for the attractive and repulsive forces. The default is 0.8.
         seed : int , optional
@@ -5546,6 +5547,8 @@ class Graph:
             The desired maximum number of iterations to solve the forces in the 'spring' mode. The default is 50.
         rootVertex : topologic_core.Vertex , optional
             The desired vertex to use as the root of the tree and radial layouts.
+        radius : float, optional
+            The desired radius for the circle layout option. The default is 0.5.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -5712,6 +5715,60 @@ class Graph:
                 old_roots = new_roots
             return root, num_nodes
 
+
+        def circle_layout(graph, radius=0.5):
+            from topologicpy.Vertex import Vertex
+            from topologicpy.Vector import Vector
+            from topologicpy.Wire import Wire
+            from topologicpy.Graph import Graph
+            from topologicpy.Edge import Edge
+
+            vertices = Graph.Vertices(graph)
+            edges = Graph.Edges(graph)
+            edge_dict = {}
+
+            for i, edge in enumerate(edges):
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                si = Vertex.Index(sv, vertices)
+                ei = Vertex.Index(ev, vertices)
+                edge_dict[str(si)+"_"+str(ei)] = i
+                edge_dict[str(ei)+"_"+str(si)] = i
+            
+            n = len(vertices)
+            c = Wire.Circle(radius=radius, sides=n)
+            c_vertices = Topology.Vertices(c)
+
+            for i, c_v in enumerate(c_vertices):
+                d = Topology.Dictionary(vertices[i])
+                c_v = Topology.SetDictionary(c_v, d)
+            adj_dict = Graph.AdjacencyDictionary(graph)
+            keys = adj_dict.keys()
+            c_edges = []
+            used = [[0] * n for _ in range(n)]
+            for key in keys:
+                x = int(key)
+                adj_vertices = [int(v) for v in adj_dict[key]]
+                for y in adj_vertices:
+                    if used[x][y] == 0:
+                        v1 = Vector.ByCoordinates(Vertex.X(c_vertices[x]), Vertex.Y(c_vertices[x]), Vertex.Z(c_vertices[x]))
+                        v2 = Vector.ByCoordinates(Vertex.X(c_vertices[y]), Vertex.Y(c_vertices[y]), Vertex.Z(c_vertices[y]))
+                        ang1 = Vector.CompassAngle(v1, [0,1,0])
+                        ang2 = Vector.CompassAngle(v2, [0,1,0])
+                        if ang2-ang1 < 180:
+                            e = Edge.ByVertices(c_vertices[x], c_vertices[y])
+                        else:
+                            e = Edge.ByVertices(c_vertices[y], c_vertices[x])
+                        
+                        orig_edge_index = edge_dict[str(x)+"_"+str(y)]
+                        d = Topology.Dictionary(edges[orig_edge_index])
+                        e = Topology.SetDictionary(e, d)
+                        c_edges.append(e)
+                        used[x][y] = 1
+                        used[y][x] = 1
+            new_g = Graph.ByVerticesEdges(c_vertices, c_edges)
+            return new_g
+        
         def spring_layout(edge_list, iterations=500, k=None, seed=None):
             # Compute the layout of a graph using the Fruchterman-Reingold algorithm
             # with a force-directed layout approach.
@@ -5850,6 +5907,10 @@ class Graph:
         if not Topology.IsInstance(graph, "Graph"):
             print("Graph.Flatten - Error: The input graph is not a valid topologic graph. Returning None.")
             return None
+        
+        if 'circ' in layout.lower():
+            new_graph = circle_layout(graph, radius=radius)
+            return new_graph
         d = Graph.MeshData(graph)
         vertices = d['vertices']
         edges = d['edges']
@@ -6180,7 +6241,7 @@ class Graph:
             print("Graph.IsolatedVertices - Error: The input graph is not a valid graph. Returning None.")
             return None
         vertices = []
-        _ = graph.IsolatedVertices(vertices) # Hook to core library
+        _ = graph.IsolatedVertices(vertices) # Hook to Core
         return vertices
 
     @staticmethod
@@ -7581,7 +7642,7 @@ class Graph:
         if not Topology.IsInstance(edge, "Edge"):
             print("Graph.RemoveEdge - Error: The input edge is not a valid edge. Returning None.")
             return None
-        _ = graph.RemoveEdges([edge], tolerance) # Hook to core library
+        _ = graph.RemoveEdges([edge], tolerance) # Hook to Core
         return graph
     
     @staticmethod
@@ -7613,7 +7674,7 @@ class Graph:
             print("Graph.RemoveVertex - Error: The input vertex is not a valid vertex. Returning None.")
             return None
         graphVertex = Graph.NearestVertex(graph, vertex)
-        _ = graph.RemoveVertices([graphVertex]) # Hook to core library
+        _ = graph.RemoveVertices([graphVertex]) # Hook to Core
         return graph
 
     @staticmethod
@@ -7648,7 +7709,7 @@ class Graph:
         if len(dictionary.Keys()) < 1:
             print("Graph.SetDictionary - Warning: the input dictionary parameter is empty. Returning original input.")
             return graph
-        _ = graph.SetDictionary(dictionary) # Hook to core library
+        _ = graph.SetDictionary(dictionary) # Hook to Core
         return graph
 
     @staticmethod
@@ -7784,6 +7845,7 @@ class Graph:
              sagitta = 0,
              absolute = False,
              sides = 8,
+             angle = 0,
              vertexColor="black",
              vertexSize=6,
              vertexLabelKey=None,
@@ -7832,6 +7894,8 @@ class Graph:
             For example, if the length of the edge is 10, the sagitta is set to 0.5, and absolute is set to False, the sagitta length will be 5. The default is True.
         sides : int , optional
             The number of sides of the arc. The default is 8.
+        angle : float, optional
+            An additional angle in degrees to rotate arcs (where sagitta is more than 0). The default is 0.
         vertexColor : str , optional
             The desired color of the output vertices. This can be any plotly color string and may be specified as:
             - A hex string (e.g. '#ff0000')
@@ -7933,7 +7997,7 @@ class Graph:
             print("Graph.Show - Error: The input graph is not a valid graph. Returning None.")
             return None
         
-        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides, vertexColor=vertexColor, vertexSize=vertexSize, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabels=showVertexLabels, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeWidth=edgeWidth, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabels=showEdgeLabels, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexSize=vertexSize, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabels=showVertexLabels, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeWidth=edgeWidth, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabels=showEdgeLabels, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
         fig = Plotly.FigureByData(data, width=width, height=height, xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize, backgroundColor=backgroundColor,
                                   marginLeft=marginLeft, marginRight=marginRight, marginTop=marginTop, marginBottom=marginBottom, tolerance=tolerance)
         Plotly.Show(fig, renderer=renderer, camera=camera, center=center, up=up, projection=projection)
@@ -8173,7 +8237,7 @@ class Graph:
         vertices = []
         if graph:
             try:
-                _ = graph.Vertices(vertices) # Hook to core libraries
+                _ = graph.Vertices(vertices) # Hook to Core
             except:
                 vertices = []
         if not vertexKey == None:

topologicpy/Grid.py

@@ -202,11 +202,10 @@ class Grid():
                     e.SetDictionary(d)
                     gridEdges.append(e)
                 elif Topology.Type(e) > Topology.TypeID("Edge"):
-                    tempEdges = []
-                    _ = e.Edges(None, tempEdges)
+                    tempEdges = Topology.Edges(e)
                     for tempEdge in tempEdges:
                         d = Dictionary.ByKeysValues(["dir", "offset"],["v",v])
-                        tempEdge.SetDictionary(d)
+                        tempEdge = Topology.SetDictionary(tempEdge, d)
                         gridEdges.append(tempEdge)
         grid = None
         if len(gridEdges) > 0:

topologicpy/Honeybee.py

@@ -254,8 +254,7 @@ class Honeybee:
         from topologicpy.Dictionary import Dictionary
 
         def cellFloor(cell):
-            faces = []
-            _ = cell.Faces(None, faces)
+            faces = Topology.Faces(cell)
             c = [x.CenterOfMass().Z() for x in faces]
             return round(min(c),2)
 
@@ -293,8 +292,7 @@ class Honeybee:
         if not Topology.IsInstance(tpBuilding, "Topology"):
             return None
         rooms = []
-        tpCells = []
-        _ = tpBuilding.Cells(None, tpCells)
+        tpCells = Topology.Cells(tpBuilding)
         # Sort cells by Z Levels
         tpCells.sort(key=lambda c: cellFloor(c), reverse=False)
         fl = floorLevels(tpCells, 2)
@@ -351,14 +349,13 @@ class Honeybee:
                 constr_set = constr_set_lib.construction_set_by_identifier("Default Generic Construction Set")
             spaceNames.append(tpCellName)
 
-            tpCellFaces = []
-            _ = tpCell.Faces(None, tpCellFaces)
+            tpCellFaces = Topology.Faces(tpCell)
             if tpCellFaces:
                 hbRoomFaces = []
                 for tpFaceNumber, tpCellFace in enumerate(tpCellFaces):
                     tpCellFaceNormal = Face.Normal(tpCellFace, mantissa=mantissa)
                     hbRoomFacePoints = []
-                    tpFaceVertices = Wire.Vertices(Face.ExternalBoundary(tpCellFace))
+                    tpFaceVertices = Topology.Vertices(Face.ExternalBoundary(tpCellFace))
                     for tpVertex in tpFaceVertices:
                         hbRoomFacePoints.append(Point3D(Vertex.X(tpVertex, mantissa=mantissa), Vertex.Y(tpVertex, mantissa=mantissa), Vertex.Z(tpVertex, mantissa=mantissa)))
                     hbRoomFace = HBFace(tpCellName+'_Face_'+str(tpFaceNumber+1), Face3D(hbRoomFacePoints))
@@ -372,7 +369,7 @@ class Honeybee:
                                 tpFaceApertureType = Dictionary.ValueAtKey(tpFaceApertureDictionary,apertureKeyName)
                             hbFaceAperturePoints = []
                             tpFaceApertureVertices = []
-                            tpFaceApertureVertices = Wire.Vertices(Face.ExternalBoundary(apertureTopology))
+                            tpFaceApertureVertices = Topology.Vertices(Face.ExternalBoundary(apertureTopology))
                             for tpFaceApertureVertex in tpFaceApertureVertices:
                                 hbFaceAperturePoints.append(Point3D(Vertex.X(tpFaceApertureVertex, mantissa=mantissa), Vertex.Y(tpFaceApertureVertex, mantissa=mantissa), Vertex.Z(tpFaceApertureVertex, mantissa=mantissa)))
                             if(tpFaceApertureType):
@@ -420,7 +417,7 @@ class Honeybee:
             tpShadingFaces = Topology.SubTopologies(tpShadingFacesCluster, subTopologyType="face")
             for faceIndex, tpShadingFace in enumerate(tpShadingFaces):
                 faceVertices = []
-                faceVertices = Wire.Vertices(Face.ExternalBoundary(tpShadingFace))
+                faceVertices = Topology.Vertices(Face.ExternalBoundary(tpShadingFace))
                 facePoints = []
                 for aVertex in faceVertices:
                     facePoints.append(Point3D(Vertex.X(aVertex, mantissa=mantissa), Vertex.Y(aVertex, mantissa=mantissa), Vertex.Z(aVertex, mantissa=mantissa)))

topologicpy/Plotly.py

@@ -276,6 +276,7 @@ class Plotly:
                     sagitta: float = 0,
                     absolute: bool = False,
                     sides: int = 8,
+                    angle: float = 0,
                     vertexColor: str = "black",
                     vertexSize: float = 6,
                     vertexLabelKey: str = None,
@@ -370,6 +371,7 @@ class Plotly:
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
         from topologicpy.Graph import Graph
+        from topologicpy.Color import Color
         import plotly.graph_objs as go
 
         if not Topology.IsInstance(graph, "Graph"):
@@ -377,6 +379,7 @@ class Plotly:
         v_labels = []
         v_groupList = []
         data = []
+        
         if showVertices:
             vertices = Graph.Vertices(graph)
             if vertexLabelKey or vertexGroupKey:
@@ -452,9 +455,12 @@ class Plotly:
                     d = Topology.Dictionary(edge)
                     arc = Wire.ArcByEdge(edge, sagitta=sagitta, absolute=absolute, sides=sides, close=False, silent=silent)
                     if Topology.IsInstance(arc, "Wire"):
+                        if not angle == 0:
+                            direc = Edge.Direction(edge)
+                            arc = Topology.Rotate(arc, origin=Topology.Centroid(edge), axis=direc, angle=angle)
                         arc_edges = Topology.Edges(arc)
                         for arc_edge in arc_edges:
-                            arc_edge = Topology.SetDictionary(arc_edge, d, silent=silent)
+                            arc_edge = Topology.SetDictionary(arc_edge, d, silent=True)
                             new_edges.append(arc_edge)
                     else:
                         new_edges.append(edge)
@@ -473,9 +479,14 @@ class Plotly:
                     d = Topology.Dictionary(e)
                     if d:
                         if not edgeLabelKey == None:
-                            e_label = str(Dictionary.ValueAtKey(d, key=edgeLabelKey)) or ""
+                            e_label = str(Dictionary.ValueAtKey(d, key=edgeLabelKey))
+                            if e_label == None:
+                                e_label = ""
                         if not edgeGroupKey == None:
-                            e_group = str(Dictionary.ValueAtKey(d, key=edgeGroupKey)) or ""
+                            if edgeGroupKey:
+                                e_group = Dictionary.ValueAtKey(d, key=edgeGroupKey)
+                                if e_group == None:
+                                    e_group = ""
                     try:
                         e_groupList.append(edgeGroups.index(e_group))
                     except:
@@ -491,6 +502,7 @@ class Plotly:
                     Ye+=[Vertex.Y(sv, mantissa=mantissa), Vertex.Y(ev, mantissa=mantissa), None] # y-coordinates of edge ends
                     Ze+=[Vertex.Z(sv, mantissa=mantissa), Vertex.Z(ev, mantissa=mantissa), None] # z-coordinates of edge ends
 
+
             if len(list(set(e_groupList))) < 2:
                 e_groupList = edgeColor
             if len(e_labels) < 1:
@@ -500,6 +512,19 @@ class Plotly:
                 mode = "lines+text"
             else:
                 mode = "lines"
+            
+            final_categories = edgeColor # Start with the default edgeColor
+            if len(edgeGroups) > 0:
+                # Normalize categories to a range between 0 and 1 for the color scale
+                min_category = 0
+                max_category = max(len(edgeGroups), 1)
+                normalized_categories = [(cat - min_category) / (max_category - min_category) for cat in e_groupList]
+
+                final_categories = []
+                for c in normalized_categories:
+                    color = Color.ByValueInRange(c, minValue=0, maxValue=1, colorScale=colorScale)
+                    color = "rgb("+str(color[0])+","+str(color[1])+","+str(color[2])+")"
+                    final_categories.append(color)
             e_trace=go.Scatter3d(x=Xe,
                                  y=Ye,
                                  z=Ze,
@@ -508,12 +533,12 @@ class Plotly:
                                  legendgroup=5,
                                  legendrank=5,
                                  showlegend=showEdgeLegend,
-                                 line=dict(color=e_groupList, width=edgeWidth),
+                                 line=dict(color=final_categories, colorscale=Plotly.ColorScale(colorScale), cmin=0, cmax=1, width=edgeWidth),
                                  text=e_labels,
                                  hoverinfo='text'
                                 )
             data.append(e_trace)
-
+        
         return data
 
     @staticmethod
@@ -1022,7 +1047,7 @@ class Plotly:
                                 d = Topology.Dictionary(tp_face)
                                 f_dictionaries.append(d)
                                 if d:
-                                    _ = Topology.SetDictionary(tri, d)
+                                    tri = Topology.SetDictionary(tri, d)
                             all_triangles.append(tri)
                 if len(all_triangles) > 0:
                     f_cluster = Cluster.ByTopologies(all_triangles)

topologicpy/Shell.py

@@ -182,7 +182,7 @@ class Shell():
 
             shell = Topology.Slice(internalBoundary, skeleton_cluster, tolerance=tolerance)
             if mergeJunctions == True:
-                vertices = Shell.Vertices(shell)
+                vertices = Topology.Vertices(shell)
                 centers = []
                 used = []
                 for v in vertices:
@@ -264,7 +264,7 @@ class Shell():
                     s = Topology.InternalVertex(f, tolerance=tolerance)
                     s = Topology.SetDictionary(s, d)
                     selectors.append(s)
-                _ = Topology.TransferDictionariesBySelectors(topology=shell, selectors=selectors, tranFaces=True, tolerance=tolerance)
+                shell = Topology.TransferDictionariesBySelectors(topology=shell, selectors=selectors, tranFaces=True, tolerance=tolerance)
             return shell
         return None
 
@@ -330,8 +330,7 @@ class Shell():
 
         if not Topology.IsInstance(cluster, "Cluster"):
             return None
-        faces = []
-        _ = cluster.Faces(None, faces)
+        faces = Topology.Faces(cluster)
         return Shell.ByFaces(faces, tolerance=tolerance)
 
     @staticmethod
@@ -619,7 +618,7 @@ class Shell():
             origin = Topology.Centroid(face)
             normal = Face.Normal(face, mantissa=mantissa)
             flatFace = Topology.Flatten(face, origin=origin, direction=normal)
-            faceVertices = Face.Vertices(face)
+            faceVertices = Topology.Vertices(face)
             vertices += faceVertices
 
             # Create a cluster of the input vertices
@@ -628,7 +627,7 @@ class Shell():
             # Flatten the cluster using the same transformations
             verticesCluster = Topology.Flatten(verticesCluster, origin=origin, direction=normal)
 
-            vertices = Cluster.Vertices(verticesCluster)
+            vertices = Topology.Vertices(verticesCluster)
         points = []
         for v in vertices:
             points.append([Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa)])
@@ -682,7 +681,7 @@ class Shell():
         if not Topology.IsInstance(shell, "Shell"):
             return None
         edges = []
-        _ = shell.Edges(None, edges)
+        _ = shell.Edges(None, edges) # Hook to Core
         return edges
 
     @staticmethod
@@ -708,12 +707,10 @@ class Shell():
 
         if not Topology.IsInstance(shell, "Shell"):
             return None
-        edges = []
-        _ = shell.Edges(None, edges)
+        edges = Topology.Edges(shell)
         obEdges = []
         for anEdge in edges:
-            faces = []
-            _ = anEdge.Faces(shell, faces)
+            faces = Topology.SuperTopologies(anEdge, shell, topologyType="face")
             if len(faces) == 1:
                 obEdges.append(anEdge)
         return Topology.SelfMerge(Cluster.ByTopologies(obEdges), tolerance=tolerance)
@@ -1748,7 +1745,7 @@ class Shell():
             if isinstance(wire, list):
                 points = wire
             else:
-                points = Wire.Vertices(wire)
+                points = Topology.Vertices(wire)
                 # points.insert(0, points.pop())
             if len(points) <= 2:
                 return points
@@ -1937,7 +1934,7 @@ class Shell():
             points.append([Vertex.X(flatVertex, mantissa=mantissa), Vertex.Y(flatVertex, mantissa=mantissa)])
 
         br = Wire.BoundingRectangle(flatFace)
-        br_vertices = Wire.Vertices(br)
+        br_vertices = Topology.Vertices(br)
         br_x = []
         br_y = []
         for br_v in br_vertices: