topologicpy 0.7.67__py3-none-any.whl → 0.7.68__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
@@ -8173,7 +8234,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

@@ -370,6 +370,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 +378,7 @@ class Plotly:
         v_labels = []
         v_groupList = []
         data = []
+        
         if showVertices:
             vertices = Graph.Vertices(graph)
             if vertexLabelKey or vertexGroupKey:
@@ -454,7 +456,7 @@ class Plotly:
                     if Topology.IsInstance(arc, "Wire"):
                         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 +475,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 +498,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 +508,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 +529,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 +1043,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: