topologicpy 0.7.66__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
@@ -1631,7 +1631,7 @@ class Graph:
                   edgeValidateMaskHeader="val_mask", edgeTestMaskHeader="test_mask", edgeFeaturesHeader="feat", edgeFeaturesKeys=[],
                   nodeIDHeader="node_id", nodeLabelHeader="label", nodeTrainMaskHeader="train_mask", 
                   nodeValidateMaskHeader="val_mask", nodeTestMaskHeader="test_mask", nodeFeaturesHeader="feat", nodeXHeader="X", nodeYHeader="Y", nodeZHeader="Z",
-                  nodeFeaturesKeys=[], tolerance=0.0001):
+                  nodeFeaturesKeys=[], tolerance=0.0001, silent=False):
         """
         Returns graphs according to the input folder path. This method assumes the CSV files follow DGL's schema.
 
@@ -1681,6 +1681,8 @@ class Graph:
             The column header string used to specify the Z coordinate of nodes. The default is "Z".
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
@@ -1717,15 +1719,18 @@ class Graph:
             return graphs_path, edges_path, nodes_path
 
         if not exists(path):
-            print("Graph.ByCSVPath - Error: the input path parameter does not exists. Returning None.")
+            if not silent:
+                print("Graph.ByCSVPath - Error: the input path parameter does not exists. Returning None.")
             return None
         if not isdir(path):
-            print("Graph.ByCSVPath - Error: the input path parameter is not a folder. Returning None.")
+            if not silent:
+                print("Graph.ByCSVPath - Error: the input path parameter is not a folder. Returning None.")
             return None
         
         yaml_files = find_yaml_files(path)
         if len(yaml_files) < 1:
-            print("Graph.ByCSVPath - Error: the input path parameter does not contain any valid YAML files. Returning None.")
+            if not silent:
+                print("Graph.ByCSVPath - Error: the input path parameter does not contain any valid YAML files. Returning None.")
             return None
         yaml_file = yaml_files[0]
         yaml_file_path = os.path.join(path, yaml_file)
@@ -1734,7 +1739,8 @@ class Graph:
         if not graphs_path == None:
             graphs_path = os.path.join(path, graphs_path)
         if graphs_path == None:
-            print("Graph.ByCSVPath - Warning: a graphs.csv file does not exist inside the folder specified by the input path parameter. Will assume the dataset includes only one graph.")
+            if not silent:
+                print("Graph.ByCSVPath - Warning: a graphs.csv file does not exist inside the folder specified by the input path parameter. Will assume the dataset includes only one graph.")
             graphs_df = pd.DataFrame()
             graph_ids=[0]
             graph_labels=[0]
@@ -1748,7 +1754,8 @@ class Graph:
         if not edges_path == None:
             edges_path = os.path.join(path, edges_path)
         if not exists(edges_path):
-            print("Graph.ByCSVPath - Error: an edges.csv file does not exist inside the folder specified by the input path parameter. Returning None.")
+            if not silent:
+                print("Graph.ByCSVPath - Error: an edges.csv file does not exist inside the folder specified by the input path parameter. Returning None.")
             return None
         edges_path = os.path.join(path, edges_path)
         edges_df = pd.read_csv(edges_path)
@@ -1756,7 +1763,8 @@ class Graph:
         if not nodes_path == None:
             nodes_path = os.path.join(path, nodes_path)
         if not exists(nodes_path):
-            print("Graph.ByCSVPath - Error: a nodes.csv file does not exist inside the folder specified by the input path parameter. Returning None.")
+            if not silent:
+                print("Graph.ByCSVPath - Error: a nodes.csv file does not exist inside the folder specified by the input path parameter. Returning None.")
             return None
         nodes_df = pd.read_csv(nodes_path)
         # Group nodes and nodes by their 'graph_id'
@@ -1830,10 +1838,12 @@ class Graph:
                     if Topology.IsInstance(d, "Dictionary"):
                         v = Topology.SetDictionary(v, d)
                     else:
-                        print("Graph.ByCSVPath - Warning: Failed to create and add a dictionary to the created vertex.")
+                        if not silent:
+                            print("Graph.ByCSVPath - Warning: Failed to create and add a dictionary to the created vertex.")
                     vertices.append(v)
                 else:
-                    print("Graph.ByCSVPath - Warning: Failed to create and add a vertex to the list of vertices.")
+                    if not silent:
+                        print("Graph.ByCSVPath - Warning: Failed to create and add a vertex to the list of vertices.")
             vertices_ds.append(vertices)
         edges_ds = [] # A list to hold the vertices data structures until we can build the actual graphs
         # Access specific columns within the grouped DataFrame
@@ -1870,21 +1880,25 @@ class Graph:
                     try:
                         edge = Edge.ByVertices([vertices[src_id], vertices[dst_id]], tolerance=tolerance)
                     except:
-                        print("Graph.ByCSVPath - Warning: Failed to create and add a edge to the list of edges.")
+                        if not silent:
+                            print("Graph.ByCSVPath - Warning: Failed to create and add a edge to the list of edges.")
                         edge = None
                     if Topology.IsInstance(edge, "Edge"):
                         d = Dictionary.ByKeysValues(edge_keys, values)
                         if Topology.IsInstance(d, "Dictionary"):
                             edge = Topology.SetDictionary(edge, d)
                         else:
-                            print("Graph.ByCSVPath - Warning: Failed to create and add a dictionary to the created edge.")
+                            if not silent:
+                                print("Graph.ByCSVPath - Warning: Failed to create and add a dictionary to the created edge.")
                         edges.append(edge)
                     else:
-                        print("Graph.ByCSVPath - Warning: Failed to create and add an edge to the list of edges.")
+                        if not silent:
+                            print("Graph.ByCSVPath - Warning: Failed to create and add an edge to the list of edges.")
                 else:
                     duplicate_edges += 1
             if duplicate_edges > 0:
-                print("Graph.ByCSVPath - Warning: Found", duplicate_edges, "duplicate edges in graph id:", graph_id)
+                if not silent:
+                    print("Graph.ByCSVPath - Warning: Found", duplicate_edges, "duplicate edges in graph id:", graph_id)
             edges_ds.append(edges)
         
         # Build the graphs
@@ -1905,16 +1919,19 @@ class Graph:
                 l1 = len(graph_keys)
                 l2 = len(values)
                 if not l1 == l2:
-                    print("Graph.ByCSVPath - Error: The length of the keys and values lists do not match. Returning None.")
+                    if not silent:
+                        print("Graph.ByCSVPath - Error: The length of the keys and values lists do not match. Returning None.")
                     return None
                 d = Dictionary.ByKeysValues(graph_keys, values)
                 if Topology.IsInstance(d, "Dictionary"):
                     g = Graph.SetDictionary(g, d)
                 else:
-                    print("Graph.ByCSVPath - Warning: Failed to create and add a dictionary to the created graph.")
+                    if not silent:
+                        print("Graph.ByCSVPath - Warning: Failed to create and add a dictionary to the created graph.")
                 graphs.append(g)
             else:
-                print("Graph.ByCSVPath - Error: Failed to create and add a graph to the list of graphs.")
+                if not silent:
+                    print("Graph.ByCSVPath - Error: Failed to create and add a graph to the list of graphs.")
         return {"graphs": graphs, "labels": graph_labels, "features": graph_features}
     
     @staticmethod
@@ -3485,142 +3502,6 @@ class Graph:
             return [graph_vertices, graph_edges]
 
 
-
-
-
-
-        # def processEdge(item):
-        #     topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
-        #     vertices = []
-        #     edges = []
-
-        #     if useInternalVertex == True:
-        #         try:
-        #             vEdge = Edge.VertexByParameter(topology, 0.5)
-        #         except:
-        #             vEdge = topology.CenterOfMass()
-        #     else:
-        #         vEdge = topology.CenterOfMass()
-
-        #     d1 = vEdge.GetDictionary()
-        #     d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 0) # main topology
-        #     if storeBREP:
-        #         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(topology), Topology.Type(topology), Topology.TypeAsString(topology)])
-        #         d3 = mergeDictionaries2([d1, d2])
-        #         _ = vEdge.SetDictionary(d3)
-        #     else:
-        #         _ = vEdge.SetDictionary(topology.GetDictionary())
-
-        #     vertices.append(vEdge)
-
-        #     if toOutposts and others:
-        #         d = Topology.Dictionary(topology)
-        #         if not d == None:
-        #             keys = Dictionary.Keys(d)
-        #         else:
-        #             keys = []
-        #         k = None
-        #         for key in keys:
-        #             if key.lower() == outpostsKey.lower():
-        #                 k = key
-        #         if k:
-        #             ids = Dictionary.ValueAtKey(d, k)
-        #             outposts = outpostsByID(others, ids, idKey)
-        #         else:
-        #             outposts = []
-        #         for outpost in outposts:
-        #             if useInternalVertex == True:
-        #                 vop = Topology.InternalVertex(outpost, tolerance)
-        #             else:
-        #                 vop = Topology.CenterOfMass(outpost)
-        #             tempe = Edge.ByStartVertexEndVertex(vEdge, vop, tolerance=tolerance)
-        #             tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Outposts", 6])
-        #             _ = tempe.SetDictionary(tempd)
-        #             edges.append(tempe)
-            
-        #     if (toExteriorTopologies == True) or (toExteriorApertures == True) or (toContents == True):
-        #         eVertices = []
-        #         _ = topology.Vertices(None, eVertices)
-        #         exteriorTopologies = []
-        #         exteriorApertures = []
-        #         for aVertex in eVertices:
-        #             exteriorTopologies.append(aVertex)
-        #             apertures = Topology.Apertures(aVertex)
-        #             for anAperture in apertures:
-        #                 exteriorApertures.append(anAperture)
-        #             if toExteriorTopologies:
-        #                 for exteriorTopology in exteriorTopologies:
-        #                     if useInternalVertex == True:
-        #                         vst = Topology.InternalVertex(exteriorTopology, tolerance)
-        #                     else:
-        #                         vst = exteriorTopology.CenterOfMass()
-        #                     d1 = exteriorTopology.GetDictionary()
-        #                     d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 3) # exterior topology
-        #                     if storeBREP:
-        #                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exteriorTopology), Topology.Type(exteriorTopology), Topology.TypeAsString(exteriorTopology)])
-        #                         d3 = mergeDictionaries2([d1, d2])
-        #                         _ = vst.SetDictionary(d3)
-        #                     else:
-        #                         _ = vst.SetDictionary(d1)
-        #                     vertices.append(vst)
-        #                     tempe = Edge.ByStartVertexEndVertex(vEdge, vst, tolerance=tolerance)
-        #                     tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Exterior_Topologies", 3])
-        #                     _ = tempe.SetDictionary(tempd)
-        #                     edges.append(tempe)
-        #                     if toContents:
-        #                         contents = []
-        #                         _ = vst.Contents(contents)
-        #                         for content in contents:
-        #                             if Topology.IsInstance(content, "Aperture"):
-        #                                 content = Aperture.Topology(content)
-        #                             if useInternalVertex == True:
-        #                                 vst2 = Topology.InternalVertex(content, tolerance)
-        #                             else:
-        #                                 vst2 = content.CenterOfMass()
-        #                             vst2 = Vertex.ByCoordinates(Vertex.X(vst2, mantissa=mantissa)+(tolerance*100), Vertex.Y(vst2, mantissa=mantissa)+(tolerance*100), Vertex.Z(vst2, mantissa=mantissa)+(tolerance*100))
-        #                             d1 = content.GetDictionary()
-        #                             d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 5) # content
-        #                             if storeBREP:
-        #                                 d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(content), Topology.Type(content), Topology.TypeAsString(content)])
-        #                                 d3 = mergeDictionaries2([d1, d2])
-        #                                 _ = vst2.SetDictionary(d3)
-        #                             else:
-        #                                 _ = vst2.SetDictionary(d1)
-        #                             vertices.append(vst2)
-        #                             tempe = Edge.ByStartVertexEndVertex(vst, vst2, tolerance=tolerance)
-        #                             tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Contents", 5])
-        #                             _ = tempe.SetDictionary(tempd)
-        #                             edges.append(tempe)
-        #             if toExteriorApertures:
-        #                 for exTop in exteriorApertures:
-        #                     if useInternalVertex == True:
-        #                         vst = Topology.InternalVertex(exTop, tolerance)
-        #                     else:
-        #                         vst = exTop.CenterOfMass()
-        #                     d1 = exTop.GetDictionary()
-        #                     d1 = Dictionary.SetValueAtKey(d1, vertexCategoryKey, 4) # exterior aperture
-        #                     vst = Vertex.ByCoordinates(Vertex.X(vst, mantissa=mantissa)+(tolerance*100), Vertex.Y(vst, mantissa=mantissa)+(tolerance*100), Vertex.Z(vst, mantissa=mantissa)+(tolerance*100))
-        #                     if storeBREP:
-        #                         d2 = Dictionary.ByKeysValues(["brep", "brepType", "brepTypeString"], [Topology.BREPString(exTop), Topology.Type(exTop), Topology.TypeAsString(exTop)])
-        #                         d3 = mergeDictionaries2([d1, d2])
-        #                         _ = vst.SetDictionary(d3)
-        #                     else:
-        #                         _ = vst.SetDictionary(d1)
-        #                     _ = vst.SetDictionary(exTop.GetDictionary())
-        #                     vertices.append(vst)
-        #                     tempe = Edge.ByStartVertexEndVertex(vEdge, vst, tolerance=tolerance)
-        #                     tempd = Dictionary.ByKeysValues(["relationship", edgeCategoryKey],["To_Exterior_Apertures", 4])
-        #                     _ = tempe.SetDictionary(tempd)
-        #                     edges.append(tempe)
-                    
-        #     return [vertices, edges]
-
-
-
-
-
-
-
         def processVertex(item):
             topology, others, outpostsKey, idKey, direct, directApertures, viaSharedTopologies, viaSharedApertures, toExteriorTopologies, toExteriorApertures, toContents, toOutposts, useInternalVertex, storeBREP, tolerance = item
             vertices = [topology]
@@ -4158,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
@@ -4298,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
@@ -4612,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")]
@@ -4620,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
@@ -5645,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.
 
@@ -5655,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
@@ -5665,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.
 
@@ -5831,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.
@@ -5969,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']
@@ -6299,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
@@ -7700,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
@@ -7732,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
@@ -7767,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
@@ -8292,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)))